MRVector2.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMisc/common.h>
#include <MRCMisc/exports.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_NoInit MR_NoInit; // Defined in `#include <MRCMesh/MRMeshFwd.h>`.
 
 
typedef struct MR_Vector2b
{
    bool x;
    bool y;
} MR_Vector2b;
 
typedef struct MR_Vector2i
{
    int x;
    int y;
} MR_Vector2i;
 
typedef struct MR_Vector2i64
{
    MR_int64_t x;
    MR_int64_t y;
} MR_Vector2i64;
 
typedef struct MR_Vector2f
{
    float x;
    float y;
} MR_Vector2f;
 
typedef struct MR_Vector2d
{
    double x;
    double y;
} MR_Vector2d;
 
MRC_API const int *MR_Vector2b_Get_elements(void);
 
MRC_API MR_Vector2b MR_Vector2b_DefaultConstruct(void);
 
MRC_API MR_Vector2b *MR_Vector2b_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector2b MR_Vector2b_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector2b MR_Vector2b_Construct_2(bool x, bool y);
 
MRC_API MR_Vector2b MR_Vector2b_diagonal(bool a);
 
MRC_API MR_Vector2b MR_Vector2b_plusX(void);
 
MRC_API MR_Vector2b MR_Vector2b_plusY(void);
 
MRC_API const bool *MR_Vector2b_index_const(const MR_Vector2b *_this, int e);
 
MRC_API bool *MR_Vector2b_index(MR_Vector2b *_this, int e);
 
MRC_API bool MR_Vector2b_lengthSq(const MR_Vector2b *_this);
 
MRC_API double MR_Vector2b_length(const MR_Vector2b *_this);
 
MRC_API bool MR_equal_MR_Vector2b(const MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API bool MR_not_equal_MR_Vector2b(const MR_Vector2b *a, const MR_Vector2b *b);
 
// NOTE: We use `std::declval()` in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping `a.x` and such. TODO fix this when we update libclang.
MRC_API const MR_Vector2b *MR_pos_MR_Vector2b(const MR_Vector2b *a);
 
MRC_API MR_Vector2i MR_neg_MR_Vector2b(const MR_Vector2b *a);
 
MRC_API MR_Vector2i MR_add_MR_Vector2b(const MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API MR_Vector2i MR_sub_MR_Vector2b(const MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API MR_Vector2i MR_mul_bool_MR_Vector2b(bool a, const MR_Vector2b *b);
 
MRC_API MR_Vector2i MR_mul_MR_Vector2b_bool(const MR_Vector2b *b, bool a);
 
MRC_API MR_Vector2i MR_div_MR_Vector2b_bool(MR_Vector2b b, bool a);
 
MRC_API MR_Vector2b *MR_add_assign_MR_Vector2b(MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API MR_Vector2b *MR_sub_assign_MR_Vector2b(MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API MR_Vector2b *MR_mul_assign_MR_Vector2b_bool(MR_Vector2b *a, bool b);
 
MRC_API MR_Vector2b *MR_div_assign_MR_Vector2b_bool(MR_Vector2b *a, bool b);
 
MRC_API const int *MR_Vector2i_Get_elements(void);
 
MRC_API MR_Vector2i MR_Vector2i_DefaultConstruct(void);
 
MRC_API MR_Vector2i *MR_Vector2i_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector2i MR_Vector2i_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector2i MR_Vector2i_Construct_2(int x, int y);
 
MRC_API MR_Vector2i MR_Vector2i_diagonal(int a);
 
MRC_API MR_Vector2i MR_Vector2i_plusX(void);
 
MRC_API MR_Vector2i MR_Vector2i_plusY(void);
 
MRC_API MR_Vector2i MR_Vector2i_minusX(void);
 
MRC_API MR_Vector2i MR_Vector2i_minusY(void);
 
MRC_API const int *MR_Vector2i_index_const(const MR_Vector2i *_this, int e);
 
MRC_API int *MR_Vector2i_index(MR_Vector2i *_this, int e);
 
MRC_API int MR_Vector2i_lengthSq(const MR_Vector2i *_this);
 
MRC_API double MR_Vector2i_length(const MR_Vector2i *_this);
 
MRC_API MR_Vector2i MR_Vector2i_furthestBasisVector(const MR_Vector2i *_this);
 
MRC_API MR_Vector2i MR_Vector2i_perpendicular(const MR_Vector2i *_this);
 
MRC_API bool MR_equal_MR_Vector2i(const MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API bool MR_not_equal_MR_Vector2i(const MR_Vector2i *a, const MR_Vector2i *b);
 
// NOTE: We use `std::declval()` in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping `a.x` and such. TODO fix this when we update libclang.
MRC_API const MR_Vector2i *MR_pos_MR_Vector2i(const MR_Vector2i *a);
 
MRC_API MR_Vector2i MR_neg_MR_Vector2i(const MR_Vector2i *a);
 
MRC_API MR_Vector2i MR_add_MR_Vector2i(const MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API MR_Vector2i MR_sub_MR_Vector2i(const MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API MR_Vector2i MR_mul_int_MR_Vector2i(int a, const MR_Vector2i *b);
 
MRC_API MR_Vector2i MR_mul_MR_Vector2i_int(const MR_Vector2i *b, int a);
 
MRC_API MR_Vector2i MR_div_MR_Vector2i_int(MR_Vector2i b, int a);
 
MRC_API MR_Vector2i *MR_add_assign_MR_Vector2i(MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API MR_Vector2i *MR_sub_assign_MR_Vector2i(MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API MR_Vector2i *MR_mul_assign_MR_Vector2i_int(MR_Vector2i *a, int b);
 
MRC_API MR_Vector2i *MR_div_assign_MR_Vector2i_int(MR_Vector2i *a, int b);
 
MRC_API const int *MR_Vector2i64_Get_elements(void);
 
MRC_API MR_Vector2i64 MR_Vector2i64_DefaultConstruct(void);
 
MRC_API MR_Vector2i64 *MR_Vector2i64_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector2i64 MR_Vector2i64_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector2i64 MR_Vector2i64_Construct_2(MR_int64_t x, MR_int64_t y);
 
MRC_API MR_Vector2i64 MR_Vector2i64_diagonal(MR_int64_t a);
 
MRC_API MR_Vector2i64 MR_Vector2i64_plusX(void);
 
MRC_API MR_Vector2i64 MR_Vector2i64_plusY(void);
 
MRC_API MR_Vector2i64 MR_Vector2i64_minusX(void);
 
MRC_API MR_Vector2i64 MR_Vector2i64_minusY(void);
 
MRC_API const MR_int64_t *MR_Vector2i64_index_const(const MR_Vector2i64 *_this, int e);
 
MRC_API MR_int64_t *MR_Vector2i64_index(MR_Vector2i64 *_this, int e);
 
MRC_API MR_int64_t MR_Vector2i64_lengthSq(const MR_Vector2i64 *_this);
 
MRC_API double MR_Vector2i64_length(const MR_Vector2i64 *_this);
 
MRC_API MR_Vector2i64 MR_Vector2i64_furthestBasisVector(const MR_Vector2i64 *_this);
 
MRC_API MR_Vector2i64 MR_Vector2i64_perpendicular(const MR_Vector2i64 *_this);
 
MRC_API bool MR_equal_MR_Vector2i64(const MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API bool MR_not_equal_MR_Vector2i64(const MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
// NOTE: We use `std::declval()` in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping `a.x` and such. TODO fix this when we update libclang.
MRC_API const MR_Vector2i64 *MR_pos_MR_Vector2i64(const MR_Vector2i64 *a);
 
MRC_API MR_Vector2i64 MR_neg_MR_Vector2i64(const MR_Vector2i64 *a);
 
MRC_API MR_Vector2i64 MR_add_MR_Vector2i64(const MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API MR_Vector2i64 MR_sub_MR_Vector2i64(const MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API MR_Vector2i64 MR_mul_int64_t_MR_Vector2i64(MR_int64_t a, const MR_Vector2i64 *b);
 
MRC_API MR_Vector2i64 MR_mul_MR_Vector2i64_int64_t(const MR_Vector2i64 *b, MR_int64_t a);
 
MRC_API MR_Vector2i64 MR_div_MR_Vector2i64_int64_t(MR_Vector2i64 b, MR_int64_t a);
 
MRC_API MR_Vector2i64 *MR_add_assign_MR_Vector2i64(MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API MR_Vector2i64 *MR_sub_assign_MR_Vector2i64(MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API MR_Vector2i64 *MR_mul_assign_MR_Vector2i64_int64_t(MR_Vector2i64 *a, MR_int64_t b);
 
MRC_API MR_Vector2i64 *MR_div_assign_MR_Vector2i64_int64_t(MR_Vector2i64 *a, MR_int64_t b);
 
MRC_API const int *MR_Vector2f_Get_elements(void);
 
MRC_API MR_Vector2f MR_Vector2f_DefaultConstruct(void);
 
MRC_API MR_Vector2f *MR_Vector2f_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector2f MR_Vector2f_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector2f MR_Vector2f_Construct_2(float x, float y);
 
MRC_API MR_Vector2f MR_Vector2f_diagonal(float a);
 
MRC_API MR_Vector2f MR_Vector2f_plusX(void);
 
MRC_API MR_Vector2f MR_Vector2f_plusY(void);
 
MRC_API MR_Vector2f MR_Vector2f_minusX(void);
 
MRC_API MR_Vector2f MR_Vector2f_minusY(void);
 
MRC_API const float *MR_Vector2f_index_const(const MR_Vector2f *_this, int e);
 
MRC_API float *MR_Vector2f_index(MR_Vector2f *_this, int e);
 
MRC_API float MR_Vector2f_lengthSq(const MR_Vector2f *_this);
 
MRC_API float MR_Vector2f_length(const MR_Vector2f *_this);
 
MRC_API MR_Vector2f MR_Vector2f_normalized(const MR_Vector2f *_this);
 
MRC_API MR_Vector2f MR_Vector2f_furthestBasisVector(const MR_Vector2f *_this);
 
MRC_API MR_Vector2f MR_Vector2f_perpendicular(const MR_Vector2f *_this);
 
MRC_API bool MR_Vector2f_isFinite(const MR_Vector2f *_this);
 
MRC_API bool MR_equal_MR_Vector2f(const MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API bool MR_not_equal_MR_Vector2f(const MR_Vector2f *a, const MR_Vector2f *b);
 
// NOTE: We use `std::declval()` in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping `a.x` and such. TODO fix this when we update libclang.
MRC_API const MR_Vector2f *MR_pos_MR_Vector2f(const MR_Vector2f *a);
 
MRC_API MR_Vector2f MR_neg_MR_Vector2f(const MR_Vector2f *a);
 
MRC_API MR_Vector2f MR_add_MR_Vector2f(const MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API MR_Vector2f MR_sub_MR_Vector2f(const MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API MR_Vector2f MR_mul_float_MR_Vector2f(float a, const MR_Vector2f *b);
 
MRC_API MR_Vector2f MR_mul_MR_Vector2f_float(const MR_Vector2f *b, float a);
 
MRC_API MR_Vector2f MR_div_MR_Vector2f_float(MR_Vector2f b, float a);
 
MRC_API MR_Vector2f *MR_add_assign_MR_Vector2f(MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API MR_Vector2f *MR_sub_assign_MR_Vector2f(MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API MR_Vector2f *MR_mul_assign_MR_Vector2f_float(MR_Vector2f *a, float b);
 
MRC_API MR_Vector2f *MR_div_assign_MR_Vector2f_float(MR_Vector2f *a, float b);
 
MRC_API const int *MR_Vector2d_Get_elements(void);
 
MRC_API MR_Vector2d MR_Vector2d_DefaultConstruct(void);
 
MRC_API MR_Vector2d *MR_Vector2d_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector2d MR_Vector2d_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector2d MR_Vector2d_Construct_2(double x, double y);
 
MRC_API MR_Vector2d MR_Vector2d_diagonal(double a);
 
MRC_API MR_Vector2d MR_Vector2d_plusX(void);
 
MRC_API MR_Vector2d MR_Vector2d_plusY(void);
 
MRC_API MR_Vector2d MR_Vector2d_minusX(void);
 
MRC_API MR_Vector2d MR_Vector2d_minusY(void);
 
MRC_API const double *MR_Vector2d_index_const(const MR_Vector2d *_this, int e);
 
MRC_API double *MR_Vector2d_index(MR_Vector2d *_this, int e);
 
MRC_API double MR_Vector2d_lengthSq(const MR_Vector2d *_this);
 
MRC_API double MR_Vector2d_length(const MR_Vector2d *_this);
 
MRC_API MR_Vector2d MR_Vector2d_normalized(const MR_Vector2d *_this);
 
MRC_API MR_Vector2d MR_Vector2d_furthestBasisVector(const MR_Vector2d *_this);
 
MRC_API MR_Vector2d MR_Vector2d_perpendicular(const MR_Vector2d *_this);
 
MRC_API bool MR_Vector2d_isFinite(const MR_Vector2d *_this);
 
MRC_API bool MR_equal_MR_Vector2d(const MR_Vector2d *a, const MR_Vector2d *b);
 
MRC_API bool MR_not_equal_MR_Vector2d(const MR_Vector2d *a, const MR_Vector2d *b);
 
// NOTE: We use `std::declval()` in the operators below because libclang 18 in our binding generator is bugged and chokes on decltyping `a.x` and such. TODO fix this when we update libclang.
MRC_API const MR_Vector2d *MR_pos_MR_Vector2d(const MR_Vector2d *a);
 
MRC_API MR_Vector2d MR_neg_MR_Vector2d(const MR_Vector2d *a);
 
MRC_API MR_Vector2d MR_add_MR_Vector2d(const MR_Vector2d *a, const MR_Vector2d *b);
 
MRC_API MR_Vector2d MR_sub_MR_Vector2d(const MR_Vector2d *a, const MR_Vector2d *b);
 
MRC_API MR_Vector2d MR_mul_double_MR_Vector2d(double a, const MR_Vector2d *b);
 
MRC_API MR_Vector2d MR_mul_MR_Vector2d_double(const MR_Vector2d *b, double a);
 
MRC_API MR_Vector2d MR_div_MR_Vector2d_double(MR_Vector2d b, double a);
 
MRC_API MR_Vector2d *MR_add_assign_MR_Vector2d(MR_Vector2d *a, const MR_Vector2d *b);
 
MRC_API MR_Vector2d *MR_sub_assign_MR_Vector2d(MR_Vector2d *a, const MR_Vector2d *b);
 
MRC_API MR_Vector2d *MR_mul_assign_MR_Vector2d_double(MR_Vector2d *a, double b);
 
MRC_API MR_Vector2d *MR_div_assign_MR_Vector2d_double(MR_Vector2d *a, double b);
 
MRC_API float MR_cross(const MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API int MR_dot_bool_MR_Vector2b(const MR_Vector2b *a, const MR_Vector2b *b);
 
MRC_API int MR_dot_int_MR_Vector2i(const MR_Vector2i *a, const MR_Vector2i *b);
 
MRC_API MR_int64_t MR_dot_int64_t_MR_Vector2i64(const MR_Vector2i64 *a, const MR_Vector2i64 *b);
 
MRC_API float MR_dot_float_MR_Vector2f(const MR_Vector2f *a, const MR_Vector2f *b);
 
MRC_API double MR_dot_double_MR_Vector2d(const MR_Vector2d *a, const MR_Vector2d *b);
 
#ifdef __cplusplus
} // extern "C"
#endif