Переименование методов на распространённые названия
This commit is contained in:
parent
039b26305a
commit
b621191698
14 changed files with 192 additions and 192 deletions
|
|
@ -60,14 +60,14 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="complex.h" />
|
||||
<Unit filename="dual-number.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-number.h" />
|
||||
<Unit filename="dual-quaternion.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-quaternion.h" />
|
||||
<Unit filename="dual-scalar.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="dual-scalar.h" />
|
||||
<Unit filename="dual-vector3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ extern inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* di
|
|||
extern inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale);
|
||||
extern inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier);
|
||||
|
|
|
|||
|
|
@ -146,7 +146,7 @@ inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* di
|
|||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
|
||||
inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
|
||||
{
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
|
||||
|
|
@ -247,7 +247,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_dual_number(BGC_FP32_DualQuaternio
|
|||
}
|
||||
|
||||
bgc_fp32_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor);
|
||||
bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
|
||||
bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
|
@ -277,7 +277,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_conjugate_number(BGC_FP32_DualQuat
|
|||
}
|
||||
|
||||
bgc_fp32_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate);
|
||||
bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
|
||||
bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
|
||||
|
||||
return BGC_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,11 +10,11 @@ extern inline void bgc_fp64_quaternion_make_unit(BGC_FP64_Quaternion* quaternion
|
|||
extern inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* quaternion, const float s0, const float x1, const float x2, const float x3);
|
||||
extern inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const double s0, const double x1, const double x2, const double x3);
|
||||
|
||||
extern inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion);
|
||||
extern inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion);
|
||||
extern inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion);
|
||||
extern inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion);
|
||||
|
||||
extern inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion);
|
||||
extern inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion);
|
||||
extern inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion);
|
||||
extern inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion);
|
||||
|
||||
extern inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion);
|
||||
extern inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion);
|
||||
|
|
|
|||
|
|
@ -64,50 +64,50 @@ inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const doub
|
|||
|
||||
// ============= Get Square Modulus ============= //
|
||||
|
||||
inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion)
|
||||
inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
|
||||
}
|
||||
|
||||
inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion)
|
||||
inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
|
||||
}
|
||||
|
||||
// ================ Get Modulus ================= //
|
||||
|
||||
inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion)
|
||||
inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
return sqrtf(bgc_fp32_quaternion_get_square_modulus(quaternion));
|
||||
return sqrtf(bgc_fp32_quaternion_get_square_magnitude(quaternion));
|
||||
}
|
||||
|
||||
inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion)
|
||||
inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
return sqrt(bgc_fp64_quaternion_get_square_modulus(quaternion));
|
||||
return sqrt(bgc_fp64_quaternion_get_square_magnitude(quaternion));
|
||||
}
|
||||
|
||||
// ================== Is Zero =================== //
|
||||
|
||||
inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
return bgc_fp32_quaternion_get_square_modulus(quaternion) <= BGC_FP32_SQUARE_EPSILON;
|
||||
return bgc_fp32_quaternion_get_square_magnitude(quaternion) <= BGC_FP32_SQUARE_EPSILON;
|
||||
}
|
||||
|
||||
inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
return bgc_fp64_quaternion_get_square_modulus(quaternion) <= BGC_FP64_SQUARE_EPSILON;
|
||||
return bgc_fp64_quaternion_get_square_magnitude(quaternion) <= BGC_FP64_SQUARE_EPSILON;
|
||||
}
|
||||
|
||||
// ================== Is Unit =================== //
|
||||
|
||||
inline int bgc_fp32_quaternion_is_unit(const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_modulus(quaternion));
|
||||
return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_magnitude(quaternion));
|
||||
}
|
||||
|
||||
inline int bgc_fp64_quaternion_is_unit(const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_modulus(quaternion));
|
||||
return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_magnitude(quaternion));
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
|
@ -358,7 +358,7 @@ inline int bgc_fp64_quaternion_divide_by_real(BGC_FP64_Quaternion* quotient, con
|
|||
|
||||
inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor);
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -372,7 +372,7 @@ inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotien
|
|||
|
||||
inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor);
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -388,7 +388,7 @@ inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotien
|
|||
|
||||
inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor_to_conjugate)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor_to_conjugate);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor_to_conjugate);
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -402,7 +402,7 @@ inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient
|
|||
|
||||
inline int bgc_fp64_quaternion_divide_by_conjugate(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor_to_conjugate)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor_to_conjugate);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor_to_conjugate);
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -542,7 +542,7 @@ inline void bgc_fp64_quaternion_get_reverse(BGC_FP64_Quaternion* reverse, const
|
|||
|
||||
inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -560,7 +560,7 @@ inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const B
|
|||
|
||||
inline int bgc_fp64_quaternion_get_inverse(BGC_FP64_Quaternion* inverse, const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -590,7 +590,7 @@ inline int bgc_fp64_quaternion_invert(BGC_FP64_Quaternion* quaternion)
|
|||
|
||||
inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -612,7 +612,7 @@ inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
|
|||
|
||||
inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -634,7 +634,7 @@ inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
|
|||
|
||||
inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, const BGC_FP32_Quaternion* quaternion)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
bgc_fp32_quaternion_reset(normalized);
|
||||
|
|
@ -652,7 +652,7 @@ inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, c
|
|||
|
||||
inline int bgc_fp64_quaternion_get_normalized(BGC_FP64_Quaternion* normalized, const BGC_FP64_Quaternion* quaternion)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
bgc_fp64_quaternion_reset(normalized);
|
||||
|
|
@ -746,7 +746,7 @@ inline void _bgc_fp64_quaternion_turn_vector_back_roughly(BGC_FP64_Vector3* turn
|
|||
|
||||
inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -772,7 +772,7 @@ inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, cons
|
|||
|
||||
inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -800,7 +800,7 @@ inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, cons
|
|||
|
||||
inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
|
||||
{
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -826,7 +826,7 @@ inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector,
|
|||
|
||||
inline int bgc_fp64_quaternion_turn_vector_back(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
|
||||
{
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
|
||||
return BGC_FAILURE;
|
||||
|
|
@ -1049,8 +1049,8 @@ inline int bgc_fp32_quaternion_are_close(const BGC_FP32_Quaternion* quaternion1,
|
|||
const float dx2 = quaternion1->x2 - quaternion2->x2;
|
||||
const float dx3 = quaternion1->x3 - quaternion2->x3;
|
||||
|
||||
const float square_modulus1 = bgc_fp32_quaternion_get_square_modulus(quaternion1);
|
||||
const float square_modulus2 = bgc_fp32_quaternion_get_square_modulus(quaternion2);
|
||||
const float square_modulus1 = bgc_fp32_quaternion_get_square_magnitude(quaternion1);
|
||||
const float square_modulus2 = bgc_fp32_quaternion_get_square_magnitude(quaternion2);
|
||||
const float square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
|
||||
|
||||
if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) {
|
||||
|
|
@ -1067,8 +1067,8 @@ inline int bgc_fp64_quaternion_are_close(const BGC_FP64_Quaternion* quaternion1,
|
|||
const double dx2 = quaternion1->x2 - quaternion2->x2;
|
||||
const double dx3 = quaternion1->x3 - quaternion2->x3;
|
||||
|
||||
const double square_modulus1 = bgc_fp64_quaternion_get_square_modulus(quaternion1);
|
||||
const double square_modulus2 = bgc_fp64_quaternion_get_square_modulus(quaternion2);
|
||||
const double square_modulus1 = bgc_fp64_quaternion_get_square_magnitude(quaternion1);
|
||||
const double square_modulus2 = bgc_fp64_quaternion_get_square_magnitude(quaternion2);
|
||||
const double square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
|
||||
|
||||
if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) {
|
||||
|
|
|
|||
|
|
@ -1,32 +1,32 @@
|
|||
#include "./slerp3.h"
|
||||
|
||||
extern inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp);
|
||||
extern inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp);
|
||||
extern inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp);
|
||||
extern inline void bgc_fp64_slerp3_reset(BGC_FP64_Slerp3* slerp);
|
||||
|
||||
extern inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
|
||||
extern inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
|
||||
extern inline void bgc_fp32_slerp3_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
|
||||
extern inline void bgc_fp64_slerp3_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
|
||||
|
||||
extern inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
|
||||
extern inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
|
||||
extern inline void bgc_fp32_slerp3_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
|
||||
extern inline void bgc_fp64_slerp3_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
|
||||
|
||||
extern inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* versor, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* versor, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
extern inline void bgc_fp32_slerp3_get_phase_turn(BGC_FP32_Turn3* versor, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp3_get_phase_turn(BGC_FP64_Turn3* versor, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
|
||||
extern inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
extern inline void bgc_fp32_slerp3_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
|
||||
extern inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
extern inline void bgc_fp32_slerp3_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
|
||||
extern inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
extern inline void bgc_fp32_slerp3_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
|
||||
extern inline void bgc_fp64_slerp3_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
|
||||
|
||||
void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
|
||||
void bgc_fp32_slerp3_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
|
||||
{
|
||||
const float square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
|
||||
|
||||
if (isnan(square_vector)) {
|
||||
bgc_fp32_slerp_reset(slerp);
|
||||
bgc_fp32_slerp3_reset(slerp);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -62,12 +62,12 @@ void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, co
|
|||
slerp->_sine_weight.x3 = multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
|
||||
}
|
||||
|
||||
void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
|
||||
void bgc_fp64_slerp3_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
|
||||
{
|
||||
const double square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
|
||||
|
||||
if (isnan(square_vector)) {
|
||||
bgc_fp64_slerp_reset(slerp);
|
||||
bgc_fp64_slerp3_reset(slerp);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
// =================== Reset ==================== //
|
||||
|
||||
inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
|
||||
inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp)
|
||||
{
|
||||
slerp->_cosine_weight.s0 = 1.0f;
|
||||
slerp->_cosine_weight.x1 = 0.0f;
|
||||
|
|
@ -22,7 +22,7 @@ inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
|
|||
slerp->radians = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
|
||||
inline void bgc_fp64_slerp3_reset(BGC_FP64_Slerp3* slerp)
|
||||
{
|
||||
slerp->_cosine_weight.s0 = 1.0;
|
||||
slerp->_cosine_weight.x1 = 0.0;
|
||||
|
|
@ -39,54 +39,54 @@ inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
|
|||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
|
||||
void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
|
||||
void bgc_fp32_slerp3_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
|
||||
void bgc_fp64_slerp3_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
|
||||
|
||||
// ================= Make Full ================== //
|
||||
|
||||
inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
|
||||
inline void bgc_fp32_slerp3_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
|
||||
{
|
||||
BGC_FP32_Turn3 augment;
|
||||
|
||||
bgc_fp32_turn3_exclude(&augment, end, start);
|
||||
|
||||
bgc_fp32_slerp_make(slerp, start, &augment);
|
||||
bgc_fp32_slerp3_make(slerp, start, &augment);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
|
||||
inline void bgc_fp64_slerp3_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
|
||||
{
|
||||
BGC_FP64_Turn3 augment;
|
||||
|
||||
bgc_fp64_turn3_exclude(&augment, end, start);
|
||||
|
||||
bgc_fp64_slerp_make(slerp, start, &augment);
|
||||
bgc_fp64_slerp3_make(slerp, start, &augment);
|
||||
}
|
||||
|
||||
// =============== Make Shortened =============== //
|
||||
|
||||
inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
|
||||
inline void bgc_fp32_slerp3_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
|
||||
{
|
||||
BGC_FP32_Turn3 augment;
|
||||
|
||||
bgc_fp32_turn3_exclude(&augment, end, start);
|
||||
bgc_fp32_turn3_shorten(&augment);
|
||||
|
||||
bgc_fp32_slerp_make(slerp, start, &augment);
|
||||
bgc_fp32_slerp3_make(slerp, start, &augment);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
|
||||
inline void bgc_fp64_slerp3_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
|
||||
{
|
||||
BGC_FP64_Turn3 augment;
|
||||
|
||||
bgc_fp64_turn3_exclude(&augment, end, start);
|
||||
bgc_fp64_turn3_shorten(&augment);
|
||||
|
||||
bgc_fp64_slerp_make(slerp, start, &augment);
|
||||
bgc_fp64_slerp3_make(slerp, start, &augment);
|
||||
}
|
||||
|
||||
// =============== Get Phase Turn =============== //
|
||||
|
||||
inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
inline void bgc_fp32_slerp3_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
{
|
||||
const float angle = slerp->radians * phase;
|
||||
const float cosine = cosf(angle);
|
||||
|
|
@ -100,7 +100,7 @@ inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_S
|
|||
bgc_fp32_turn3_set_quaternion(turn, &q);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
inline void bgc_fp64_slerp3_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
{
|
||||
const double angle = slerp->radians * phase;
|
||||
const double cosine = cos(angle);
|
||||
|
|
@ -116,7 +116,7 @@ inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_S
|
|||
|
||||
// ========= Get Phase Rotation Matrix ========== //
|
||||
|
||||
inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
inline void bgc_fp32_slerp3_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
{
|
||||
const float angle = slerp->radians * phase;
|
||||
const float cosine = cosf(angle);
|
||||
|
|
@ -130,7 +130,7 @@ inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotatio
|
|||
bgc_fp32_quaternion_get_rotation_matrix(rotation_matrix, &q);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
{
|
||||
const double angle = slerp->radians * phase;
|
||||
const double cosine = cos(angle);
|
||||
|
|
@ -146,7 +146,7 @@ inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotatio
|
|||
|
||||
// ========== Get Phase Reverse Matrix ========== //
|
||||
|
||||
inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
inline void bgc_fp32_slerp3_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
{
|
||||
const float angle = slerp->radians * phase;
|
||||
const float cosine = cosf(angle);
|
||||
|
|
@ -160,7 +160,7 @@ inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_
|
|||
bgc_fp32_quaternion_get_reverse_matrix(reverse_matrix, &q);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
inline void bgc_fp64_slerp3_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
{
|
||||
const double angle = slerp->radians * phase;
|
||||
const double cosine = cos(angle);
|
||||
|
|
@ -176,7 +176,7 @@ inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_
|
|||
|
||||
// ========== Get Phase Both Matrices =========== //
|
||||
|
||||
inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
inline void bgc_fp32_slerp3_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
|
||||
{
|
||||
const float angle = slerp->radians * phase;
|
||||
const float cosine = cosf(angle);
|
||||
|
|
@ -190,7 +190,7 @@ inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_
|
|||
bgc_fp32_quaternion_get_both_matrices(rotation_matrix, reverse_matrix, &q);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
inline void bgc_fp64_slerp3_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
|
||||
{
|
||||
const double angle = slerp->radians * phase;
|
||||
const double cosine = cos(angle);
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ void bgc_fp32_turn3_set_rotation(BGC_FP32_Turn3* turn, const float x1, const flo
|
|||
|
||||
bgc_fp32_quaternion_make(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(turn, square_modulus);
|
||||
|
|
@ -195,7 +195,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
|
|||
|
||||
bgc_fp64_quaternion_make(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(turn, square_modulus);
|
||||
|
|
@ -206,7 +206,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
|
|||
|
||||
int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP32_Vector3* first, const BGC_FP32_Vector3* second)
|
||||
{
|
||||
const float first_square_modulus = bgc_fp32_vector3_get_square_modulus(first);
|
||||
const float first_square_modulus = bgc_fp32_vector3_get_squared_length(first);
|
||||
|
||||
bgc_fp32_turn3_reset(turn);
|
||||
|
||||
|
|
@ -214,7 +214,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
|
|||
return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
|
||||
}
|
||||
|
||||
const float second_square_modulus = bgc_fp32_vector3_get_square_modulus(second);
|
||||
const float second_square_modulus = bgc_fp32_vector3_get_squared_length(second);
|
||||
|
||||
if (second_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
|
||||
|
|
@ -226,7 +226,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
|
|||
|
||||
const float square_product = first_square_modulus * second_square_modulus;
|
||||
const float dot_product = bgc_fp32_vector3_get_dot_product(first, second);
|
||||
const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis);
|
||||
const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
|
||||
|
||||
if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON * square_product) {
|
||||
if (dot_product < 0.0f) {
|
||||
|
|
@ -250,7 +250,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
|
|||
|
||||
int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP64_Vector3* first, const BGC_FP64_Vector3* second)
|
||||
{
|
||||
const double first_square_modulus = bgc_fp64_vector3_get_square_modulus(first);
|
||||
const double first_square_modulus = bgc_fp64_vector3_get_squared_length(first);
|
||||
|
||||
bgc_fp64_turn3_reset(turn);
|
||||
|
||||
|
|
@ -258,7 +258,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
|
|||
return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
|
||||
}
|
||||
|
||||
const double second_square_modulus = bgc_fp64_vector3_get_square_modulus(second);
|
||||
const double second_square_modulus = bgc_fp64_vector3_get_squared_length(second);
|
||||
|
||||
if (second_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
|
||||
|
|
@ -270,7 +270,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
|
|||
|
||||
const double square_product = first_square_modulus * second_square_modulus;
|
||||
const double dot_product = bgc_fp64_vector3_get_dot_product(first, second);
|
||||
const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis);
|
||||
const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
|
||||
|
||||
if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON * square_product) {
|
||||
bgc_fp64_turn3_reset(turn);
|
||||
|
|
@ -297,13 +297,13 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
|
|||
|
||||
static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_main, BGC_FP32_Vector3* unit_branch, const BGC_FP32_Vector3* main, const BGC_FP32_Vector3* branch)
|
||||
{
|
||||
const float main_square_modulus = bgc_fp32_vector3_get_square_modulus(main);
|
||||
const float main_square_modulus = bgc_fp32_vector3_get_squared_length(main);
|
||||
|
||||
if (main_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_EMPTY_MAIN;
|
||||
}
|
||||
|
||||
const float branch_square_modulus = bgc_fp32_vector3_get_square_modulus(branch);
|
||||
const float branch_square_modulus = bgc_fp32_vector3_get_squared_length(branch);
|
||||
|
||||
if (branch_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_EMPTY_BRANCH;
|
||||
|
|
@ -313,7 +313,7 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
|
|||
|
||||
bgc_fp32_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp32_vector3_get_dot_product(branch, unit_main));
|
||||
|
||||
const float orthogonal_square_modulus = bgc_fp32_vector3_get_square_modulus(unit_branch);
|
||||
const float orthogonal_square_modulus = bgc_fp32_vector3_get_squared_length(unit_branch);
|
||||
|
||||
if (orthogonal_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_PAIR_PARALLEL;
|
||||
|
|
@ -326,13 +326,13 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
|
|||
|
||||
static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_main, BGC_FP64_Vector3* unit_branch, const BGC_FP64_Vector3* main, const BGC_FP64_Vector3* branch)
|
||||
{
|
||||
const double main_square_modulus = bgc_fp64_vector3_get_square_modulus(main);
|
||||
const double main_square_modulus = bgc_fp64_vector3_get_squared_length(main);
|
||||
|
||||
if (main_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_EMPTY_MAIN;
|
||||
}
|
||||
|
||||
const double branch_square_modulus = bgc_fp64_vector3_get_square_modulus(branch);
|
||||
const double branch_square_modulus = bgc_fp64_vector3_get_squared_length(branch);
|
||||
|
||||
if (branch_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_EMPTY_BRANCH;
|
||||
|
|
@ -342,7 +342,7 @@ static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_mai
|
|||
|
||||
bgc_fp64_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp64_vector3_get_dot_product(branch, unit_main));
|
||||
|
||||
const double orthogonal_square_modulus = bgc_fp64_vector3_get_square_modulus(unit_branch);
|
||||
const double orthogonal_square_modulus = bgc_fp64_vector3_get_squared_length(unit_branch);
|
||||
|
||||
if (orthogonal_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
return _BGC_ERROR_TURN3_PAIR_PARALLEL;
|
||||
|
|
@ -363,7 +363,7 @@ static inline void _bgc_fp32_turn3_get_turning_quaternion(BGC_FP32_Quaternion* q
|
|||
|
||||
const float dot_product = bgc_fp32_vector3_get_dot_product(unit_start, unit_end);
|
||||
|
||||
const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis);
|
||||
const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
|
||||
|
||||
// unit_start and unit_end are parallel
|
||||
if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
|
||||
|
|
@ -404,7 +404,7 @@ static inline void _bgc_fp64_turn3_get_turning_quaternion(BGC_FP64_Quaternion* q
|
|||
|
||||
const double dot_product = bgc_fp64_vector3_get_dot_product(unit_start, unit_end);
|
||||
|
||||
const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis);
|
||||
const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
|
||||
|
||||
// unit_start and unit_end are parallel
|
||||
if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
|
||||
|
|
@ -477,7 +477,7 @@ int bgc_fp32_turn3_find_pair_difference(
|
|||
bgc_fp32_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
|
||||
|
||||
// Making a final versor (a normalized quaternion)
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(turn, square_modulus);
|
||||
|
|
@ -524,7 +524,7 @@ int bgc_fp64_turn3_find_pair_difference(
|
|||
bgc_fp64_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
|
||||
|
||||
// Making a final versor (a normalized quaternion)
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(turn, square_modulus);
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ inline void bgc_fp32_turn3_set_quaternion(BGC_FP32_Turn3* turn, const BGC_FP32_Q
|
|||
{
|
||||
bgc_fp32_quaternion_copy(&turn->_versor, quaternion);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(turn, square_modulus);
|
||||
|
|
@ -102,7 +102,7 @@ inline void bgc_fp64_turn3_set_quaternion(BGC_FP64_Turn3* turn, const BGC_FP64_Q
|
|||
{
|
||||
bgc_fp64_quaternion_copy(&turn->_versor, quaternion);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(turn, square_modulus);
|
||||
|
|
@ -187,7 +187,7 @@ inline void bgc_fp32_turn3_convert_to_fp64(BGC_FP64_Turn3* destination, const BG
|
|||
{
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->_versor, &source->_versor);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&destination->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&destination->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(destination, square_modulus);
|
||||
|
|
@ -198,7 +198,7 @@ inline void bgc_fp64_turn3_convert_to_fp32(BGC_FP32_Turn3* destination, const BG
|
|||
{
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->_versor, &source->_versor);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&destination->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&destination->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(destination, square_modulus);
|
||||
|
|
@ -297,7 +297,7 @@ inline void bgc_fp32_turn3_combine(BGC_FP32_Turn3* combination, const BGC_FP32_T
|
|||
{
|
||||
bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(combination, square_modulus);
|
||||
|
|
@ -308,7 +308,7 @@ inline void bgc_fp64_turn3_combine(BGC_FP64_Turn3* combination, const BGC_FP64_T
|
|||
{
|
||||
bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(combination, square_modulus);
|
||||
|
|
@ -325,7 +325,7 @@ inline void bgc_fp32_turn3_combine3(BGC_FP32_Turn3* combination, const BGC_FP32_
|
|||
|
||||
bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(combination, square_modulus);
|
||||
|
|
@ -340,7 +340,7 @@ inline void bgc_fp64_turn3_combine3(BGC_FP64_Turn3* combination, const BGC_FP64_
|
|||
|
||||
bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(combination, square_modulus);
|
||||
|
|
@ -353,7 +353,7 @@ inline void bgc_fp32_turn3_exclude(BGC_FP32_Turn3* difference, const BGC_FP32_Tu
|
|||
{
|
||||
bgc_fp32_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
|
||||
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&difference->_versor);
|
||||
const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&difference->_versor);
|
||||
|
||||
if (!bgc_fp32_is_square_unit(square_modulus)) {
|
||||
_bgc_fp32_turn3_normalize(difference, square_modulus);
|
||||
|
|
@ -364,7 +364,7 @@ inline void bgc_fp64_turn3_exclude(BGC_FP64_Turn3* difference, const BGC_FP64_Tu
|
|||
{
|
||||
bgc_fp64_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
|
||||
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&difference->_versor);
|
||||
const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&difference->_versor);
|
||||
|
||||
if (!bgc_fp64_is_square_unit(square_modulus)) {
|
||||
_bgc_fp64_turn3_normalize(difference, square_modulus);
|
||||
|
|
@ -541,14 +541,14 @@ inline int bgc_fp32_turn3_are_close(const BGC_FP32_Turn3* turn1, const BGC_FP32_
|
|||
{
|
||||
BGC_FP32_Quaternion difference;
|
||||
bgc_fp32_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
|
||||
return bgc_fp32_quaternion_get_square_modulus(&difference) <= BGC_FP32_SQUARE_EPSILON;
|
||||
return bgc_fp32_quaternion_get_square_magnitude(&difference) <= BGC_FP32_SQUARE_EPSILON;
|
||||
}
|
||||
|
||||
inline int bgc_fp64_turn3_are_close(const BGC_FP64_Turn3* turn1, const BGC_FP64_Turn3* turn2)
|
||||
{
|
||||
BGC_FP64_Quaternion difference;
|
||||
bgc_fp64_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
|
||||
return bgc_fp64_quaternion_get_square_modulus(&difference) <= BGC_FP64_SQUARE_EPSILON;
|
||||