Добавление объявлений для inline методов в единицах трансляции в соответствии со стандартом C99
This commit is contained in:
parent
e39765b733
commit
6c0ae92ed4
14 changed files with 646 additions and 1 deletions
|
|
@ -1,3 +1,67 @@
|
|||
#include "utilities.h"
|
||||
#include "angle.h"
|
||||
|
||||
// !================= Radians ==================! //
|
||||
|
||||
extern inline float bgc_radians_to_degrees_fp32(const float radians);
|
||||
extern inline double bgc_radians_to_degrees_fp64(const double radians);
|
||||
|
||||
extern inline float bgc_radians_to_turns_fp32(const float radians);
|
||||
extern inline double bgc_radians_to_turns_fp64(const double radians);
|
||||
|
||||
extern inline float bgc_radians_to_units_fp32(const float radians, const BgcAngleUnitEnum to_unit);
|
||||
extern inline double bgc_radians_to_units_fp64(const double radians, const BgcAngleUnitEnum to_unit);
|
||||
|
||||
extern inline float bgc_radians_normalize_fp32(const float radians, const BgcAngleRangeEnum range);
|
||||
extern inline double bgc_radians_normalize_fp64(const double radians, const BgcAngleRangeEnum range);
|
||||
|
||||
// !================= Degrees ==================! //
|
||||
|
||||
extern inline float bgc_degrees_to_radians_fp32(const float degrees);
|
||||
extern inline double bgc_degrees_to_radians_fp64(const double degrees);
|
||||
|
||||
extern inline float bgc_degrees_to_turns_fp32(const float radians);
|
||||
extern inline double bgc_degrees_to_turns_fp64(const double radians);
|
||||
|
||||
extern inline float bgc_degrees_to_units_fp32(const float degrees, const BgcAngleUnitEnum to_unit);
|
||||
extern inline double bgc_degrees_to_units_fp64(const double degrees, const BgcAngleUnitEnum to_unit);
|
||||
|
||||
extern inline float bgc_degrees_normalize_fp32(const float degrees, const BgcAngleRangeEnum range);
|
||||
extern inline double bgc_degrees_normalize_fp64(const double degrees, const BgcAngleRangeEnum range);
|
||||
|
||||
// !================== Turns ===================! //
|
||||
|
||||
extern inline float bgc_turns_to_radians_fp32(const float turns);
|
||||
extern inline double bgc_turns_to_radians_fp64(const double turns);
|
||||
|
||||
extern inline float bgc_turns_to_degrees_fp32(const float turns);
|
||||
extern inline double bgc_turns_to_degrees_fp64(const double turns);
|
||||
|
||||
extern inline float bgc_turns_to_units_fp32(const float turns, const BgcAngleUnitEnum to_unit);
|
||||
extern inline double bgc_turns_to_units_fp64(const double turns, const BgcAngleUnitEnum to_unit);
|
||||
|
||||
extern inline float bgc_turns_normalize_fp32(const float turns, const BgcAngleRangeEnum range);
|
||||
extern inline double bgc_turns_normalize_fp64(const double turns, const BgcAngleRangeEnum range);
|
||||
|
||||
// !================== Angle ===================! //
|
||||
|
||||
extern inline float bgc_angle_to_radians_fp32(const float angle, const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_to_radians_fp64(const double angle, const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_to_degrees_fp32(const float angle, const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_to_degrees_fp64(const double angle, const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_to_turns_fp32(const float angle, const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_to_turns_fp64(const double angle, const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_get_full_circle_fp32(const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_get_full_circle_fp64(const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_get_half_circle_fp32(const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_get_half_circle_fp64(const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_get_quater_circle_fp32(const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_angle_get_quater_circle_fp64(const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline float bgc_angle_normalize_fp32(const float angle, const BgcAngleUnitEnum unit, const BgcAngleRangeEnum range);
|
||||
extern inline double bgc_angle_normalize_fp64(const double angle, const BgcAngleUnitEnum unit, const BgcAngleRangeEnum range);
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ inline float bgc_degrees_to_turns_fp32(const float radians)
|
|||
return radians * BGC_TURNS_IN_DEGREE_FP32;
|
||||
}
|
||||
|
||||
inline double fp64_degrees_to_turns(const double radians)
|
||||
inline double bgc_degrees_to_turns_fp64(const double radians)
|
||||
{
|
||||
return radians * BGC_TURNS_IN_DEGREE_FP64;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1 +1,73 @@
|
|||
#include "matrix2x2.h"
|
||||
|
||||
extern inline void bgc_matrix2x2_reset_fp32(BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_reset_fp64(BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_to_identity_fp32(BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_to_identity_fp64(BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_to_diagonal_fp32(const float d1, const float d2, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_to_diagonal_fp64(const double d1, const double d2, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_make_rotation_fp32(const float angle, const BgcAngleUnitEnum unit, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_make_rotation_fp64(const double angle, const BgcAngleUnitEnum unit, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_copy_fp32(const BgcMatrix2x2FP32* from, BgcMatrix2x2FP32* to);
|
||||
extern inline void bgc_matrix2x2_copy_fp64(const BgcMatrix2x2FP64* from, BgcMatrix2x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x2_swap_fp32(BgcMatrix2x2FP32* matrix1, BgcMatrix2x2FP32* matrix2);
|
||||
extern inline void bgc_matrix2x2_swap_fp64(BgcMatrix2x2FP64* matrix1, BgcMatrix2x2FP64* matrix2);
|
||||
|
||||
extern inline void bgc_matrix2x2_convert_fp64_to_fp32(const BgcMatrix2x2FP64* from, BgcMatrix2x2FP32* to);
|
||||
extern inline void bgc_matrix2x2_convert_fp32_to_fp64(const BgcMatrix2x2FP32* from, BgcMatrix2x2FP64* to);
|
||||
|
||||
extern inline float bgc_matrix2x2_get_determinant_fp32(const BgcMatrix2x2FP32* matrix);
|
||||
extern inline double bgc_matrix2x2_get_determinant_fp64(const BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline int bgc_matrix2x2_is_singular_fp32(const BgcMatrix2x2FP32* matrix);
|
||||
extern inline int bgc_matrix2x2_is_singular_fp64(const BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_transpose_fp32(BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_transpose_fp64(BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline int bgc_matrix2x2_invert_fp32(BgcMatrix2x2FP32* matrix);
|
||||
extern inline int bgc_matrix2x2_invert_fp64(BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_transposed_fp32(const BgcMatrix2x2FP32* from, BgcMatrix2x2FP32* to);
|
||||
extern inline void bgc_matrix2x2_set_transposed_fp64(const BgcMatrix2x2FP64* from, BgcMatrix2x2FP64* to);
|
||||
|
||||
extern inline int bgc_matrix2x2_set_inverted_fp32(const BgcMatrix2x2FP32* from, BgcMatrix2x2FP32* to);
|
||||
extern inline int bgc_matrix2x2_set_inverted_fp64(const BgcMatrix2x2FP64* from, BgcMatrix2x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_row1_fp32(const float c1, const float c2, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_row1_fp64(const double c1, const double c2, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_row2_fp32(const float c1, const float c2, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_row2_fp64(const double c1, const double c2, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_column1_fp32(const float r1, const float r2, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_column1_fp64(const double r1, const double r2, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_set_column2_fp32(const float r1, const float r2, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_matrix2x2_set_column2_fp64(const double r1, const double r2, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x2_add_fp32(const BgcMatrix2x2FP32* matrix1, const BgcMatrix2x2FP32* matrix2, BgcMatrix2x2FP32* sum);
|
||||
extern inline void bgc_matrix2x2_add_fp64(const BgcMatrix2x2FP64* matrix1, const BgcMatrix2x2FP64* matrix2, BgcMatrix2x2FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix2x2_add_scaled_fp32(const BgcMatrix2x2FP32* basic_matrix, const BgcMatrix2x2FP32* scalable_matrix, const float scale, BgcMatrix2x2FP32* sum);
|
||||
extern inline void bgc_matrix2x2_add_scaled_fp64(const BgcMatrix2x2FP64* basic_matrix, const BgcMatrix2x2FP64* scalable_matrix, const double scale, BgcMatrix2x2FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix2x2_subtract_fp32(const BgcMatrix2x2FP32* minuend, const BgcMatrix2x2FP32* subtrahend, BgcMatrix2x2FP32* difference);
|
||||
extern inline void bgc_matrix2x2_subtract_fp64(const BgcMatrix2x2FP64* minuend, const BgcMatrix2x2FP64* subtrahend, BgcMatrix2x2FP64* difference);
|
||||
|
||||
extern inline void bgc_matrix2x2_multiply_fp32(const BgcMatrix2x2FP32* multiplicand, const float multiplier, BgcMatrix2x2FP32* product);
|
||||
extern inline void bgc_matrix2x2_multiply_fp64(const BgcMatrix2x2FP64* multiplicand, const double multiplier, BgcMatrix2x2FP64* product);
|
||||
|
||||
extern inline void bgc_matrix2x2_divide_fp32(const BgcMatrix2x2FP32* dividend, const float divisor, BgcMatrix2x2FP32* quotient);
|
||||
extern inline void bgc_matrix2x2_divide_fp64(const BgcMatrix2x2FP64* dividend, const double divisor, BgcMatrix2x2FP64* quotient);
|
||||
|
||||
extern inline void bgc_matrix2x2_left_product_fp32(const BgcVector2FP32* vector, const BgcMatrix2x2FP32* matrix, BgcVector2FP32* result);
|
||||
extern inline void bgc_matrix2x2_left_product_fp64(const BgcVector2FP64* vector, const BgcMatrix2x2FP64* matrix, BgcVector2FP64* result);
|
||||
|
||||
extern inline void bgc_matrix2x2_right_product_fp32(const BgcMatrix2x2FP32* matrix, const BgcVector2FP32* vector, BgcVector2FP32* result);
|
||||
extern inline void bgc_matrix2x2_right_product_fp64(const BgcMatrix2x2FP64* matrix, const BgcVector2FP64* vector, BgcVector2FP64* result);
|
||||
|
|
|
|||
|
|
@ -1,2 +1,55 @@
|
|||
#include "matrix2x3.h"
|
||||
|
||||
extern inline void bgc_matrix2x3_reset_fp32(BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_reset_fp64(BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_copy_fp32(const BgcMatrix2x3FP32* from, BgcMatrix2x3FP32* to);
|
||||
extern inline void bgc_matrix2x3_copy_fp64(const BgcMatrix2x3FP64* from, BgcMatrix2x3FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x3_swap_fp32(BgcMatrix2x3FP32* matrix1, BgcMatrix2x3FP32* matrix2);
|
||||
extern inline void bgc_matrix2x3_swap_fp64(BgcMatrix2x3FP64* matrix1, BgcMatrix2x3FP64* matrix2);
|
||||
|
||||
extern inline void bgc_matrix2x3_convert_fp64_to_fp32(const BgcMatrix2x3FP64* from, BgcMatrix2x3FP32* to);
|
||||
extern inline void bgc_matrix2x3_convert_fp32_to_fp64(const BgcMatrix2x3FP32* from, BgcMatrix2x3FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_transposed_fp32(const BgcMatrix3x2FP32* from, BgcMatrix2x3FP32* to);
|
||||
extern inline void bgc_matrix2x3_set_transposed_fp64(const BgcMatrix3x2FP64* from, BgcMatrix2x3FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_transposed_fp32_fp64(const BgcMatrix3x2FP64* from, BgcMatrix2x3FP32* to);
|
||||
extern inline void bgc_matrix2x3_set_transposed_fp64_fp32(const BgcMatrix3x2FP32* from, BgcMatrix2x3FP64* to);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_row1_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_set_row1_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_row2_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_set_row2_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_row3_fp32(const float c1, const float c2, BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_set_row3_fp64(const double c1, const double c2, BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_column1_fp32(const float r1, const float r2, const float r3, BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_set_column1_fp64(const double r1, const double r2, const double r3, BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_set_column2_fp32(const float r1, const float r2, const float r3, BgcMatrix2x3FP32* matrix);
|
||||
extern inline void bgc_matrix2x3_set_column2_fp64(const double r1, const double r2, const double r3, BgcMatrix2x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix2x3_add_fp32(const BgcMatrix2x3FP32* matrix1, const BgcMatrix2x3FP32* matrix2, BgcMatrix2x3FP32* sum);
|
||||
extern inline void bgc_matrix2x3_add_fp64(const BgcMatrix2x3FP64* matrix1, const BgcMatrix2x3FP64* matrix2, BgcMatrix2x3FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix2x3_add_scaled_fp32(const BgcMatrix2x3FP32* basic_matrix, const BgcMatrix2x3FP32* scalable_matrix, const float scale, BgcMatrix2x3FP32* sum);
|
||||
extern inline void bgc_matrix2x3_add_scaled_fp64(const BgcMatrix2x3FP64* basic_matrix, const BgcMatrix2x3FP64* scalable_matrix, const double scale, BgcMatrix2x3FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix2x3_subtract_fp32(const BgcMatrix2x3FP32* minuend, const BgcMatrix2x3FP32* subtrahend, BgcMatrix2x3FP32* difference);
|
||||
extern inline void bgc_matrix2x3_subtract_fp64(const BgcMatrix2x3FP64* minuend, const BgcMatrix2x3FP64* subtrahend, BgcMatrix2x3FP64* difference);
|
||||
|
||||
extern inline void bgc_matrix2x3_multiply_fp32(const BgcMatrix2x3FP32* multiplicand, const float multiplier, BgcMatrix2x3FP32* product);
|
||||
extern inline void bgc_matrix2x3_multiply_fp64(const BgcMatrix2x3FP64* multiplicand, const double multiplier, BgcMatrix2x3FP64* product);
|
||||
|
||||
extern inline void bgc_matrix2x3_divide_fp32(const BgcMatrix2x3FP32* dividend, const float divisor, BgcMatrix2x3FP32* quotient);
|
||||
extern inline void bgc_matrix2x3_divide_fp64(const BgcMatrix2x3FP64* dividend, const double divisor, BgcMatrix2x3FP64* quotient);
|
||||
|
||||
extern inline void bgc_matrix2x3_left_product_fp32(const BgcVector3FP32* vector, const BgcMatrix2x3FP32* matrix, BgcVector2FP32* result);
|
||||
extern inline void bgc_matrix2x3_left_product_fp64(const BgcVector3FP64* vector, const BgcMatrix2x3FP64* matrix, BgcVector2FP64* result);
|
||||
|
||||
extern inline void bgc_matrix2x3_right_product_fp32(const BgcMatrix2x3FP32* matrix, const BgcVector2FP32* vector, BgcVector3FP32* result);
|
||||
extern inline void bgc_matrix2x3_right_product_fp64(const BgcMatrix2x3FP64* matrix, const BgcVector2FP64* vector, BgcVector3FP64* result);
|
||||
|
|
|
|||
|
|
@ -1,2 +1,55 @@
|
|||
#include "matrix3x2.h"
|
||||
|
||||
extern inline void bgc_matrix3x2_reset_fp32(BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_reset_fp64(BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_copy_fp32(const BgcMatrix3x2FP32* from, BgcMatrix3x2FP32* to);
|
||||
extern inline void bgc_matrix3x2_copy_fp64(const BgcMatrix3x2FP64* from, BgcMatrix3x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix3x2_swap_fp32(BgcMatrix3x2FP32* matrix1, BgcMatrix3x2FP32* matrix2);
|
||||
extern inline void bgc_matrix3x2_swap_fp64(BgcMatrix3x2FP64* matrix1, BgcMatrix3x2FP64* matrix2);
|
||||
|
||||
extern inline void bgc_matrix3x2_convert_fp64_to_fp32(const BgcMatrix3x2FP64* from, BgcMatrix3x2FP32* to);
|
||||
extern inline void bgc_matrix3x2_convert_fp32_to_fp64(const BgcMatrix3x2FP32* from, BgcMatrix3x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_transposed_fp32(const BgcMatrix2x3FP32* from, BgcMatrix3x2FP32* to);
|
||||
extern inline void bgc_matrix3x2_set_transposed_fp64(const BgcMatrix2x3FP64* from, BgcMatrix3x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_transposed_fp32_fp64(const BgcMatrix2x3FP64* from, BgcMatrix3x2FP32* to);
|
||||
extern inline void bgc_matrix3x2_set_transposed_fp64_fp32(const BgcMatrix2x3FP32* from, BgcMatrix3x2FP64* to);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_row1_fp32(const float c1, const float c2, const float c3, BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_set_row1_fp64(const double c1, const double c2, const double c3, BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_row2_fp32(const float c1, const float c2, const float c3, BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_set_row2_fp64(const double c1, const double c2, const double c3, BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_column1_fp32(const float r1, const float r2, BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_set_column1_fp64(const double r1, const double r2, BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_column2_fp32(const float r1, const float r2, BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_set_column2_fp64(const double r1, const double r2, BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_set_column3_fp32(const float r1, const float r2, BgcMatrix3x2FP32* matrix);
|
||||
extern inline void bgc_matrix3x2_set_column3_fp64(const double r1, const double r2, BgcMatrix3x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x2_add_fp32(const BgcMatrix3x2FP32* matrix1, const BgcMatrix3x2FP32* matrix2, BgcMatrix3x2FP32* sum);
|
||||
extern inline void bgc_matrix3x2_add_fp64(const BgcMatrix3x2FP64* matrix1, const BgcMatrix3x2FP64* matrix2, BgcMatrix3x2FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix3x2_add_scaled_fp32(const BgcMatrix3x2FP32* basic_matrix, const BgcMatrix3x2FP32* scalable_matrix, const float scale, BgcMatrix3x2FP32* sum);
|
||||
extern inline void bgc_matrix3x2_add_scaled_fp64(const BgcMatrix3x2FP64* basic_matrix, const BgcMatrix3x2FP64* scalable_matrix, const double scale, BgcMatrix3x2FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix3x2_subtract_fp32(const BgcMatrix3x2FP32* minuend, const BgcMatrix3x2FP32* subtrahend, BgcMatrix3x2FP32* difference);
|
||||
extern inline void bgc_matrix3x2_subtract_fp64(const BgcMatrix3x2FP64* minuend, const BgcMatrix3x2FP64* subtrahend, BgcMatrix3x2FP64* difference);
|
||||
|
||||
extern inline void bgc_matrix3x2_multiply_fp32(const BgcMatrix3x2FP32* multiplicand, const float multiplier, BgcMatrix3x2FP32* product);
|
||||
extern inline void bgc_matrix3x2_multiply_fp64(const BgcMatrix3x2FP64* multiplicand, const double multiplier, BgcMatrix3x2FP64* product);
|
||||
|
||||
extern inline void bgc_matrix3x2_divide_fp32(const BgcMatrix3x2FP32* dividend, const float divisor, BgcMatrix3x2FP32* quotient);
|
||||
extern inline void bgc_matrix3x2_divide_fp64(const BgcMatrix3x2FP64* dividend, const double divisor, BgcMatrix3x2FP64* quotient);
|
||||
|
||||
extern inline void bgc_matrix3x2_left_product_fp32(const BgcVector2FP32* vector, const BgcMatrix3x2FP32* matrix, BgcVector3FP32* result);
|
||||
extern inline void bgc_matrix3x2_left_product_fp64(const BgcVector2FP64* vector, const BgcMatrix3x2FP64* matrix, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_matrix3x2_right_product_fp32(const BgcMatrix3x2FP32* matrix, const BgcVector3FP32* vector, BgcVector2FP32* result);
|
||||
extern inline void bgc_matrix3x2_right_product_fp64(const BgcMatrix3x2FP64* matrix, const BgcVector3FP64* vector, BgcVector2FP64* result);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,74 @@
|
|||
#include "matrix3x3.h"
|
||||
|
||||
extern inline void bgc_matrix3x3_reset_fp32(BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_reset_fp64(BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_to_identity_fp32(BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_to_identity_fp64(BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_to_diagonal_fp32(const float d1, const float d2, const float d3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_to_diagonal_fp64(const double d1, const double d2, const double d3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_copy_fp32(const BgcMatrix3x3FP32* from, BgcMatrix3x3FP32* to);
|
||||
extern inline void bgc_matrix3x3_copy_fp64(const BgcMatrix3x3FP64* from, BgcMatrix3x3FP64* to);
|
||||
|
||||
extern inline void bgc_matrix3x3_swap_fp32(BgcMatrix3x3FP32* matrix1, BgcMatrix3x3FP32* matrix2);
|
||||
extern inline void bgc_matrix3x3_swap_fp64(BgcMatrix3x3FP64* matrix1, BgcMatrix3x3FP64* matrix2);
|
||||
|
||||
extern inline void bgc_matrix3x3_convert_fp64_to_fp32(const BgcMatrix3x3FP64* from, BgcMatrix3x3FP32* to);
|
||||
extern inline void bgc_matrix3x3_convert_fp32_to_fp64(const BgcMatrix3x3FP32* from, BgcMatrix3x3FP64* to);
|
||||
|
||||
extern inline float bgc_matrix3x3_get_determinant_fp32(const BgcMatrix3x3FP32* matrix);
|
||||
extern inline double bgc_matrix3x3_get_determinant_fp64(const BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline int bgc_matrix3x3_is_singular_fp32(const BgcMatrix3x3FP32* matrix);
|
||||
extern inline int bgc_matrix3x3_is_singular_fp64(const BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_transpose_fp32(BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_transpose_fp64(BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_transposed_fp32(const BgcMatrix3x3FP32* matrix, BgcMatrix3x3FP32* result);
|
||||
extern inline void bgc_matrix3x3_set_transposed_fp64(const BgcMatrix3x3FP64* matrix, BgcMatrix3x3FP64* result);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_row1_fp32(const float c1, const float c2, const float c3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_row1_fp64(const double c1, const double c2, const double c3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_row2_fp32(const float c1, const float c2, const float c3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_row2_fp64(const double c1, const double c2, const double c3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_row3_fp32(const float c1, const float c2, const float c3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_row3_fp64(const double c1, const double c2, const double c3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_column1_fp32(const float r1, const float r2, const float r3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_column1_fp64(const double r1, const double r2, const double r3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_column2_fp32(const float r1, const float r2, const float r3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_column2_fp64(const double r1, const double r2, const double r3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_set_column3_fp32(const float r1, const float r2, const float r3, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_matrix3x3_set_column3_fp64(const double r1, const double r2, const double r3, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_matrix3x3_add_fp32(const BgcMatrix3x3FP32* matrix1, const BgcMatrix3x3FP32* matrix2, BgcMatrix3x3FP32* sum);
|
||||
extern inline void bgc_matrix3x3_add_fp64(const BgcMatrix3x3FP64* matrix1, const BgcMatrix3x3FP64* matrix2, BgcMatrix3x3FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix3x3_add_scaled_fp32(const BgcMatrix3x3FP32* basic_matrix, const BgcMatrix3x3FP32* scalable_matrix, const float scale, BgcMatrix3x3FP32* sum);
|
||||
extern inline void bgc_matrix3x3_add_scaled_fp64(const BgcMatrix3x3FP64* basic_matrix, const BgcMatrix3x3FP64* scalable_matrix, const double scale, BgcMatrix3x3FP64* sum);
|
||||
|
||||
extern inline void bgc_matrix3x3_subtract_fp32(const BgcMatrix3x3FP32* minuend, const BgcMatrix3x3FP32* subtrahend, BgcMatrix3x3FP32* difference);
|
||||
extern inline void bgc_matrix3x3_subtract_fp64(const BgcMatrix3x3FP64* minuend, const BgcMatrix3x3FP64* subtrahend, BgcMatrix3x3FP64* difference);
|
||||
|
||||
extern inline void bgc_matrix3x3_multiply_fp32(const BgcMatrix3x3FP32* multiplicand, const float multiplier, BgcMatrix3x3FP32* product);
|
||||
extern inline void bgc_matrix3x3_multiply_fp64(const BgcMatrix3x3FP64* multiplicand, const double multiplier, BgcMatrix3x3FP64* product);
|
||||
|
||||
extern inline void bgc_matrix3x3_divide_fp32(const BgcMatrix3x3FP32* dividend, const float divisor, BgcMatrix3x3FP32* quotient);
|
||||
extern inline void bgc_matrix3x3_divide_fp64(const BgcMatrix3x3FP64* dividend, const double divisor, BgcMatrix3x3FP64* quotient);
|
||||
|
||||
extern inline void bgc_matrix3x3_left_product_fp32(const BgcVector3FP32* vector, const BgcMatrix3x3FP32* matrix, BgcVector3FP32* result);
|
||||
extern inline void bgc_matrix3x3_left_product_fp64(const BgcVector3FP64* vector, const BgcMatrix3x3FP64* matrix, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_matrix3x3_right_product_fp32(const BgcMatrix3x3FP32* matrix, const BgcVector3FP32* vector, BgcVector3FP32* result);
|
||||
extern inline void bgc_matrix3x3_right_product_fp64(const BgcMatrix3x3FP64* matrix, const BgcVector3FP64* vector, BgcVector3FP64* result);
|
||||
|
||||
// ================= Inversion ================== //
|
||||
|
||||
int bgc_matrix3x3_invert_fp32(BgcMatrix3x3FP32* matrix)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,8 @@
|
|||
#include "matrixes.h"
|
||||
|
||||
extern inline void bgc_matrix_product_2x2_at_2x2_fp32(const BgcMatrix2x2FP32* matrix1, const BgcMatrix2x2FP32* matrix2, BgcMatrix2x2FP32* result);
|
||||
extern inline void bgc_matrix_product_2x2_at_2x2_fp64(const BgcMatrix2x2FP64* matrix1, const BgcMatrix2x2FP64* matrix2, BgcMatrix2x2FP64* result);
|
||||
|
||||
// ========== Matrix Product 2x2 at 3x2 ========= //
|
||||
|
||||
void bgc_matrix_product_2x2_at_3x2_fp32(const BgcMatrix2x2FP32* matrix1, const BgcMatrix3x2FP32* matrix2, BgcMatrix3x2FP32* result)
|
||||
|
|
|
|||
|
|
@ -1,2 +1,61 @@
|
|||
#include "quaternion.h"
|
||||
|
||||
extern inline void bgc_quaternion_reset_fp32(BgcQuaternionFP32* quaternion);
|
||||
extern inline void bgc_quaternion_reset_fp64(BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline void bgc_quaternion_set_to_identity_fp32(BgcQuaternionFP32* quaternion);
|
||||
extern inline void bgc_quaternion_set_to_identity_fp64(BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline void bgc_quaternion_set_values_fp32(const float s0, const float x1, const float x2, const float x3, BgcQuaternionFP32* quaternion);
|
||||
extern inline void bgc_quaternion_set_values_fp64(const double s0, const double x1, const double x2, const double x3, BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline void bgc_quaternion_copy_fp32(const BgcQuaternionFP32* from, BgcQuaternionFP32* to);
|
||||
extern inline void bgc_quaternion_copy_fp64(const BgcQuaternionFP64* from, BgcQuaternionFP64* to);
|
||||
|
||||
extern inline void bgc_quaternion_swap_fp32(BgcQuaternionFP32* quarternion1, BgcQuaternionFP32* quarternion2);
|
||||
extern inline void bgc_quaternion_swap_fp64(BgcQuaternionFP64* quarternion1, BgcQuaternionFP64* quarternion2);
|
||||
|
||||
extern inline void bgc_quaternion_convert_fp64_to_fp32(const BgcQuaternionFP64* quaternion, BgcQuaternionFP32* result);
|
||||
extern inline void bgc_quaternion_convert_fp32_to_fp64(const BgcQuaternionFP32* quaternion, BgcQuaternionFP64* result);
|
||||
|
||||
extern inline void bgc_quaternion_conjugate_fp32(BgcQuaternionFP32* quaternion);
|
||||
extern inline void bgc_quaternion_conjugate_fp64(BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline void bgc_quaternion_set_conjugate_fp32(const BgcQuaternionFP32* quaternion, BgcQuaternionFP32* result);
|
||||
extern inline void bgc_quaternion_set_conjugate_fp64(const BgcQuaternionFP64* quaternion, BgcQuaternionFP64* result);
|
||||
|
||||
extern inline void bgc_quaternion_set_conjugate_fp64_to_fp32(const BgcQuaternionFP64* quaternion, BgcQuaternionFP32* result);
|
||||
extern inline void bgc_quaternion_set_conjugate_fp32_to_fp64(const BgcQuaternionFP32* quaternion, BgcQuaternionFP64* result);
|
||||
|
||||
extern inline float bgc_quaternion_get_square_modulus_fp32(const BgcQuaternionFP32* quaternion);
|
||||
extern inline double bgc_quaternion_get_square_modulus_fp64(const BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline float bgc_quaternion_get_modulus_fp32(const BgcQuaternionFP32* quaternion);
|
||||
extern inline double bgc_quaternion_get_modulus_fp64(const BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline int bgc_quaternion_normalize_fp32(BgcQuaternionFP32* quaternion);
|
||||
extern inline int bgc_quaternion_normalize_fp64(BgcQuaternionFP64* quaternion);
|
||||
|
||||
extern inline void bgc_quaternion_get_rotation_matrix_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_quaternion_get_rotation_matrix_fp64(const BgcQuaternionFP64* quaternion, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_quaternion_get_reverse_matrix_fp32(const BgcQuaternionFP32* quaternion, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_quaternion_get_reverse_matrix_fp64(const BgcQuaternionFP64* quaternion, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_quaternion_add_fp32(const BgcQuaternionFP32* quaternion1, const BgcQuaternionFP32* quaternion2, BgcQuaternionFP32* sum);
|
||||
extern inline void bgc_quaternion_add_fp64(const BgcQuaternionFP64* quaternion1, const BgcQuaternionFP64* quaternion2, BgcQuaternionFP64* sum);
|
||||
|
||||
extern inline void bgc_quaternion_add_scaled_fp32(const BgcQuaternionFP32* basic_quaternion, const BgcQuaternionFP32* scalable_quaternion, const float scale, BgcQuaternionFP32* sum);
|
||||
extern inline void bgc_quaternion_add_scaled_fp64(const BgcQuaternionFP64* basic_quaternion, const BgcQuaternionFP64* scalable_quaternion, const double scale, BgcQuaternionFP64* sum);
|
||||
|
||||
extern inline void bgc_quaternion_subtract_fp32(const BgcQuaternionFP32* minuend, const BgcQuaternionFP32* subtrahend, BgcQuaternionFP32* difference);
|
||||
extern inline void bgc_quaternion_subtract_fp64(const BgcQuaternionFP64* minuend, const BgcQuaternionFP64* subtrahend, BgcQuaternionFP64* difference);
|
||||
|
||||
extern inline void bgc_quaternion_multiply_fp32(const BgcQuaternionFP32* multiplicand, const float multipier, BgcQuaternionFP32* product);
|
||||
extern inline void bgc_quaternion_multiply_fp64(const BgcQuaternionFP64* multiplicand, const double multipier, BgcQuaternionFP64* product);
|
||||
|
||||
extern inline void bgc_quaternion_divide_fp32(const BgcQuaternionFP32* dividend, const float divisor, BgcQuaternionFP32* quotient);
|
||||
extern inline void bgc_quaternion_divide_fp64(const BgcQuaternionFP64* dividend, const double divisor, BgcQuaternionFP64* quotient);
|
||||
|
||||
extern inline void bgc_quaternion_get_product_fp32(const BgcQuaternionFP32* left, const BgcQuaternionFP32* right, BgcQuaternionFP32* product);
|
||||
extern inline void bgc_quaternion_get_product_fp64(const BgcQuaternionFP64* left, const BgcQuaternionFP64* right, BgcQuaternionFP64* product);
|
||||
|
|
|
|||
|
|
@ -3,3 +3,12 @@
|
|||
const BgcRotation3FP32 BGC_IDLE_ROTATION3_FP32 = { {0.0f, 0.0f, 0.0f}, 0.0f};
|
||||
|
||||
const BgcRotation3FP64 BGC_IDLE_ROTATION3_FP64 = { {0.0, 0.0, 0.0}, 0.0};
|
||||
|
||||
extern inline void bgc_rotation3_reset_fp32(BgcRotation3FP32* rotation);
|
||||
extern inline void bgc_rotation3_reset_fp64(BgcRotation3FP64* rotation);
|
||||
|
||||
extern inline void bgc_rotation3_set_values_fp32(const float x1, const float x2, const float x3, const float angle, const BgcAngleUnitEnum unit, BgcRotation3FP32* rotation);
|
||||
extern inline void bgc_rotation3_set_values_fp64(const double x1, const double x2, const double x3, const double angle, const BgcAngleUnitEnum unit, BgcRotation3FP64* rotation);
|
||||
|
||||
extern inline void bgc_rotation3_set_with_axis_fp32(const BgcVector3FP32* axis, const float angle, const BgcAngleUnitEnum unit, BgcRotation3FP32* rotation);
|
||||
extern inline void bgc_rotation3_set_with_axis_fp64(const BgcVector3FP64* axis, const double angle, const BgcAngleUnitEnum unit, BgcRotation3FP64* rotation);
|
||||
|
|
|
|||
|
|
@ -4,6 +4,48 @@ const BgcTangentFP32 BGC_IDLE_TANGENT_FP32 = { 1.0f, 0.0f };
|
|||
|
||||
const BgcTangentFP64 BGC_IDLE_TANGENT_FP64 = { 1.0, 0.0 };
|
||||
|
||||
extern inline void bgc_tangent_reset_fp32(BgcTangentFP32* tangent);
|
||||
extern inline void bgc_tangent_reset_fp64(BgcTangentFP64* tangent);
|
||||
|
||||
extern inline void bgc_tangent_set_values_fp32(const float x1, const float x2, BgcTangentFP32* tangent);
|
||||
extern inline void bgc_tangent_set_values_fp64(const double x1, const double x2, BgcTangentFP64* tangent);
|
||||
|
||||
extern inline void bgc_tangent_copy_fp32(const BgcTangentFP32* from, BgcTangentFP32* to);
|
||||
extern inline void bgc_tangent_copy_fp64(const BgcTangentFP64* from, BgcTangentFP64* to);
|
||||
|
||||
extern inline void bgc_tangent_swap_fp32(BgcTangentFP32* tangent1, BgcTangentFP32* tangent2);
|
||||
extern inline void bgc_tangent_swap_fp64(BgcTangentFP64* tangent1, BgcTangentFP64* tangent2);
|
||||
|
||||
extern inline void bgc_tangent_set_turn_fp32(const float angle, const BgcAngleUnitEnum unit, BgcTangentFP32* tangent);
|
||||
extern inline void bgc_tangent_set_turn_fp64(const double angle, const BgcAngleUnitEnum unit, BgcTangentFP64* tangent);
|
||||
|
||||
extern inline void bgc_tangent_convert_fp64_to_fp32(const BgcTangentFP64* from, BgcTangentFP32* to);
|
||||
extern inline void bgc_tangent_convert_fp32_to_fp64(const BgcTangentFP32* from, BgcTangentFP64* to);
|
||||
|
||||
extern inline void bgc_tangent_invert_fp32(BgcTangentFP32* tangent);
|
||||
extern inline void bgc_tangent_invert_fp64(BgcTangentFP64* tangent);
|
||||
|
||||
extern inline void bgc_tangent_set_inverted_fp32(const BgcTangentFP32* tangent, BgcTangentFP32* result);
|
||||
extern inline void bgc_tangent_set_inverted_fp64(const BgcTangentFP64* tangent, BgcTangentFP64* result);
|
||||
|
||||
extern inline void bgc_tangent_make_rotation_matrix_fp32(const BgcTangentFP32* tangent, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_tangent_make_rotation_matrix_fp64(const BgcTangentFP64* tangent, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline void bgc_tangent_make_reverse_matrix_fp32(const BgcTangentFP32* tangent, BgcMatrix2x2FP32* matrix);
|
||||
extern inline void bgc_tangent_make_reverse_matrix_fp64(const BgcTangentFP64* tangent, BgcMatrix2x2FP64* matrix);
|
||||
|
||||
extern inline float bgc_tangent_get_angle_fp32(const BgcTangentFP32* tangent, const BgcAngleUnitEnum unit);
|
||||
extern inline double bgc_tangent_get_angle_fp64(const BgcTangentFP64* tangent, const BgcAngleUnitEnum unit);
|
||||
|
||||
extern inline void bgc_tangent_combine_fp32(const BgcTangentFP32* tangent1, const BgcTangentFP32* tangent2, BgcTangentFP32* result);
|
||||
extern inline void bgc_tangent_combine_fp64(const BgcTangentFP64* tangent1, const BgcTangentFP64* tangent2, BgcTangentFP64* result);
|
||||
|
||||
extern inline void bgc_tangent_turn_vector_fp32(const BgcTangentFP32* tangent, const BgcVector2FP32* vector, BgcVector2FP32* result);
|
||||
extern inline void bgc_tangent_turn_vector_fp64(const BgcTangentFP64* tangent, const BgcVector2FP64* vector, BgcVector2FP64* result);
|
||||
|
||||
extern inline void bgc_tangent_turn_vector_back_fp32(const BgcTangentFP32* tangent, const BgcVector2FP32* vector, BgcVector2FP32* result);
|
||||
extern inline void bgc_tangent_turn_vector_back_fp64(const BgcTangentFP64* tangent, const BgcVector2FP64* vector, BgcVector2FP64* result);
|
||||
|
||||
void _bgc_tangent_normalize_fp32(const float square_modulus, _BgcDarkTwinTangentFP32* twin)
|
||||
{
|
||||
// (square_modulus != square_modulus) is true when square_modulus is NaN
|
||||
|
|
|
|||
|
|
@ -1,2 +1,4 @@
|
|||
#include "utilities.h"
|
||||
|
||||
extern inline int bgc_are_equal_fp32(const float value1, const float value2);
|
||||
extern inline int bgc_are_equal_fp64(const double value1, const double value2);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,83 @@
|
|||
#include "vector2.h"
|
||||
|
||||
extern inline void bgc_vector2_reset_fp32(BgcVector2FP32* vector);
|
||||
extern inline void bgc_vector2_reset_fp64(BgcVector2FP64* vector);
|
||||
|
||||
extern inline void bgc_vector2_set_values_fp32(const float x1, const float x2, BgcVector2FP32* to);
|
||||
extern inline void bgc_vector2_set_values_fp64(const double x1, const double x2, BgcVector2FP64* to);
|
||||
|
||||
extern inline void bgc_vector2_copy_fp32(const BgcVector2FP32* from, BgcVector2FP32* to);
|
||||
extern inline void bgc_vector2_copy_fp64(const BgcVector2FP64* from, BgcVector2FP64* to);
|
||||
|
||||
extern inline void bgc_vector2_swap_fp32(BgcVector2FP32* vector1, BgcVector2FP32* vector2);
|
||||
extern inline void bgc_vector2_swap_fp64(BgcVector2FP64* vector1, BgcVector2FP64* vector2);
|
||||
|
||||
extern inline void bgc_vector2_convert_fp64_to_fp32(const BgcVector2FP64* from, BgcVector2FP32* to);
|
||||
extern inline void bgc_vector2_convert_fp32_to_fp64(const BgcVector2FP32* from, BgcVector2FP64* to);
|
||||
|
||||
extern inline void bgc_vector2_set_reverse_fp32(const BgcVector2FP32* from, BgcVector2FP32* to);
|
||||
extern inline void bgc_vector2_set_reverse_fp64(const BgcVector2FP64* from, BgcVector2FP64* to);
|
||||
|
||||
extern inline void bgc_vector2_set_reverse_fp64_to_fp32(const BgcVector2FP64* from, BgcVector2FP32* to);
|
||||
extern inline void bgc_vector2_set_reverse_fp32_to_fp64(const BgcVector2FP32* from, BgcVector2FP64* to);
|
||||
|
||||
extern inline float bgc_vector2_get_square_modulus_fp32(const BgcVector2FP32* vector);
|
||||
extern inline double bgc_vector2_get_square_modulus_fp64(const BgcVector2FP64* vector);
|
||||
|
||||
extern inline float bgc_vector2_get_modulus_fp32(const BgcVector2FP32* vector);
|
||||
extern inline double bgc_vector2_get_modulus_fp64(const BgcVector2FP64* vector);
|
||||
|
||||
extern inline int bgc_vector2_is_zero_fp32(const BgcVector2FP32* vector);
|
||||
extern inline int bgc_vector2_is_zero_fp64(const BgcVector2FP64* vector);
|
||||
|
||||
extern inline int bgc_vector2_is_unit_fp32(const BgcVector2FP32* vector);
|
||||
extern inline int bgc_vector2_is_unit_fp64(const BgcVector2FP64* vector);
|
||||
|
||||
extern inline void bgc_vector2_add_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2, BgcVector2FP32* sum);
|
||||
extern inline void bgc_vector2_add_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2, BgcVector2FP64* sum);
|
||||
|
||||
extern inline void bgc_vector2_add_scaled_fp32(const BgcVector2FP32* basic_vector, const BgcVector2FP32* scalable_vector, const float scale, BgcVector2FP32* sum);
|
||||
extern inline void bgc_vector2_add_scaled_fp64(const BgcVector2FP64* basic_vector, const BgcVector2FP64* scalable_vector, const double scale, BgcVector2FP64* sum);
|
||||
|
||||
extern inline void bgc_vector2_subtract_fp32(const BgcVector2FP32* minuend, const BgcVector2FP32* subtrahend, BgcVector2FP32* difference);
|
||||
extern inline void bgc_vector2_subtract_fp64(const BgcVector2FP64* minuend, const BgcVector2FP64* subtrahend, BgcVector2FP64* difference);
|
||||
|
||||
extern inline void bgc_vector2_multiply_fp32(const BgcVector2FP32* multiplicand, const float multiplier, BgcVector2FP32* product);
|
||||
extern inline void bgc_vector2_multiply_fp64(const BgcVector2FP64* multiplicand, const double multiplier, BgcVector2FP64* product);
|
||||
|
||||
extern inline void bgc_vector2_divide_fp32(const BgcVector2FP32* dividend, const float divisor, BgcVector2FP32* quotient);
|
||||
extern inline void bgc_vector2_divide_fp64(const BgcVector2FP64* dividend, const double divisor, BgcVector2FP64* quotient);
|
||||
|
||||
extern inline void bgc_vector2_mean_of_two_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2, BgcVector2FP32* result);
|
||||
extern inline void bgc_vector2_mean_of_two_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2, BgcVector2FP64* result);
|
||||
|
||||
extern inline void bgc_vector2_mean_of_three_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2, const BgcVector2FP32* vector3, BgcVector2FP32* result);
|
||||
extern inline void bgc_vector2_mean_of_three_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2, const BgcVector2FP64* vector3, BgcVector2FP64* result);
|
||||
|
||||
extern inline float bgc_vector2_scalar_product_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2);
|
||||
extern inline double bgc_vector2_scalar_product_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2);
|
||||
|
||||
extern inline float bgc_vector2_cross_product_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2);
|
||||
extern inline double bgc_vector2_cross_product_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2);
|
||||
|
||||
extern inline void bgc_vector2_complex_product_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2, BgcVector2FP32* result);
|
||||
extern inline void bgc_vector2_complex_product_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2, BgcVector2FP64* result);
|
||||
|
||||
extern inline int bgc_vector2_normalize_fp32(BgcVector2FP32* vector);
|
||||
extern inline int bgc_vector2_normalize_fp64(BgcVector2FP64* vector);
|
||||
|
||||
extern inline int bgc_vector2_set_normalized_fp32(const BgcVector2FP32* vector, BgcVector2FP32* result);
|
||||
extern inline int bgc_vector2_set_normalized_fp64(const BgcVector2FP64* vector, BgcVector2FP64* result);
|
||||
|
||||
extern inline float bgc_vector2_get_square_distance_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2);
|
||||
extern inline double bgc_vector2_get_square_distance_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2);
|
||||
|
||||
extern inline float bgc_vector2_get_distance_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2);
|
||||
extern inline double bgc_vector2_get_distance_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2);
|
||||
|
||||
extern inline int bgc_vector2_are_equal_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2);
|
||||
extern inline int bgc_vector2_are_equal_fp64(const BgcVector2FP64* vector1, const BgcVector2FP64* vector2);
|
||||
|
||||
// =================== Angle ==================== //
|
||||
|
||||
float bgc_vector2_get_angle_fp32(const BgcVector2FP32* vector1, const BgcVector2FP32* vector2, const BgcAngleUnitEnum unit)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,89 @@
|
|||
#include "vector3.h"
|
||||
|
||||
extern inline void bgc_vector3_reset_fp32(BgcVector3FP32* vector);
|
||||
extern inline void bgc_vector3_reset_fp64(BgcVector3FP64* vector);
|
||||
|
||||
extern inline void bgc_vector3_set_values_fp32(const float x1, const float x2, const float x3, BgcVector3FP32* to);
|
||||
extern inline void bgc_vector3_set_values_fp64(const double x1, const double x2, const double x3, BgcVector3FP64* to);
|
||||
|
||||
extern inline void bgc_vector3_copy_fp32(const BgcVector3FP32* from, BgcVector3FP32* to);
|
||||
extern inline void bgc_vector3_copy_fp64(const BgcVector3FP64* from, BgcVector3FP64* to);
|
||||
|
||||
extern inline void bgc_vector3_convert_fp64_to_fp32(const BgcVector3FP64* from, BgcVector3FP32* to);
|
||||
extern inline void bgc_vector3_convert_fp32_to_fp64(const BgcVector3FP32* from, BgcVector3FP64* to);
|
||||
|
||||
extern inline void bgc_vector3_swap_fp32(BgcVector3FP32* vector1, BgcVector3FP32* vector2);
|
||||
extern inline void bgc_vector3_swap_fp64(BgcVector3FP64* vector1, BgcVector3FP64* vector2);
|
||||
|
||||
extern inline void bgc_vector3_invert_fp32(BgcVector3FP32* vector);
|
||||
extern inline void bgc_vector3_invert_fp64(BgcVector3FP64* vector);
|
||||
|
||||
extern inline void bgc_vector3_set_inverted_fp32(const BgcVector3FP32* vector, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_set_inverted_fp64(const BgcVector3FP64* vector, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_vector3_set_inverted_fp32_to_fp64(const BgcVector3FP32* vector, BgcVector3FP64* result);
|
||||
extern inline void bgc_vector3_set_inverted_fp64_to_fp32(const BgcVector3FP64* vector, BgcVector3FP32* result);
|
||||
|
||||
extern inline float bgc_vector3_get_square_modulus_fp32(const BgcVector3FP32* vector);
|
||||
extern inline double bgc_vector3_get_square_modulus_fp64(const BgcVector3FP64* vector);
|
||||
|
||||
extern inline float bgc_vector3_get_modulus_fp32(const BgcVector3FP32* vector);
|
||||
extern inline double bgc_vector3_get_modulus_fp64(const BgcVector3FP64* vector);
|
||||
|
||||
extern inline int bgc_vector3_is_zero_fp32(const BgcVector3FP32* vector);
|
||||
extern inline int bgc_vector3_is_zero_fp64(const BgcVector3FP64* vector);
|
||||
|
||||
extern inline int bgc_vector3_is_unit_fp32(const BgcVector3FP32* vector);
|
||||
extern inline int bgc_vector3_is_unit_fp64(const BgcVector3FP64* vector);
|
||||
|
||||
extern inline void bgc_vector3_add_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, BgcVector3FP32* sum);
|
||||
extern inline void bgc_vector3_add_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, BgcVector3FP64* sum);
|
||||
|
||||
extern inline void bgc_vector3_add_scaled_fp32(const BgcVector3FP32* basic_vector, const BgcVector3FP32* scalable_vector, const float scale, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_add_scaled_fp64(const BgcVector3FP64* basic_vector, const BgcVector3FP64* scalable_vector, const double scale, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_vector3_subtract_fp32(const BgcVector3FP32* minuend, const BgcVector3FP32* subtrahend, BgcVector3FP32* difference);
|
||||
extern inline void bgc_vector3_subtract_fp64(const BgcVector3FP64* minuend, const BgcVector3FP64* subtrahend, BgcVector3FP64* difference);
|
||||
|
||||
extern inline void bgc_vector3_multiply_fp32(const BgcVector3FP32* multiplicand, const float multiplier, BgcVector3FP32* product);
|
||||
extern inline void bgc_vector3_multiply_fp64(const BgcVector3FP64* multiplicand, const double multiplier, BgcVector3FP64* product);
|
||||
|
||||
extern inline void bgc_vector3_divide_fp32(const BgcVector3FP32* dividend, const float divisor, BgcVector3FP32* quotient);
|
||||
extern inline void bgc_vector3_divide_fp64(const BgcVector3FP64* dividend, const double divisor, BgcVector3FP64* quotient);
|
||||
|
||||
extern inline void bgc_vector3_mean_of_two_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_mean_of_two_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_vector3_mean_of_three_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, const BgcVector3FP32* vector3, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_mean_of_three_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, const BgcVector3FP64* vector3, BgcVector3FP64* result);
|
||||
|
||||
extern inline float bgc_vector3_scalar_product_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2);
|
||||
extern inline double bgc_vector3_scalar_product_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2);
|
||||
|
||||
extern inline float bgc_vector3_triple_product_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, const BgcVector3FP32* vector3);
|
||||
extern inline double bgc_vector3_triple_product_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, const BgcVector3FP64* vector3);
|
||||
|
||||
extern inline void bgc_vector3_cross_product_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_cross_product_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_vector3_double_cross_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, const BgcVector3FP32* vector3, BgcVector3FP32* result);
|
||||
extern inline void bgc_vector3_double_cross_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2, const BgcVector3FP64* vector3, BgcVector3FP64* result);
|
||||
|
||||
extern inline int bgc_vector3_normalize_fp32(BgcVector3FP32* vector);
|
||||
extern inline int bgc_vector3_normalize_fp64(BgcVector3FP64* vector);
|
||||
|
||||
extern inline int bgc_vector3_set_normalized_fp32(const BgcVector3FP32* vector, BgcVector3FP32* result);
|
||||
extern inline int bgc_vector3_set_normalized_fp64(const BgcVector3FP64* vector, BgcVector3FP64* result);
|
||||
|
||||
extern inline float bgc_vector3_get_square_distance_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2);
|
||||
extern inline double bgc_vector3_get_square_distance_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2);
|
||||
|
||||
extern inline float bgc_vector3_get_distance_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2);
|
||||
extern inline double bgc_vector3_get_distance_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2);
|
||||
|
||||
extern inline int bgc_vector3_are_equal_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2);
|
||||
extern inline int bgc_vector3_are_equal_fp64(const BgcVector3FP64* vector1, const BgcVector3FP64* vector2);
|
||||
|
||||
// =================== Angle ==================== //
|
||||
|
||||
float bgc_vector3_get_angle_fp32(const BgcVector3FP32* vector1, const BgcVector3FP32* vector2, const BgcAngleUnitEnum unit)
|
||||
|
|
|
|||
|
|
@ -7,6 +7,63 @@ const BgcVersorFP32 BGC_IDLE_VERSOR_FP32 = { 1.0f, 0.0f, 0.0f, 0.0f };
|
|||
|
||||
const BgcVersorFP64 BGC_IDLE_VERSOR_FP64 = { 1.0, 0.0, 0.0, 0.0 };
|
||||
|
||||
extern inline void bgc_versor_reset_fp32(BgcVersorFP32* versor);
|
||||
extern inline void bgc_versor_reset_fp64(BgcVersorFP64* versor);
|
||||
|
||||
extern inline void bgc_versor_set_values_fp32(const float s0, const float x1, const float x2, const float x3, BgcVersorFP32* versor);
|
||||
extern inline void bgc_versor_set_values_fp64(const double s0, const double x1, const double x2, const double x3, BgcVersorFP64* versor);
|
||||
|
||||
extern inline void bgc_versor_copy_fp32(const BgcVersorFP32* from, BgcVersorFP32* to);
|
||||
extern inline void bgc_versor_copy_fp64(const BgcVersorFP64* from, BgcVersorFP64* to);
|
||||
|
||||
extern inline void bgc_versor_swap_fp32(BgcVersorFP32* versor1, BgcVersorFP32* versor2);
|
||||
extern inline void bgc_versor_swap_fp64(BgcVersorFP64* versor1, BgcVersorFP64* versor2);
|
||||
|
||||
extern inline void bgc_versor_set_turn_fp32(const BgcVector3FP32* axis, const float angle, const BgcAngleUnitEnum unit, BgcVersorFP32* result);
|
||||
extern inline void bgc_versor_set_turn_fp64(const BgcVector3FP32* axis, const double angle, const BgcAngleUnitEnum unit, BgcVersorFP64* result);
|
||||
|
||||
extern inline void bgc_versor_set_rotation_fp32(const BgcRotation3FP32* rotation, BgcVersorFP32* result);
|
||||
extern inline void bgc_versor_set_rotation_fp64(const BgcRotation3FP64* rotation, BgcVersorFP64* result);
|
||||
|
||||
extern inline int bgc_versor_is_idle_fp32(const BgcVersorFP32* versor);
|
||||
extern inline int bgc_versor_is_idle_fp64(const BgcVersorFP64* versor);
|
||||
|
||||
extern inline void bgc_versor_convert_fp64_to_fp32(const BgcVersorFP64* versor, BgcVersorFP32* result);
|
||||
extern inline void bgc_versor_convert_fp32_to_fp64(const BgcVersorFP32* versor, BgcVersorFP64* result);
|
||||
|
||||
extern inline void bgc_versor_shorten_fp32(BgcVersorFP32* versor);
|
||||
extern inline void bgc_versor_shorten_fp64(BgcVersorFP64* versor);
|
||||
|
||||
extern inline void bgc_versor_set_shortened_fp32(const BgcVersorFP32* versor, BgcVersorFP32* shortened);
|
||||
extern inline void bgc_versor_set_shortened_fp64(const BgcVersorFP64* versor, BgcVersorFP64* shortened);
|
||||
|
||||
extern inline void bgc_versor_invert_fp32(BgcVersorFP32* versor);
|
||||
extern inline void bgc_versor_invert_fp64(BgcVersorFP64* versor);
|
||||
|
||||
extern inline void bgc_versor_set_inverted_fp32(const BgcVersorFP32* versor, BgcVersorFP32* to);
|
||||
extern inline void bgc_versor_set_inverted_fp64(const BgcVersorFP64* versor, BgcVersorFP64* to);
|
||||
|
||||
extern inline void bgc_versor_set_inverted_fp64_to_fp32(const BgcVersorFP64* versor, BgcVersorFP32* to);
|
||||
extern inline void bgc_versor_set_inverted_fp32_to_fp64(const BgcVersorFP32* versor, BgcVersorFP64* to);
|
||||
|
||||
extern inline void bgc_versor_combine_fp32(const BgcVersorFP32* second, const BgcVersorFP32* first, BgcVersorFP32* result);
|
||||
extern inline void bgc_versor_combine_fp64(const BgcVersorFP64* second, const BgcVersorFP64* first, BgcVersorFP64* result);
|
||||
|
||||
extern inline void bgc_versor_combine3_fp32(const BgcVersorFP32* third, const BgcVersorFP32* second, const BgcVersorFP32* first, BgcVersorFP32* result);
|
||||
extern inline void bgc_versor_combine3_fp64(const BgcVersorFP64* third, const BgcVersorFP64* second, const BgcVersorFP64* first, BgcVersorFP64* result);
|
||||
|
||||
extern inline void bgc_versor_make_rotation_matrix_fp32(const BgcVersorFP32* versor, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_versor_make_rotation_matrix_fp64(const BgcVersorFP64* versor, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_versor_make_reverse_matrix_fp32(const BgcVersorFP32* versor, BgcMatrix3x3FP32* matrix);
|
||||
extern inline void bgc_versor_make_reverse_matrix_fp64(const BgcVersorFP64* versor, BgcMatrix3x3FP64* matrix);
|
||||
|
||||
extern inline void bgc_versor_turn_vector_fp32(const BgcVersorFP32* versor, const BgcVector3FP32* vector, BgcVector3FP32* result);
|
||||
extern inline void bgc_versor_turn_vector_fp64(const BgcVersorFP64* versor, const BgcVector3FP64* vector, BgcVector3FP64* result);
|
||||
|
||||
extern inline void bgc_versor_turn_vector_back_fp32(const BgcVersorFP32* versor, const BgcVector3FP32* vector, BgcVector3FP32* result);
|
||||
extern inline void bgc_versor_turn_vector_back_fp64(const BgcVersorFP64* versor, const BgcVector3FP64* vector, BgcVector3FP64* result);
|
||||
|
||||
// =============== Normalization ================ //
|
||||
|
||||
void _bgc_versor_normalize_fp32(const float square_modulus, _BgcDarkTwinVersorFP32* twin)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue