MRVector4.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRVector3.h>
#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_Vector4b
{
    bool x;
    bool y;
    bool z;
    bool w;
} MR_Vector4b;
 
typedef struct MR_Vector4i
{
    int x;
    int y;
    int z;
    int w;
} MR_Vector4i;
 
typedef struct MR_Vector4i64
{
    MR_int64_t x;
    MR_int64_t y;
    MR_int64_t z;
    MR_int64_t w;
} MR_Vector4i64;
 
typedef struct MR_Vector4f
{
    float x;
    float y;
    float z;
    float w;
} MR_Vector4f;
 
typedef struct MR_Vector4d
{
    double x;
    double y;
    double z;
    double w;
} MR_Vector4d;
 
typedef struct MR_Vector4_unsigned_char MR_Vector4_unsigned_char;
 
MRC_API const int *MR_Vector4b_Get_elements(void);
 
MRC_API MR_Vector4b MR_Vector4b_DefaultConstruct(void);
 
MRC_API MR_Vector4b *MR_Vector4b_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector4b MR_Vector4b_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4b MR_Vector4b_Construct_4(bool x, bool y, bool z, bool w);
 
MRC_API MR_Vector4b MR_Vector4b_diagonal(bool a);
 
MRC_API const bool *MR_Vector4b_index_const(const MR_Vector4b *_this, int e);
 
MRC_API bool *MR_Vector4b_index(MR_Vector4b *_this, int e);
 
MRC_API bool MR_Vector4b_lengthSq(const MR_Vector4b *_this);
 
MRC_API double MR_Vector4b_length(const MR_Vector4b *_this);
 
MRC_API bool MR_equal_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API bool MR_not_equal_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *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_Vector4b *MR_pos_MR_Vector4b(const MR_Vector4b *a);
 
MRC_API MR_Vector4i MR_neg_MR_Vector4b(const MR_Vector4b *a);
 
MRC_API MR_Vector4i MR_add_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API MR_Vector4i MR_sub_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API MR_Vector4i MR_mul_bool_MR_Vector4b(bool a, const MR_Vector4b *b);
 
MRC_API MR_Vector4i MR_mul_MR_Vector4b_bool(const MR_Vector4b *b, bool a);
 
MRC_API MR_Vector4i MR_div_MR_Vector4b_bool(MR_Vector4b b, bool a);
 
MRC_API MR_Vector4b *MR_add_assign_MR_Vector4b(MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API MR_Vector4b *MR_sub_assign_MR_Vector4b(MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API MR_Vector4b *MR_mul_assign_MR_Vector4b_bool(MR_Vector4b *a, bool b);
 
MRC_API MR_Vector4b *MR_div_assign_MR_Vector4b_bool(MR_Vector4b *a, bool b);
 
MRC_API const int *MR_Vector4i_Get_elements(void);
 
MRC_API MR_Vector4i MR_Vector4i_DefaultConstruct(void);
 
MRC_API MR_Vector4i *MR_Vector4i_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector4i MR_Vector4i_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4i MR_Vector4i_Construct_4(int x, int y, int z, int w);
 
MRC_API MR_Vector4i MR_Vector4i_diagonal(int a);
 
MRC_API const int *MR_Vector4i_index_const(const MR_Vector4i *_this, int e);
 
MRC_API int *MR_Vector4i_index(MR_Vector4i *_this, int e);
 
MRC_API int MR_Vector4i_lengthSq(const MR_Vector4i *_this);
 
MRC_API double MR_Vector4i_length(const MR_Vector4i *_this);
 
MRC_API bool MR_equal_MR_Vector4i(const MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API bool MR_not_equal_MR_Vector4i(const MR_Vector4i *a, const MR_Vector4i *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_Vector4i *MR_pos_MR_Vector4i(const MR_Vector4i *a);
 
MRC_API MR_Vector4i MR_neg_MR_Vector4i(const MR_Vector4i *a);
 
MRC_API MR_Vector4i MR_add_MR_Vector4i(const MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i MR_sub_MR_Vector4i(const MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i MR_mul_int_MR_Vector4i(int a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i MR_mul_MR_Vector4i_int(const MR_Vector4i *b, int a);
 
MRC_API MR_Vector4i MR_div_MR_Vector4i_int(MR_Vector4i b, int a);
 
MRC_API MR_Vector4i *MR_add_assign_MR_Vector4i(MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i *MR_sub_assign_MR_Vector4i(MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i *MR_mul_assign_MR_Vector4i_int(MR_Vector4i *a, int b);
 
MRC_API MR_Vector4i *MR_div_assign_MR_Vector4i_int(MR_Vector4i *a, int b);
 
MRC_API const int *MR_Vector4i64_Get_elements(void);
 
MRC_API MR_Vector4i64 MR_Vector4i64_DefaultConstruct(void);
 
MRC_API MR_Vector4i64 *MR_Vector4i64_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector4i64 MR_Vector4i64_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4i64 MR_Vector4i64_Construct_4(MR_int64_t x, MR_int64_t y, MR_int64_t z, MR_int64_t w);
 
MRC_API MR_Vector4i64 MR_Vector4i64_diagonal(MR_int64_t a);
 
MRC_API const MR_int64_t *MR_Vector4i64_index_const(const MR_Vector4i64 *_this, int e);
 
MRC_API MR_int64_t *MR_Vector4i64_index(MR_Vector4i64 *_this, int e);
 
MRC_API MR_int64_t MR_Vector4i64_lengthSq(const MR_Vector4i64 *_this);
 
MRC_API double MR_Vector4i64_length(const MR_Vector4i64 *_this);
 
MRC_API bool MR_equal_MR_Vector4i64(const MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API bool MR_not_equal_MR_Vector4i64(const MR_Vector4i64 *a, const MR_Vector4i64 *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_Vector4i64 *MR_pos_MR_Vector4i64(const MR_Vector4i64 *a);
 
MRC_API MR_Vector4i64 MR_neg_MR_Vector4i64(const MR_Vector4i64 *a);
 
MRC_API MR_Vector4i64 MR_add_MR_Vector4i64(const MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API MR_Vector4i64 MR_sub_MR_Vector4i64(const MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API MR_Vector4i64 MR_mul_int64_t_MR_Vector4i64(MR_int64_t a, const MR_Vector4i64 *b);
 
MRC_API MR_Vector4i64 MR_mul_MR_Vector4i64_int64_t(const MR_Vector4i64 *b, MR_int64_t a);
 
MRC_API MR_Vector4i64 MR_div_MR_Vector4i64_int64_t(MR_Vector4i64 b, MR_int64_t a);
 
MRC_API MR_Vector4i64 *MR_add_assign_MR_Vector4i64(MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API MR_Vector4i64 *MR_sub_assign_MR_Vector4i64(MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API MR_Vector4i64 *MR_mul_assign_MR_Vector4i64_int64_t(MR_Vector4i64 *a, MR_int64_t b);
 
MRC_API MR_Vector4i64 *MR_div_assign_MR_Vector4i64_int64_t(MR_Vector4i64 *a, MR_int64_t b);
 
MRC_API const int *MR_Vector4f_Get_elements(void);
 
MRC_API MR_Vector4f MR_Vector4f_DefaultConstruct(void);
 
MRC_API MR_Vector4f *MR_Vector4f_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector4f MR_Vector4f_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4f MR_Vector4f_Construct_4(float x, float y, float z, float w);
 
MRC_API MR_Vector4f MR_Vector4f_diagonal(float a);
 
MRC_API const float *MR_Vector4f_index_const(const MR_Vector4f *_this, int e);
 
MRC_API float *MR_Vector4f_index(MR_Vector4f *_this, int e);
 
MRC_API float MR_Vector4f_lengthSq(const MR_Vector4f *_this);
 
MRC_API float MR_Vector4f_length(const MR_Vector4f *_this);
 
MRC_API MR_Vector4f MR_Vector4f_normalized(const MR_Vector4f *_this);
 
MRC_API MR_Vector3f MR_Vector4f_proj3d(const MR_Vector4f *_this);
 
MRC_API bool MR_Vector4f_isFinite(const MR_Vector4f *_this);
 
MRC_API bool MR_equal_MR_Vector4f(const MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API bool MR_not_equal_MR_Vector4f(const MR_Vector4f *a, const MR_Vector4f *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_Vector4f *MR_pos_MR_Vector4f(const MR_Vector4f *a);
 
MRC_API MR_Vector4f MR_neg_MR_Vector4f(const MR_Vector4f *a);
 
MRC_API MR_Vector4f MR_add_MR_Vector4f(const MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API MR_Vector4f MR_sub_MR_Vector4f(const MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API MR_Vector4f MR_mul_float_MR_Vector4f(float a, const MR_Vector4f *b);
 
MRC_API MR_Vector4f MR_mul_MR_Vector4f_float(const MR_Vector4f *b, float a);
 
MRC_API MR_Vector4f MR_div_MR_Vector4f_float(MR_Vector4f b, float a);
 
MRC_API MR_Vector4f *MR_add_assign_MR_Vector4f(MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API MR_Vector4f *MR_sub_assign_MR_Vector4f(MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API MR_Vector4f *MR_mul_assign_MR_Vector4f_float(MR_Vector4f *a, float b);
 
MRC_API MR_Vector4f *MR_div_assign_MR_Vector4f_float(MR_Vector4f *a, float b);
 
MRC_API const int *MR_Vector4d_Get_elements(void);
 
MRC_API MR_Vector4d MR_Vector4d_DefaultConstruct(void);
 
MRC_API MR_Vector4d *MR_Vector4d_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector4d MR_Vector4d_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4d MR_Vector4d_Construct_4(double x, double y, double z, double w);
 
MRC_API MR_Vector4d MR_Vector4d_diagonal(double a);
 
MRC_API const double *MR_Vector4d_index_const(const MR_Vector4d *_this, int e);
 
MRC_API double *MR_Vector4d_index(MR_Vector4d *_this, int e);
 
MRC_API double MR_Vector4d_lengthSq(const MR_Vector4d *_this);
 
MRC_API double MR_Vector4d_length(const MR_Vector4d *_this);
 
MRC_API MR_Vector4d MR_Vector4d_normalized(const MR_Vector4d *_this);
 
MRC_API MR_Vector3d MR_Vector4d_proj3d(const MR_Vector4d *_this);
 
MRC_API bool MR_Vector4d_isFinite(const MR_Vector4d *_this);
 
MRC_API bool MR_equal_MR_Vector4d(const MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API bool MR_not_equal_MR_Vector4d(const MR_Vector4d *a, const MR_Vector4d *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_Vector4d *MR_pos_MR_Vector4d(const MR_Vector4d *a);
 
MRC_API MR_Vector4d MR_neg_MR_Vector4d(const MR_Vector4d *a);
 
MRC_API MR_Vector4d MR_add_MR_Vector4d(const MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API MR_Vector4d MR_sub_MR_Vector4d(const MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API MR_Vector4d MR_mul_double_MR_Vector4d(double a, const MR_Vector4d *b);
 
MRC_API MR_Vector4d MR_mul_MR_Vector4d_double(const MR_Vector4d *b, double a);
 
MRC_API MR_Vector4d MR_div_MR_Vector4d_double(MR_Vector4d b, double a);
 
MRC_API MR_Vector4d *MR_add_assign_MR_Vector4d(MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API MR_Vector4d *MR_sub_assign_MR_Vector4d(MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API MR_Vector4d *MR_mul_assign_MR_Vector4d_double(MR_Vector4d *a, double b);
 
MRC_API MR_Vector4d *MR_div_assign_MR_Vector4d_double(MR_Vector4d *a, double b);
 
MRC_API const int *MR_Vector4_unsigned_char_Get_elements(void);
 
MRC_API const unsigned char *MR_Vector4_unsigned_char_Get_x(const MR_Vector4_unsigned_char *_this);
 
MRC_API void MR_Vector4_unsigned_char_Set_x(MR_Vector4_unsigned_char *_this, unsigned char value);
 
MRC_API unsigned char *MR_Vector4_unsigned_char_GetMutable_x(MR_Vector4_unsigned_char *_this);
 
MRC_API const unsigned char *MR_Vector4_unsigned_char_Get_y(const MR_Vector4_unsigned_char *_this);
 
MRC_API void MR_Vector4_unsigned_char_Set_y(MR_Vector4_unsigned_char *_this, unsigned char value);
 
MRC_API unsigned char *MR_Vector4_unsigned_char_GetMutable_y(MR_Vector4_unsigned_char *_this);
 
MRC_API const unsigned char *MR_Vector4_unsigned_char_Get_z(const MR_Vector4_unsigned_char *_this);
 
MRC_API void MR_Vector4_unsigned_char_Set_z(MR_Vector4_unsigned_char *_this, unsigned char value);
 
MRC_API unsigned char *MR_Vector4_unsigned_char_GetMutable_z(MR_Vector4_unsigned_char *_this);
 
MRC_API const unsigned char *MR_Vector4_unsigned_char_Get_w(const MR_Vector4_unsigned_char *_this);
 
MRC_API void MR_Vector4_unsigned_char_Set_w(MR_Vector4_unsigned_char *_this, unsigned char value);
 
MRC_API unsigned char *MR_Vector4_unsigned_char_GetMutable_w(MR_Vector4_unsigned_char *_this);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_DefaultConstruct(void);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_DefaultConstructArray(size_t num_elems);
 
MRC_API const MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_OffsetPtr(const MR_Vector4_unsigned_char *ptr, ptrdiff_t i);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_OffsetMutablePtr(MR_Vector4_unsigned_char *ptr, ptrdiff_t i);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_ConstructFromAnother(const MR_Vector4_unsigned_char *_other);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_Construct_4(unsigned char x, unsigned char y, unsigned char z, unsigned char w);
 
MRC_API void MR_Vector4_unsigned_char_Destroy(const MR_Vector4_unsigned_char *_this);
 
MRC_API void MR_Vector4_unsigned_char_DestroyArray(const MR_Vector4_unsigned_char *_this);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_AssignFromAnother(MR_Vector4_unsigned_char *_this, const MR_Vector4_unsigned_char *_other);
 
MRC_API MR_Vector4_unsigned_char *MR_Vector4_unsigned_char_diagonal(unsigned char a);
 
MRC_API const unsigned char *MR_Vector4_unsigned_char_index_const(const MR_Vector4_unsigned_char *_this, int e);
 
MRC_API unsigned char *MR_Vector4_unsigned_char_index(MR_Vector4_unsigned_char *_this, int e);
 
MRC_API unsigned char MR_Vector4_unsigned_char_lengthSq(const MR_Vector4_unsigned_char *_this);
 
MRC_API double MR_Vector4_unsigned_char_length(const MR_Vector4_unsigned_char *_this);
 
MRC_API bool MR_equal_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
MRC_API bool MR_not_equal_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *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_Vector4_unsigned_char *MR_pos_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a);
 
MRC_API MR_Vector4i MR_neg_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a);
 
MRC_API MR_Vector4i MR_add_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
MRC_API MR_Vector4i MR_sub_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
MRC_API MR_Vector4i MR_mul_unsigned_char_MR_Vector4_unsigned_char(unsigned char a, const MR_Vector4_unsigned_char *b);
 
MRC_API MR_Vector4i MR_mul_MR_Vector4_unsigned_char_unsigned_char(const MR_Vector4_unsigned_char *b, unsigned char a);
 
MRC_API MR_Vector4i MR_div_MR_Vector4_unsigned_char_unsigned_char(const MR_Vector4_unsigned_char *b, unsigned char a);
 
MRC_API MR_Vector4_unsigned_char *MR_add_assign_MR_Vector4_unsigned_char(MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
MRC_API MR_Vector4_unsigned_char *MR_sub_assign_MR_Vector4_unsigned_char(MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
MRC_API MR_Vector4_unsigned_char *MR_mul_assign_MR_Vector4_unsigned_char_unsigned_char(MR_Vector4_unsigned_char *a, unsigned char b);
 
MRC_API MR_Vector4_unsigned_char *MR_div_assign_MR_Vector4_unsigned_char_unsigned_char(MR_Vector4_unsigned_char *a, unsigned char b);
 
MRC_API int MR_dot_bool_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API int MR_dot_int_MR_Vector4i(const MR_Vector4i *a, const MR_Vector4i *b);
 
MRC_API MR_int64_t MR_dot_int64_t_MR_Vector4i64(const MR_Vector4i64 *a, const MR_Vector4i64 *b);
 
MRC_API float MR_dot_float_MR_Vector4f(const MR_Vector4f *a, const MR_Vector4f *b);
 
MRC_API double MR_dot_double_MR_Vector4d(const MR_Vector4d *a, const MR_Vector4d *b);
 
MRC_API int MR_dot_unsigned_char_MR_Vector4_unsigned_char(const MR_Vector4_unsigned_char *a, const MR_Vector4_unsigned_char *b);
 
#ifdef __cplusplus
} // extern "C"
#endif