Реорганизация проекта: перенос определения всех типов в один файл, перегруппировка функций в файлах

basic-geometry/affine2.c

@@ -1,4 +1,4 @@
-#include "affine2.h"
+#include "./affine2.h"
 
 extern inline void bgc_fp32_affine2_reset(BGC_FP32_Affine2* affine);
 extern inline void bgc_fp64_affine2_reset(BGC_FP64_Affine2* affine);

basic-geometry/affine2.h

@@ -1,21 +1,9 @@
 #ifndef _BGC_AFFINE2_H_INCLUDED_
 #define _BGC_AFFINE2_H_INCLUDED_
 
-#include "vector2.h"
+#include "./vector2.h"
-#include "matrices.h"
+#include "./types.h"
-#include "matrix2x2.h"
+#include "./matrix2x2.h"
-
-// ==================== Types ==================== //
-
-typedef struct {
-    BGC_FP32_Matrix2x2 distortion;
-    BGC_FP32_Vector2 shift;
-} BGC_FP32_Affine2;
-
-typedef struct {
-    BGC_FP64_Matrix2x2 distortion;
-    BGC_FP64_Vector2 shift;
-} BGC_FP64_Affine2;
 
 // ==================== Reset ==================== //
 
@@ -96,7 +84,7 @@ inline int bgc_fp32_affine2_invert(BGC_FP32_Affine2 * affine)
         return BGC_FAILURE;
     }
 
-    bgc_fp32_multiply_matrix2x2_by_vector2(&affine->shift, &affine->distortion, &affine->shift);
+    bgc_fp32_matrix2x2_multiply_by_vector2(&affine->shift, &affine->distortion, &affine->shift);
     bgc_fp32_vector2_revert(&affine->shift);
 
     return BGC_SUCCESS;
@@ -108,7 +96,7 @@ inline int bgc_fp64_affine2_invert(BGC_FP64_Affine2 * affine)
         return BGC_FAILURE;
     }
 
-    bgc_fp64_multiply_matrix2x2_by_vector2(&affine->shift, &affine->distortion, &affine->shift);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&affine->shift, &affine->distortion, &affine->shift);
     bgc_fp64_vector2_revert(&affine->shift);
 
     return BGC_SUCCESS;
@@ -122,7 +110,7 @@ inline int bgc_fp32_affine2_get_inverse(BGC_FP32_Affine2* inverse, const BGC_FP3
         return BGC_FAILURE;
     }
 
-    bgc_fp32_multiply_matrix2x2_by_vector2(&inverse->shift, &inverse->distortion, &affine->shift);
+    bgc_fp32_matrix2x2_multiply_by_vector2(&inverse->shift, &inverse->distortion, &affine->shift);
     bgc_fp32_vector2_revert(&inverse->shift);
 
     return BGC_SUCCESS;
@@ -134,7 +122,7 @@ inline int bgc_fp64_affine2_get_inverse(BGC_FP64_Affine2* inverse, const BGC_FP6
         return BGC_FAILURE;
     }
 
-    bgc_fp64_multiply_matrix2x2_by_vector2(&inverse->shift, &inverse->distortion, &affine->shift);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&inverse->shift, &inverse->distortion, &affine->shift);
     bgc_fp64_vector2_revert(&inverse->shift);
 
     return BGC_SUCCESS;
@@ -145,16 +133,16 @@ inline int bgc_fp64_affine2_get_inverse(BGC_FP64_Affine2* inverse, const BGC_FP6
 inline void bgc_fp32_affine2_combine(BGC_FP32_Affine2* combination, const BGC_FP32_Affine2 * first, const BGC_FP32_Affine2 * second)
 {
     BGC_FP32_Vector2 first_shift;
-    bgc_fp32_multiply_matrix2x2_by_vector2(&first_shift, &second->distortion, &first->shift);
+    bgc_fp32_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
-    bgc_fp32_multiply_matrix2x2_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
+    bgc_fp32_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp32_vector2_add(&combination->shift, &second->shift, &first_shift);
 }
 
 inline void bgc_fp64_affine2_combine(BGC_FP64_Affine2* combination, const BGC_FP64_Affine2 * first, const BGC_FP64_Affine2 * second)
 {
     BGC_FP64_Vector2 first_shift;
-    bgc_fp64_multiply_matrix2x2_by_vector2(&first_shift, &second->distortion, &first->shift);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&first_shift, &second->distortion, &first->shift);
-    bgc_fp64_multiply_matrix2x2_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
+    bgc_fp64_matrix2x2_multiply_by_matrix2x2(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp64_vector2_add(&combination->shift, &second->shift, &first_shift);
 }
 
@@ -163,14 +151,14 @@ inline void bgc_fp64_affine2_combine(BGC_FP64_Affine2* combination, const BGC_FP
 inline void bgc_fp32_affine2_transform_point(BGC_FP32_Vector2* transformed_point, const BGC_FP32_Affine2 * affine, const BGC_FP32_Vector2 * initial_point)
 {
     BGC_FP32_Vector2 distorted;
-    bgc_fp32_multiply_matrix2x2_by_vector2(&distorted, &affine->distortion, initial_point);
+    bgc_fp32_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
     bgc_fp32_vector2_add(transformed_point, &affine->shift, &distorted);
 }
 
 inline void bgc_fp64_affine2_transform_point(BGC_FP64_Vector2* transformed_point, const BGC_FP64_Affine2 * affine, const BGC_FP64_Vector2 * initial_point)
 {
     BGC_FP64_Vector2 distorted;
-    bgc_fp64_multiply_matrix2x2_by_vector2(&distorted, &affine->distortion, initial_point);
+    bgc_fp64_matrix2x2_multiply_by_vector2(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector2_add(transformed_point, &affine->shift, &distorted);
 }
 
@@ -178,12 +166,12 @@ inline void bgc_fp64_affine2_transform_point(BGC_FP64_Vector2* transformed_point
 
 inline void bgc_fp32_affine2_transform_vector(BGC_FP32_Vector2* transformed_vector, const BGC_FP32_Affine2 * affine, const BGC_FP32_Vector2 * initial_vector)
 {
-    bgc_fp32_multiply_matrix2x2_by_vector2(transformed_vector, &affine->distortion, initial_vector);
+    bgc_fp32_matrix2x2_multiply_by_vector2(transformed_vector, &affine->distortion, initial_vector);
 }
 
 inline void bgc_fp64_affine2_transform_vector(BGC_FP64_Vector2* transformed_vector, const BGC_FP64_Affine2 * affine, const BGC_FP64_Vector2 * initial_vector)
 {
-    bgc_fp64_multiply_matrix2x2_by_vector2(transformed_vector, &affine->distortion, initial_vector);
+    bgc_fp64_matrix2x2_multiply_by_vector2(transformed_vector, &affine->distortion, initial_vector);
 }
 
 #endif

basic-geometry/affine3.c

@@ -1,4 +1,4 @@
-#include "affine3.h"
+#include "./affine3.h"
 
 extern inline void bgc_fp32_affine3_reset(BGC_FP32_Affine3* affine);
 extern inline void bgc_fp64_affine3_reset(BGC_FP64_Affine3* affine);

basic-geometry/affine3.h

@@ -1,21 +1,9 @@
 #ifndef _BGC_AFFINE3_H_INCLUDED_
 #define _BGC_AFFINE3_H_INCLUDED_
 
-#include "vector3.h"
+#include "./vector3.h"
-#include "matrices.h"
+#include "./types.h"
-#include "matrix3x3.h"
+#include "./matrix3x3.h"
-
-// ==================== Types ==================== //
-
-typedef struct {
-    BGC_FP32_Matrix3x3 distortion;
-    BGC_FP32_Vector3 shift;
-} BGC_FP32_Affine3;
-
-typedef struct {
-    BGC_FP64_Matrix3x3 distortion;
-    BGC_FP64_Vector3 shift;
-} BGC_FP64_Affine3;
 
 // ==================== Reset ==================== //
 
@@ -95,7 +83,7 @@ inline int bgc_fp32_affine3_invert(BGC_FP32_Affine3 * affine)
         return BGC_FAILURE;
     }
 
-    bgc_fp32_multiply_matrix3x3_by_vector3(&affine->shift, &affine->distortion, &affine->shift);
+    bgc_fp32_matrix3x3_multiply_by_vector3(&affine->shift, &affine->distortion, &affine->shift);
     bgc_fp32_vector3_revert(&affine->shift);
 
     return BGC_SUCCESS;
@@ -107,7 +95,7 @@ inline int bgc_fp64_affine3_invert(BGC_FP64_Affine3 * affine)
         return BGC_FAILURE;
     }
 
-    bgc_fp64_multiply_matrix3x3_by_vector3(&affine->shift, &affine->distortion, &affine->shift);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&affine->shift, &affine->distortion, &affine->shift);
     bgc_fp64_vector3_revert(&affine->shift);
 
     return BGC_SUCCESS;
@@ -121,7 +109,7 @@ inline int bgc_fp32_affine3_get_inverse(BGC_FP32_Affine3* destination, const BGC
         return BGC_FAILURE;
     }
 
-    bgc_fp32_multiply_matrix3x3_by_vector3(&destination->shift, &destination->distortion, &source->shift);
+    bgc_fp32_matrix3x3_multiply_by_vector3(&destination->shift, &destination->distortion, &source->shift);
     bgc_fp32_vector3_revert(&destination->shift);
 
     return BGC_SUCCESS;
@@ -133,7 +121,7 @@ inline int bgc_fp64_affine3_get_inverse(BGC_FP64_Affine3* destination, const BGC
         return BGC_FAILURE;
     }
 
-    bgc_fp64_multiply_matrix3x3_by_vector3(&destination->shift, &destination->distortion, &source->shift);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&destination->shift, &destination->distortion, &source->shift);
     bgc_fp64_vector3_revert(&destination->shift);
 
     return BGC_SUCCESS;
@@ -144,16 +132,16 @@ inline int bgc_fp64_affine3_get_inverse(BGC_FP64_Affine3* destination, const BGC
 inline void bgc_fp32_affine3_combine(BGC_FP32_Affine3* combination, const BGC_FP32_Affine3 * first, const BGC_FP32_Affine3 * second)
 {
     BGC_FP32_Vector3 first_shift;
-    bgc_fp32_multiply_matrix3x3_by_vector3(&first_shift, &second->distortion, &first->shift);
+    bgc_fp32_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
-    bgc_fp32_multiply_matrix3x3_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
+    bgc_fp32_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp32_vector3_add(&combination->shift, &first_shift, &second->shift);
 }
 
 inline void bgc_fp64_affine3_combine(BGC_FP64_Affine3* combination, const BGC_FP64_Affine3 * first, const BGC_FP64_Affine3 * second)
 {
     BGC_FP64_Vector3 first_shift;
-    bgc_fp64_multiply_matrix3x3_by_vector3(&first_shift, &second->distortion, &first->shift);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&first_shift, &second->distortion, &first->shift);
-    bgc_fp64_multiply_matrix3x3_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
+    bgc_fp64_matrix3x3_multiply_by_matrix3x3(&combination->distortion, &second->distortion, &first->distortion);
     bgc_fp64_vector3_add(&combination->shift, &first_shift, &second->shift);
 }
 
@@ -162,14 +150,14 @@ inline void bgc_fp64_affine3_combine(BGC_FP64_Affine3* combination, const BGC_FP
 inline void bgc_fp32_affine3_transform_point(BGC_FP32_Vector3* transformed_point, const BGC_FP32_Affine3 * affine, const BGC_FP32_Vector3 * initial_point)
 {
     BGC_FP32_Vector3 distorted;
-    bgc_fp32_multiply_matrix3x3_by_vector3(&distorted, &affine->distortion, initial_point);
+    bgc_fp32_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
     bgc_fp32_vector3_add(transformed_point, &affine->shift, &distorted);
 }
 
 inline void bgc_fp64_affine3_transform_point(BGC_FP64_Vector3* transformed_point, const BGC_FP64_Affine3 * affine, const BGC_FP64_Vector3 * initial_point)
 {
     BGC_FP64_Vector3 distorted;
-    bgc_fp64_multiply_matrix3x3_by_vector3(&distorted, &affine->distortion, initial_point);
+    bgc_fp64_matrix3x3_multiply_by_vector3(&distorted, &affine->distortion, initial_point);
     bgc_fp64_vector3_add(transformed_point, &affine->shift, &distorted);
 }
 
@@ -177,12 +165,12 @@ inline void bgc_fp64_affine3_transform_point(BGC_FP64_Vector3* transformed_point
 
 inline void bgc_fp32_affine3_transform_vector(BGC_FP32_Vector3* transformed_vector, const BGC_FP32_Affine3 * affine, const BGC_FP32_Vector3 * initial_vector)
 {
-    bgc_fp32_multiply_matrix3x3_by_vector3(transformed_vector, &affine->distortion, initial_vector);
+    bgc_fp32_matrix3x3_multiply_by_vector3(transformed_vector, &affine->distortion, initial_vector);
 }
 
 inline void bgc_fp64_affine3_transform_vector(BGC_FP64_Vector3* transformed_vector, const BGC_FP64_Affine3 * affine, const BGC_FP64_Vector3 * initial_vector)
 {
-    bgc_fp64_multiply_matrix3x3_by_vector3(transformed_vector, &affine->distortion, initial_vector);
+    bgc_fp64_matrix3x3_multiply_by_vector3(transformed_vector, &affine->distortion, initial_vector);
 }
 
 #endif

basic-geometry/angle.c

@@ -1,5 +1,5 @@
-#include "utilities.h"
+#include "./utilities.h"
-#include "angle.h"
+#include "./angle.h"
 
 // !================= Radians ==================! //
 

basic-geometry/angle.h

@@ -2,7 +2,7 @@
 #define _BGC_ANGLE_H_INCLUDED_
 
 #include <math.h>
-#include "utilities.h"
+#include "./utilities.h"
 
 #define BGC_FP32_PI               3.1415926536f
 #define BGC_FP32_TWO_PI           6.2831853072f

basic-geometry/basic-geometry.h

@@ -5,10 +5,11 @@
 
 #include "./angle.h"
 
+#include "./types.h"
+
 #include "./vector2.h"
 #include "./vector3.h"
 
-#include "./matrices.h"
 #include "./matrix2x2.h"
 #include "./matrix2x3.h"
 #include "./matrix3x2.h"

basic-geometry/basic-geometry.vcxproj

@@ -33,7 +33,7 @@
     <ClInclude Include="matrix2x3.h" />
     <ClInclude Include="matrix3x2.h" />
     <ClInclude Include="matrix3x3.h" />
-    <ClInclude Include="matrices.h" />
+    <ClInclude Include="types.h" />
     <ClInclude Include="position2.h" />
     <ClInclude Include="position3.h" />
     <ClInclude Include="quaternion.h" />
@@ -63,7 +63,6 @@
     <ClCompile Include="matrix2x3.c" />
     <ClCompile Include="matrix3x2.c" />
     <ClCompile Include="matrix3x3.c" />
-    <ClCompile Include="matrices.c" />
     <ClCompile Include="quaternion.c" />
     <ClCompile Include="slerp.c" />
     <ClCompile Include="vector2.c" />

basic-geometry/basic-geometry.vcxproj.filters

@@ -48,7 +48,7 @@
     <ClInclude Include="matrix3x2.h">
       <Filter>Файлы заголовков</Filter>
     </ClInclude>
-    <ClInclude Include="matrices.h">
+    <ClInclude Include="types.h">
       <Filter>Файлы заголовков</Filter>
     </ClInclude>
     <ClInclude Include="complex.c">
@@ -113,9 +113,6 @@
     <ClCompile Include="quaternion.c">
       <Filter>Исходные файлы</Filter>
     </ClCompile>
-    <ClCompile Include="matrices.c">
-      <Filter>Исходные файлы</Filter>
-    </ClCompile>
     <ClCompile Include="matrix2x3.c">
       <Filter>Исходные файлы</Filter>
     </ClCompile>

basic-geometry/complex.h

@@ -1,20 +1,11 @@
 #ifndef _BGC_COMPLEX_H_INCLUDED_
 #define _BGC_COMPLEX_H_INCLUDED_
 
-#include "utilities.h"
-#include "angle.h"
-
 #include <math.h>
 
-typedef struct
+#include "./utilities.h"
-{
+#include "./types.h"
-    float real, imaginary;
+#include "./angle.h"
-} BGC_FP32_Complex;
-
-typedef struct
-{
-    double real, imaginary;
-} BGC_FP64_Complex;
 
 // =================== Reset ==================== //
 

basic-geometry/dual-number.c

@@ -1,4 +1,4 @@
-#include "dual-number.h"
+#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);

basic-geometry/dual-number.h

@@ -1,17 +1,8 @@
 #ifndef _BGC_DUAL_NUMBER_H_INCLUDED_
 #define _BGC_DUAL_NUMBER_H_INCLUDED_
 
-#include "utilities.h"
+#include "./utilities.h"
-
+#include "./types.h"
-// =================== Types ==================== //
-
-typedef struct {
-    float real, dual;
-} BGC_FP32_DualNumber;
-
-typedef struct {
-    double real, dual;
-} BGC_FP64_DualNumber;
 
 // =================== Reset ==================== //
 

basic-geometry/dual-quaternion.c

@@ -1,4 +1,4 @@
-#include "dual-quaternion.h"
+#include "./dual-quaternion.h"
 
 extern inline void bgc_fp32_dual_quaternion_reset(BGC_FP32_DualQuaternion* quaternion);
 extern inline void bgc_fp64_dual_quaternion_reset(BGC_FP64_DualQuaternion* quaternion);

basic-geometry/dual-quaternion.h

@@ -1,17 +1,8 @@
 #ifndef _BGC_DUAL_QUATERNION_H_INCLUDED_
 #define _BGC_DUAL_QUATERNION_H_INCLUDED_
 
-#include "quaternion.h"
+#include "./types.h"
-
+#include "./quaternion.h"
-// =================== Types ==================== //
-
-typedef struct {
-    BGC_FP32_Quaternion real, dual;
-} BGC_FP32_DualQuaternion;
-
-typedef struct {
-    BGC_FP64_Quaternion real, dual;
-} BGC_FP64_DualQuaternion;
 
 // =================== Reset ==================== //
 

basic-geometry/dual-vector3.h

@@ -1,18 +1,9 @@
 #ifndef _BGC_DUAL_VECTOR3_H_INCLUDED_
 #define _BGC_DUAL_VECTOR3_H_INCLUDED_
 
+#include "./types.h"
 #include "./vector3.h"
 
-// =================== Types ==================== //
-
-typedef struct {
-    BGC_FP32_Vector3 real, dual;
-} BGC_FP32_DualVector3;
-
-typedef struct {
-    BGC_FP64_Vector3 real, dual;
-} BGC_FP64_DualVector3;
-
 // =================== Reset ==================== //
 
 inline void bgc_fp32_dual_vector3_reset(BGC_FP32_DualVector3* vector)
@@ -147,14 +138,14 @@ inline void bgc_fp64_dual_vector3_subtract(BGC_FP64_DualVector3* difference, con
 
 inline void bgc_fp32_dual_vector3_multiply(BGC_FP32_DualVector3* product, const BGC_FP32_DualVector3* multiplicand, const float multiplier)
 {
-    bgc_fp32_vector3_multiply(&product->real, &multiplicand->real, multiplier);
+    bgc_fp32_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier);
-    bgc_fp32_vector3_multiply(&product->dual, &multiplicand->dual, multiplier);
+    bgc_fp32_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier);
 }
 
 inline void bgc_fp64_dual_vector3_multiply(BGC_FP64_DualVector3* product, const BGC_FP64_DualVector3* multiplicand, const double multiplier)
 {
-    bgc_fp64_vector3_multiply(&product->real, &multiplicand->real, multiplier);
+    bgc_fp64_vector3_multiply_by_real(&product->real, &multiplicand->real, multiplier);
-    bgc_fp64_vector3_multiply(&product->dual, &multiplicand->dual, multiplier);
+    bgc_fp64_vector3_multiply_by_real(&product->dual, &multiplicand->dual, multiplier);
 }
 
 // =================== Divide =================== //
@@ -167,8 +158,8 @@ inline int bgc_fp32_dual_vector3_divide(BGC_FP32_DualVector3* quotient, const BG
 
     const float multiplier = 1.0f / divisor;
 
-    bgc_fp32_vector3_multiply(&quotient->real, &dividend->real, multiplier);
+    bgc_fp32_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier);
-    bgc_fp32_vector3_multiply(&quotient->dual, &dividend->dual, multiplier);
+    bgc_fp32_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier);
 
     return BGC_SUCCESS;
 }
@@ -181,8 +172,8 @@ inline int bgc_fp64_dual_vector3_divide(BGC_FP64_DualVector3* quotient, const BG
 
     const double multiplier = 1.0 / divisor;
 
-    bgc_fp64_vector3_multiply(&quotient->real, &dividend->real, multiplier);
+    bgc_fp64_vector3_multiply_by_real(&quotient->real, &dividend->real, multiplier);
-    bgc_fp64_vector3_multiply(&quotient->dual, &dividend->dual, multiplier);
+    bgc_fp64_vector3_multiply_by_real(&quotient->dual, &dividend->dual, multiplier);
 
     return BGC_SUCCESS;
 }

basic-geometry/hg-matrix3x3.c

@@ -1,4 +1,4 @@
-#include "hg-matrix3x3.h"
+#include "./hg-matrix3x3.h"
 
 inline void bgc_fp32_hg_matrix3x3_reset(BGC_FP32_HgMatrix3x3* homogeneous_matrix);
 inline void bgc_fp64_hg_matrix3x3_reset(BGC_FP64_HgMatrix3x3* homogeneous_matrix);

basic-geometry/hg-matrix3x3.h

@@ -1,28 +1,10 @@
 #ifndef _BGC_HG_MATRIX3X3_H_INCLUDED_
 #define _BGC_HG_MATRIX3X3_H_INCLUDED_
 
-#include "vector3.h"
+#include "./vector3.h"
-#include "matrices.h"
+#include "./types.h"
 
-#include "hg-vector3.h"
+#include "./hg-vector3.h"
-
-// =================== Types ==================== //
-
-typedef struct
-{
-    float r1c1, r1c2, r1c3, r1d0;
-    float r2c1, r2c2, r2c3, r2d0;
-    float r3c1, r3c2, r3c3, r3d0;
-    float d0c1, d0c2, d0c3, d0d0;
-} BGC_FP32_HgMatrix3x3;
-
-typedef struct
-{
-    double r1c1, r1c2, r1c3, r1d0;
-    double r2c1, r2c2, r2c3, r2d0;
-    double r3c1, r3c2, r3c3, r3d0;
-    double d0c1, d0c2, d0c3, d0d0;
-} BGC_FP64_HgMatrix3x3;
 
 // =================== Reset ==================== //
 

basic-geometry/hg-vector3.h

@@ -1,21 +1,8 @@
 #ifndef _BGC_HG_VECTOR3_H_INCLUDED_
 #define _BGC_HG_VECTOR3_H_INCLUDED_
 
-#include "./vector3.h"
+#include "./types.h"
-
+#include "./utilities.h"
-// ================== Vector3 =================== //
-
-// Homogeneous 3D Vector
-typedef struct
-{
-    float x1, x2, x3, d0;
-} BGC_FP32_HgVector3;
-
-// Homogeneous 3D Vector
-typedef struct
-{
-    double x1, x2, x3, d0;
-} BGC_FP64_HgVector3;
 
 // ================ Reset Point ================= //
 

basic-geometry/matrices.c

@@ -1,25 +0,0 @@
-#include "matrices.h"
-
-extern inline void bgc_fp32_multiply_matrix2x2_by_matrix2x2(BGC_FP32_Matrix2x2* product, const BGC_FP32_Matrix2x2* matrix1, const BGC_FP32_Matrix2x2* matrix2);
-extern inline void bgc_fp64_multiply_matrix2x2_by_matrix2x2(BGC_FP64_Matrix2x2* product, const BGC_FP64_Matrix2x2* matrix1, const BGC_FP64_Matrix2x2* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix2x2_by_matrix3x2(BGC_FP32_Matrix3x2* product, const BGC_FP32_Matrix2x2* matrix1, const BGC_FP32_Matrix3x2* matrix2);
-extern inline void bgc_fp64_multiply_matrix2x2_by_matrix3x2(BGC_FP64_Matrix3x2* product, const BGC_FP64_Matrix2x2* matrix1, const BGC_FP64_Matrix3x2* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix2x3_by_matrix2x2(BGC_FP32_Matrix2x3* product, const BGC_FP32_Matrix2x3* matrix1, const BGC_FP32_Matrix2x2* matrix2);
-extern inline void bgc_fp64_multiply_matrix2x3_by_matrix2x2(BGC_FP64_Matrix2x3* product, const BGC_FP64_Matrix2x3* matrix1, const BGC_FP64_Matrix2x2* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix2x3_by_matrix3x2(BGC_FP32_Matrix3x3* product, const BGC_FP32_Matrix2x3* matrix1, const BGC_FP32_Matrix3x2* matrix2);
-extern inline void bgc_fp64_multiply_matrix2x3_by_matrix3x2(BGC_FP64_Matrix3x3* product, const BGC_FP64_Matrix2x3* matrix1, const BGC_FP64_Matrix3x2* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix3x2_by_matrix2x3(BGC_FP32_Matrix2x2* product, const BGC_FP32_Matrix3x2* matrix1, const BGC_FP32_Matrix2x3* matrix2);
-extern inline void bgc_fp64_multiply_matrix3x2_by_matrix2x3(BGC_FP64_Matrix2x2* product, const BGC_FP64_Matrix3x2* matrix1, const BGC_FP64_Matrix2x3* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix3x2_by_matrix3x3(BGC_FP32_Matrix3x2* product, const BGC_FP32_Matrix3x2* matrix1, const BGC_FP32_Matrix3x3* matrix2);
-extern inline void bgc_fp64_multiply_matrix3x2_by_matrix3x3(BGC_FP64_Matrix3x2* product, const BGC_FP64_Matrix3x2* matrix1, const BGC_FP64_Matrix3x3* matrix2);
-
-extern inline void bgc_fp32_multiply_matrix3x3_by_matrix2x3(BGC_FP32_Matrix2x3* product, const BGC_FP32_Matrix3x3* matrix1, const BGC_FP32_Matrix2x3* matrix2);
-extern inline void bgc_fp64_multiply_matrix3x3_by_matrix2x3(BGC_FP64_Matrix2x3* product, const BGC_FP64_Matrix3x3* matrix1, const BGC_FP64_Matrix2x3* matrix2);
-