Развитие SLERP для трёхмерных пространств, а также развитие дуальных чисел, векторов и кватернионов
This commit is contained in:
parent
053af33444
commit
86ea23de7d
23 changed files with 1063 additions and 830 deletions
|
|
@ -60,30 +60,26 @@
|
|||
<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>
|
||||
<Unit filename="dual-vector3.h" />
|
||||
<Unit filename="hg-matrix3x3.c">
|
||||
<Unit filename="hmg-matrix3x3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="hg-matrix3x3.h" />
|
||||
<Unit filename="hg-vector3.c">
|
||||
<Unit filename="hmg-matrix3x3.h" />
|
||||
<Unit filename="hmg-vector3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="hg-vector3.h" />
|
||||
<Unit filename="matrices.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="matrices.h" />
|
||||
<Unit filename="hmg-vector3.h" />
|
||||
<Unit filename="matrix2x2.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
@ -112,10 +108,10 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="quaternion.h" />
|
||||
<Unit filename="slerp.c">
|
||||
<Unit filename="slerp3.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="slerp.h" />
|
||||
<Unit filename="slerp3.h" />
|
||||
<Unit filename="turn2.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
@ -124,6 +120,7 @@
|
|||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
<Unit filename="turn3.h" />
|
||||
<Unit filename="types.h" />
|
||||
<Unit filename="utilities.c">
|
||||
<Option compilerVar="CC" />
|
||||
</Unit>
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@
|
|||
#include "./turn2.h"
|
||||
#include "./turn3.h"
|
||||
|
||||
#include "./slerp3.h"
|
||||
|
||||
#include "./position2.h"
|
||||
#include "./position3.h"
|
||||
|
||||
#include "./slerp.h"
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -24,11 +24,11 @@
|
|||
<ClInclude Include="angle.h" />
|
||||
<ClInclude Include="basic-geometry.h" />
|
||||
<ClInclude Include="complex.h" />
|
||||
<ClInclude Include="dual-number.h" />
|
||||
<ClInclude Include="dual-scalar.h" />
|
||||
<ClInclude Include="dual-quaternion.h" />
|
||||
<ClInclude Include="dual-vector3.h" />
|
||||
<ClInclude Include="hg-matrix3x3.h" />
|
||||
<ClInclude Include="hg-vector3.h" />
|
||||
<ClInclude Include="hmg-matrix3x3.h" />
|
||||
<ClInclude Include="hmg-vector3.h" />
|
||||
<ClInclude Include="matrix2x2.h" />
|
||||
<ClInclude Include="matrix2x3.h" />
|
||||
<ClInclude Include="matrix3x2.h" />
|
||||
|
|
@ -40,7 +40,7 @@
|
|||
<ClInclude Include="turn2.h" />
|
||||
<ClInclude Include="turn3.h" />
|
||||
<ClInclude Include="utilities.h" />
|
||||
<ClInclude Include="slerp.h" />
|
||||
<ClInclude Include="slerp3.h" />
|
||||
<ClInclude Include="vector2.h" />
|
||||
<ClInclude Include="vector3.h" />
|
||||
</ItemGroup>
|
||||
|
|
@ -49,11 +49,11 @@
|
|||
<ClCompile Include="affine3.c" />
|
||||
<ClCompile Include="angle.c" />
|
||||
<ClInclude Include="complex.c" />
|
||||
<ClCompile Include="dual-number.c" />
|
||||
<ClCompile Include="dual-scalar.c" />
|
||||
<ClCompile Include="dual-quaternion.c" />
|
||||
<ClCompile Include="dual-vector3.c" />
|
||||
<ClCompile Include="hg-matrix3x3.c" />
|
||||
<ClCompile Include="hg-vector3.c" />
|
||||
<ClCompile Include="hmg-matrix3x3.c" />
|
||||
<ClCompile Include="hmg-vector3.c" />
|
||||
<ClCompile Include="position2.c" />
|
||||
<ClCompile Include="position3.c" />
|
||||
<ClCompile Include="turn2.c" />
|
||||
|
|
@ -64,7 +64,7 @@
|
|||
<ClCompile Include="matrix3x2.c" />
|
||||
<ClCompile Include="matrix3x3.c" />
|
||||
<ClCompile Include="quaternion.c" />
|
||||
<ClCompile Include="slerp.c" />
|
||||
<ClCompile Include="slerp3.c" />
|
||||
<ClCompile Include="vector2.c" />
|
||||
<ClCompile Include="vector3.c" />
|
||||
</ItemGroup>
|
||||
|
|
|
|||
|
|
@ -1,55 +0,0 @@
|
|||
#include "./dual-number.h"
|
||||
|
||||
extern inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real, const float dual);
|
||||
extern inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real, const double dual);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source);
|
||||
extern inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second);
|
||||
extern inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_revert(BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_dual_number_revert(BGC_FP64_DualNumber* number);
|
||||
|
||||
extern inline void bgc_fp32_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_number_get_reverse(BGC_FP64_DualNumber* reverse, const BGC_FP64_DualNumber* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_conjugate(BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_dual_number_conjugate(BGC_FP64_DualNumber* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_get_conjugate(BGC_FP32_DualNumber* conjugate, const BGC_FP32_DualNumber* number);
|
||||
extern inline void bgc_fp64_dual_number_get_conjugate(BGC_FP64_DualNumber* conjugate, const BGC_FP64_DualNumber* number);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
|
||||
extern inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_add_scaled(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale);
|
||||
extern inline void bgc_fp64_dual_number_add_scaled(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend);
|
||||
extern inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_multiply_by_real_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier);
|
||||
extern inline void bgc_fp64_dual_number_multiply_by_real_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_multiply_by_dual_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
|
||||
extern inline void bgc_fp64_dual_number_multiply_by_dual_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_divide_by_real_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor);
|
||||
extern inline void bgc_fp64_dual_number_divide_by_real_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_divide_by_dual_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor);
|
||||
extern inline void bgc_fp64_dual_number_divide_by_dual_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second);
|
||||
extern inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_get_mean3(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const BGC_FP32_DualNumber* third);
|
||||
extern inline void bgc_fp64_dual_number_get_mean3(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const BGC_FP64_DualNumber* third);
|
||||
|
||||
extern inline void bgc_fp32_dual_number_interpolate(BGC_FP32_DualNumber* interpolation, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const float phase);
|
||||
extern inline void bgc_fp64_dual_number_interpolate(BGC_FP64_DualNumber* interpolation, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const double phase);
|
||||
|
|
@ -1,273 +0,0 @@
|
|||
#ifndef _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
#define _BGC_DUAL_NUMBER_H_INCLUDED_
|
||||
|
||||
#include "./utilities.h"
|
||||
#include "./types.h"
|
||||
|
||||
// =================== Reset ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->real = 0.0f;
|
||||
number->dual = 0.0f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->real = 0.0;
|
||||
number->dual = 0.0;
|
||||
}
|
||||
|
||||
// ==================== Make ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real, const float dual)
|
||||
{
|
||||
number->real = real;
|
||||
number->dual = dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real, const double dual)
|
||||
{
|
||||
number->real = real;
|
||||
number->dual = dual;
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source)
|
||||
{
|
||||
destination->real = source->real;
|
||||
destination->dual = source->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source)
|
||||
{
|
||||
destination->real = source->real;
|
||||
destination->dual = source->dual;
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp64_dual_number_convert_to_fp32(BGC_FP32_DualNumber* first, BGC_FP64_DualNumber* second)
|
||||
{
|
||||
first->real = (float) second->real;
|
||||
first->dual = (float) second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_convert_to_fp64(BGC_FP64_DualNumber* first, BGC_FP32_DualNumber* second)
|
||||
{
|
||||
first->real = second->real;
|
||||
first->dual = second->dual;
|
||||
}
|
||||
|
||||
// =================== Revert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_revert(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->real = -number->real;
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_revert(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->real = -number->real;
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ================ Get Reverse ================= //
|
||||
|
||||
inline void bgc_fp32_number_get_reverse(BGC_FP32_DualNumber* reverse, const BGC_FP32_DualNumber* number)
|
||||
{
|
||||
reverse->real = -number->real;
|
||||
reverse->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_number_get_reverse(BGC_FP64_DualNumber* reverse, const BGC_FP64_DualNumber* number)
|
||||
{
|
||||
reverse->real = -number->real;
|
||||
reverse->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ================= Conjugate ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_conjugate(BGC_FP32_DualNumber* number)
|
||||
{
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_conjugate(BGC_FP64_DualNumber* number)
|
||||
{
|
||||
number->dual = -number->dual;
|
||||
}
|
||||
|
||||
// =============== Get Conjugate ================ //
|
||||
|
||||
inline void bgc_fp32_dual_number_get_conjugate(BGC_FP32_DualNumber* conjugate, const BGC_FP32_DualNumber* number)
|
||||
{
|
||||
conjugate->real = number->real;
|
||||
conjugate->dual = -number->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_get_conjugate(BGC_FP64_DualNumber* conjugate, const BGC_FP64_DualNumber* number)
|
||||
{
|
||||
conjugate->real = number->real;
|
||||
conjugate->dual = -number->dual;
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
sum->real = first->real + second->real;
|
||||
sum->dual = first->dual + second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
sum->real = first->real + second->real;
|
||||
sum->dual = first->dual + second->dual;
|
||||
}
|
||||
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_dual_number_add_scaled(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale)
|
||||
{
|
||||
sum->real = base_number->real + scalable_number->real * scale;
|
||||
sum->dual = base_number->dual + scalable_number->dual * scale;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_add_scaled(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale)
|
||||
{
|
||||
sum->real = base_number->real + scalable_number->real * scale;
|
||||
sum->dual = base_number->dual + scalable_number->dual * scale;
|
||||
}
|
||||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend)
|
||||
{
|
||||
difference->real = minuend->real - subtrahend->real;
|
||||
difference->dual = minuend->dual - subtrahend->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend)
|
||||
{
|
||||
difference->real = minuend->real - subtrahend->real;
|
||||
difference->dual = minuend->dual - subtrahend->dual;
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_multiply_by_real_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier)
|
||||
{
|
||||
product->real = multiplicand->real * multiplier;
|
||||
product->dual = multiplicand->dual * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_multiply_by_real_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier)
|
||||
{
|
||||
product->real = multiplicand->real * multiplier;
|
||||
product->dual = multiplicand->dual * multiplier;
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_multiply_by_dual_number(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
product->real = first->real * second->real;
|
||||
product->dual = first->dual * second->real + first->real * second->dual;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_multiply_by_dual_number(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
product->real = first->real * second->real;
|
||||
product->dual = first->dual * second->real + first->real * second->dual;
|
||||
}
|
||||
|
||||
// =================== Divide =================== //
|
||||
|
||||
inline void bgc_fp32_dual_number_divide_by_real_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor)
|
||||
{
|
||||
bgc_fp32_dual_number_multiply_by_real_number(quotient, dividend, 1.0f / divisor);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_divide_by_real_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor)
|
||||
{
|
||||
bgc_fp64_dual_number_multiply_by_real_number(quotient, dividend, 1.0 / divisor);
|
||||
}
|
||||
|
||||
inline void bgc_fp32_dual_number_divide_by_dual_number(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const BGC_FP32_DualNumber* divisor)
|
||||
{
|
||||
const float mutliplier_real = 1 / divisor->real;
|
||||
|
||||
quotient->real = dividend->real * mutliplier_real;
|
||||
quotient->dual = dividend->dual * mutliplier_real - dividend->real * divisor->dual / (divisor->real * divisor->real);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_divide_by_dual_number(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const BGC_FP64_DualNumber* divisor)
|
||||
{
|
||||
const double mutliplier_real = 1 / divisor->real;
|
||||
|
||||
quotient->real = dividend->real * mutliplier_real;
|
||||
quotient->dual = dividend->dual * mutliplier_real - dividend->real * divisor->dual / (divisor->real * divisor->real);
|
||||
}
|
||||
|
||||
// ================ Mean of Two ================= //
|
||||
|
||||
inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
|
||||
{
|
||||
mean->real = (first->real + second->real) * 0.5f;
|
||||
mean->dual = (first->dual + second->dual) * 0.5f;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
|
||||
{
|
||||
mean->real = (first->real + second->real) * 0.5;
|
||||
mean->dual = (first->dual + second->dual) * 0.5;
|
||||
}
|
||||
|
||||
// =============== Mean of Three ================ //
|
||||
|
||||
inline void bgc_fp32_dual_number_get_mean3(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const BGC_FP32_DualNumber* third)
|
||||
{
|
||||
mean->real = (first->real + second->real + third->real) * BGC_FP32_ONE_THIRD;
|
||||
mean->dual = (first->dual + second->dual + third->dual) * BGC_FP32_ONE_THIRD;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_get_mean3(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const BGC_FP64_DualNumber* third)
|
||||
{
|
||||
mean->real = (first->real + second->real + third->real) * BGC_FP64_ONE_THIRD;
|
||||
mean->dual = (first->dual + second->dual + third->dual) * BGC_FP64_ONE_THIRD;
|
||||
}
|
||||
|
||||
// ============ Linear Interpolation ============ //
|
||||
|
||||
inline void bgc_fp32_dual_number_interpolate(BGC_FP32_DualNumber* interpolation, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const float phase)
|
||||
{
|
||||
const float counter_phase = 1.0f - phase;
|
||||
|
||||
interpolation->real = first->real *counter_phase + second->real * phase;
|
||||
interpolation->dual = first->dual *counter_phase + second->dual * phase;
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_number_interpolate(BGC_FP64_DualNumber* interpolation, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const double phase)
|
||||
{
|
||||
const double counter_phase = 1.0 - phase;
|
||||
|
||||
interpolation->real = first->real * counter_phase + second->real * phase;
|
||||
interpolation->dual = first->dual * counter_phase + second->dual * phase;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -8,112 +8,112 @@
|
|||
|
||||
inline void bgc_fp32_dual_quaternion_reset(BGC_FP32_DualQuaternion* quaternion)
|
||||
{
|
||||
bgc_fp32_quaternion_reset(&quaternion->real);
|
||||
bgc_fp32_quaternion_reset(&quaternion->dual);
|
||||
bgc_fp32_quaternion_reset(&quaternion->real_part);
|
||||
bgc_fp32_quaternion_reset(&quaternion->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_reset(BGC_FP64_DualQuaternion* quaternion)
|
||||
{
|
||||
bgc_fp64_quaternion_reset(&quaternion->real);
|
||||
bgc_fp64_quaternion_reset(&quaternion->dual);
|
||||
bgc_fp64_quaternion_reset(&quaternion->real_part);
|
||||
bgc_fp64_quaternion_reset(&quaternion->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Copy ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_copy(BGC_FP32_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp32_quaternion_copy(&destination->real, &source->real);
|
||||
bgc_fp32_quaternion_copy(&destination->dual, &source->dual);
|
||||
bgc_fp32_quaternion_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_quaternion_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_copy(BGC_FP64_DualQuaternion* destination, const BGC_FP64_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp64_quaternion_copy(&destination->real, &source->real);
|
||||
bgc_fp64_quaternion_copy(&destination->dual, &source->dual);
|
||||
bgc_fp64_quaternion_copy(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_quaternion_copy(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Swap ==================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_swap(BGC_FP32_DualQuaternion* first, BGC_FP32_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp32_quaternion_swap(&first->real, &second->real);
|
||||
bgc_fp32_quaternion_swap(&first->dual, &second->dual);
|
||||
bgc_fp32_quaternion_swap(&first->real_part, &second->real_part);
|
||||
bgc_fp32_quaternion_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_swap(BGC_FP64_DualQuaternion* first, BGC_FP64_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp64_quaternion_swap(&first->real, &second->real);
|
||||
bgc_fp64_quaternion_swap(&first->dual, &second->dual);
|
||||
bgc_fp64_quaternion_swap(&first->real_part, &second->real_part);
|
||||
bgc_fp64_quaternion_swap(&first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================== Convert =================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_convert_to_fp64(BGC_FP64_DualQuaternion* destination, const BGC_FP32_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->real, &source->real);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->dual, &source->dual);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->real_part, &source->real_part);
|
||||
bgc_fp32_quaternion_convert_to_fp64(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_convert_to_fp32(BGC_FP32_DualQuaternion* destination, const BGC_FP64_DualQuaternion* source)
|
||||
{
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->real, &source->real);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->dual, &source->dual);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->real_part, &source->real_part);
|
||||
bgc_fp64_quaternion_convert_to_fp32(&destination->dual_part, &source->dual_part);
|
||||
}
|
||||
|
||||
// ==================== Add ===================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_add(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* first, const BGC_FP32_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp32_quaternion_add(&sum->real, &first->real, &second->real);
|
||||
bgc_fp32_quaternion_add(&sum->dual, &first->dual, &second->dual);
|
||||
bgc_fp32_quaternion_add(&sum->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp32_quaternion_add(&sum->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_add(BGC_FP64_DualQuaternion* sum, const BGC_FP64_DualQuaternion* first, const BGC_FP64_DualQuaternion* second)
|
||||
{
|
||||
bgc_fp64_quaternion_add(&sum->real, &first->real, &second->real);
|
||||
bgc_fp64_quaternion_add(&sum->dual, &first->dual, &second->dual);
|
||||
bgc_fp64_quaternion_add(&sum->real_part, &first->real_part, &second->real_part);
|
||||
bgc_fp64_quaternion_add(&sum->dual_part, &first->dual_part, &second->dual_part);
|
||||
}
|
||||
|
||||
// ================= Add Scaled ================= //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_add_scaled(BGC_FP32_DualQuaternion* sum, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale)
|
||||
{
|
||||
bgc_fp32_quaternion_add_scaled(&sum->real, &base_quaternion->real, &scalable_quaternion->real, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
bgc_fp32_quaternion_add_scaled(&sum->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_add_scaled(BGC_FP64_DualQuaternion* sum, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale)
|
||||
{
|
||||
bgc_fp64_quaternion_add_scaled(&sum->real, &base_quaternion->real, &scalable_quaternion->real, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->dual, &base_quaternion->dual, &scalable_quaternion->dual, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->real_part, &base_quaternion->real_part, &scalable_quaternion->real_part, scale);
|
||||
bgc_fp64_quaternion_add_scaled(&sum->dual_part, &base_quaternion->dual_part, &scalable_quaternion->dual_part, scale);
|
||||
}
|
||||
|
||||
// ================== Subtract ================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_subtract(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* minuend, const BGC_FP32_DualQuaternion* subtrahend)
|
||||
{
|
||||
bgc_fp32_quaternion_subtract(&difference->real, &minuend->real, &subtrahend->real);
|
||||
bgc_fp32_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual);
|
||||
bgc_fp32_quaternion_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
|
||||
bgc_fp32_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* minuend, const BGC_FP64_DualQuaternion* subtrahend)
|
||||
{
|
||||
bgc_fp64_quaternion_subtract(&difference->real, &minuend->real, &subtrahend->real);
|
||||
bgc_fp64_quaternion_subtract(&difference->dual, &minuend->dual, &subtrahend->dual);
|
||||
bgc_fp64_quaternion_subtract(&difference->real_part, &minuend->real_part, &subtrahend->real_part);
|
||||
bgc_fp64_quaternion_subtract(&difference->dual_part, &minuend->dual_part, &subtrahend->dual_part);
|
||||
}
|
||||
|
||||
// ================== Multiply ================== //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multipier)
|
||||
{
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->real, &multiplicand->real, multipier);
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, multipier);
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multipier);
|
||||
bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multipier)
|
||||
{
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->real, &multiplicand->real, multipier);
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->dual, &multiplicand->dual, multipier);
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multipier);
|
||||
bgc_fp64_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multipier);
|
||||
}
|
||||
|
||||
// =================== Divide =================== //
|
||||
|
|
@ -132,70 +132,70 @@ inline void bgc_fp64_dual_quaternion_divide_by_real(BGC_FP64_DualQuaternion* quo
|
|||
|
||||
inline void bgc_fp32_dual_quaternion_get_mean2(BGC_FP32_DualQuaternion* mean, const BGC_FP32_DualQuaternion* quaternion1, const BGC_FP32_DualQuaternion* quaternion2)
|
||||
{
|
||||
bgc_fp32_quaternion_get_mean2(&mean->real, &quaternion1->real, &quaternion2->real);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part);
|
||||
bgc_fp32_quaternion_get_mean2(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_get_mean2(BGC_FP64_DualQuaternion* mean, const BGC_FP64_DualQuaternion* quaternion1, const BGC_FP64_DualQuaternion* quaternion2)
|
||||
{
|
||||
bgc_fp64_quaternion_get_mean2(&mean->real, &quaternion1->real, &quaternion2->real);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->dual, &quaternion1->dual, &quaternion2->dual);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part);
|
||||
bgc_fp64_quaternion_get_mean2(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part);
|
||||
}
|
||||
|
||||
// =============== Mean of Three ================ //
|
||||
|
||||
inline void bgc_fp32_dual_quaternion_get_mean3(BGC_FP32_DualQuaternion* mean, const BGC_FP32_DualQuaternion* quaternion1, const BGC_FP32_DualQuaternion* quaternion2, const BGC_FP32_DualQuaternion* quaternion3)
|
||||
{
|
||||
bgc_fp32_quaternion_get_mean3(&mean->real, &quaternion1->real, &quaternion2->real, &quaternion3->real);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
|
||||
bgc_fp32_quaternion_get_mean3(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part, &quaternion3->dual_part);
|
||||
}
|
||||
|
||||
inline void bgc_fp64_dual_quaternion_get_mean3(BGC_FP64_DualQuaternion* mean, const BGC_FP64_DualQuaternion* quaternion1, const BGC_FP64_DualQuaternion* quaternion2, const BGC_FP64_DualQuaternion* quaternion3)
|
||||
{
|
||||
bgc_fp64_quaternion_get_mean3(&mean->real, &quaternion1->real, &quaternion2->real, &quaternion3->real);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->dual, &quaternion1->dual, &quaternion2->dual, &quaternion3->dual);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->real_part, &quaternion1->real_part, &quaternion2->real_part, &quaternion3->real_part);
|
||||
bgc_fp64_quaternion_get_mean3(&mean->dual_part, &quaternion1->dual_part, &quaternion2->dual_part, &quaternion3->dual_part);
|
||||
}
|
||||
|
||||
// ============ Linear Interpolation ============ //
|
||||
|
||||