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>
#include <stdint.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
{
    int32_t x;
    int32_t y;
    int32_t z;
    int32_t 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;
 
MRC_API const int32_t *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, int32_t e);
 
MRC_API bool *MR_Vector4b_index(MR_Vector4b *_this, int32_t 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 int32_t *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(int32_t x, int32_t y, int32_t z, int32_t w);
 
MRC_API MR_Vector4i MR_Vector4i_diagonal(int32_t a);
 
MRC_API const int32_t *MR_Vector4i_index_const(const MR_Vector4i *_this, int32_t e);
 
MRC_API int32_t *MR_Vector4i_index(MR_Vector4i *_this, int32_t e);
 
MRC_API int32_t 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_int32_t_MR_Vector4i(int32_t a, const MR_Vector4i *b);
 
MRC_API MR_Vector4i MR_mul_MR_Vector4i_int32_t(const MR_Vector4i *b, int32_t a);
 
MRC_API MR_Vector4i MR_div_MR_Vector4i_int32_t(MR_Vector4i b, int32_t 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_int32_t(MR_Vector4i *a, int32_t b);
 
MRC_API MR_Vector4i *MR_div_assign_MR_Vector4i_int32_t(MR_Vector4i *a, int32_t b);
 
MRC_API const int32_t *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, int32_t e);
 
MRC_API MR_int64_t *MR_Vector4i64_index(MR_Vector4i64 *_this, int32_t 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 int32_t *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, int32_t e);
 
MRC_API float *MR_Vector4f_index(MR_Vector4f *_this, int32_t 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 int32_t *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, int32_t e);
 
MRC_API double *MR_Vector4d_index(MR_Vector4d *_this, int32_t 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 int32_t MR_dot_bool_MR_Vector4b(const MR_Vector4b *a, const MR_Vector4b *b);
 
MRC_API int32_t MR_dot_int32_t_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);
 
#ifdef __cplusplus
} // extern "C"
#endif