MRVector3.h

Go to the documentation of this file.

#pragma once
 
#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_AffineXf3d MR_AffineXf3d; // Defined in `#include <MRCMesh/MRAffineXf.h>`.
typedef struct MR_AffineXf3f MR_AffineXf3f; // Defined in `#include <MRCMesh/MRAffineXf.h>`.
typedef struct MR_NoInit MR_NoInit; // Defined in `#include <MRCMesh/MRMeshFwd.h>`.
typedef struct MR_std_pair_MR_Vector3d_MR_Vector3d MR_std_pair_MR_Vector3d_MR_Vector3d; // Defined in `#include <MRCMisc/std_pair_MR_Vector3d_MR_Vector3d.h>`.
typedef struct MR_std_pair_MR_Vector3f_MR_Vector3f MR_std_pair_MR_Vector3f_MR_Vector3f; // Defined in `#include <MRCMisc/std_pair_MR_Vector3f_MR_Vector3f.h>`.
 
 
typedef struct MR_Vector3b
{
    bool x;
    bool y;
    bool z;
} MR_Vector3b;
 
typedef struct MR_Vector3i
{
    int32_t x;
    int32_t y;
    int32_t z;
} MR_Vector3i;
 
typedef struct MR_Vector3i64
{
    MR_int64_t x;
    MR_int64_t y;
    MR_int64_t z;
} MR_Vector3i64;
 
typedef struct MR_Vector3f
{
    float x;
    float y;
    float z;
} MR_Vector3f;
 
typedef struct MR_Vector3d
{
    double x;
    double y;
    double z;
} MR_Vector3d;
 
MRC_API const int32_t *MR_Vector3b_Get_elements(void);
 
MRC_API MR_Vector3b MR_Vector3b_DefaultConstruct(void);
 
MRC_API MR_Vector3b *MR_Vector3b_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector3b MR_Vector3b_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector3b MR_Vector3b_Construct_3(bool x, bool y, bool z);
 
MRC_API MR_Vector3b MR_Vector3b_diagonal(bool a);
 
MRC_API MR_Vector3b MR_Vector3b_plusX(void);
 
MRC_API MR_Vector3b MR_Vector3b_plusY(void);
 
MRC_API MR_Vector3b MR_Vector3b_plusZ(void);
 
MRC_API MR_Vector3b MR_Vector3b_minusX(void);
 
MRC_API MR_Vector3b MR_Vector3b_minusY(void);
 
MRC_API MR_Vector3b MR_Vector3b_minusZ(void);
 
MRC_API const bool *MR_Vector3b_index_const(const MR_Vector3b *_this, int32_t e);
 
MRC_API bool *MR_Vector3b_index(MR_Vector3b *_this, int32_t e);
 
MRC_API bool MR_Vector3b_lengthSq(const MR_Vector3b *_this);
 
MRC_API double MR_Vector3b_length(const MR_Vector3b *_this);
 
MRC_API bool MR_equal_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API bool MR_not_equal_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *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_Vector3b *MR_pos_MR_Vector3b(const MR_Vector3b *a);
 
MRC_API MR_Vector3i MR_neg_MR_Vector3b(const MR_Vector3b *a);
 
MRC_API MR_Vector3i MR_add_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API MR_Vector3i MR_sub_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API MR_Vector3i MR_mul_bool_MR_Vector3b(bool a, const MR_Vector3b *b);
 
MRC_API MR_Vector3i MR_mul_MR_Vector3b_bool(const MR_Vector3b *b, bool a);
 
MRC_API MR_Vector3i MR_div_MR_Vector3b_bool(MR_Vector3b b, bool a);
 
MRC_API MR_Vector3b *MR_add_assign_MR_Vector3b(MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API MR_Vector3b *MR_sub_assign_MR_Vector3b(MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API MR_Vector3b *MR_mul_assign_MR_Vector3b_bool(MR_Vector3b *a, bool b);
 
MRC_API MR_Vector3b *MR_div_assign_MR_Vector3b_bool(MR_Vector3b *a, bool b);
 
MRC_API const int32_t *MR_Vector3i_Get_elements(void);
 
MRC_API MR_Vector3i MR_Vector3i_DefaultConstruct(void);
 
MRC_API MR_Vector3i *MR_Vector3i_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector3i MR_Vector3i_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector3i MR_Vector3i_Construct_3(int32_t x, int32_t y, int32_t z);
 
// Here `T == U` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
//   when generating the bindings, and looks out of place there.
MRC_API MR_Vector3i MR_Vector3i_Construct_float(const MR_Vector3f *v);
 
MRC_API MR_Vector3i MR_Vector3i_diagonal(int32_t a);
 
MRC_API MR_Vector3i MR_Vector3i_plusX(void);
 
MRC_API MR_Vector3i MR_Vector3i_plusY(void);
 
MRC_API MR_Vector3i MR_Vector3i_plusZ(void);
 
MRC_API MR_Vector3i MR_Vector3i_minusX(void);
 
MRC_API MR_Vector3i MR_Vector3i_minusY(void);
 
MRC_API MR_Vector3i MR_Vector3i_minusZ(void);
 
MRC_API const int32_t *MR_Vector3i_index_const(const MR_Vector3i *_this, int32_t e);
 
MRC_API int32_t *MR_Vector3i_index(MR_Vector3i *_this, int32_t e);
 
MRC_API int32_t MR_Vector3i_lengthSq(const MR_Vector3i *_this);
 
MRC_API double MR_Vector3i_length(const MR_Vector3i *_this);
 
MRC_API MR_Vector3i MR_Vector3i_furthestBasisVector(const MR_Vector3i *_this);
 
MRC_API bool MR_equal_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API bool MR_not_equal_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *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_Vector3i *MR_pos_MR_Vector3i(const MR_Vector3i *a);
 
MRC_API MR_Vector3i MR_neg_MR_Vector3i(const MR_Vector3i *a);
 
MRC_API MR_Vector3i MR_add_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API MR_Vector3i MR_sub_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API MR_Vector3i MR_mul_int32_t_MR_Vector3i(int32_t a, const MR_Vector3i *b);
 
MRC_API MR_Vector3i MR_mul_MR_Vector3i_int32_t(const MR_Vector3i *b, int32_t a);
 
MRC_API MR_Vector3i MR_div_MR_Vector3i_int32_t(MR_Vector3i b, int32_t a);
 
MRC_API MR_Vector3i *MR_add_assign_MR_Vector3i(MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API MR_Vector3i *MR_sub_assign_MR_Vector3i(MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API MR_Vector3i *MR_mul_assign_MR_Vector3i_int32_t(MR_Vector3i *a, int32_t b);
 
MRC_API MR_Vector3i *MR_div_assign_MR_Vector3i_int32_t(MR_Vector3i *a, int32_t b);
 
MRC_API const int32_t *MR_Vector3i64_Get_elements(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_DefaultConstruct(void);
 
MRC_API MR_Vector3i64 *MR_Vector3i64_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector3i64 MR_Vector3i64_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector3i64 MR_Vector3i64_Construct_3(MR_int64_t x, MR_int64_t y, MR_int64_t z);
 
MRC_API MR_Vector3i64 MR_Vector3i64_diagonal(MR_int64_t a);
 
MRC_API MR_Vector3i64 MR_Vector3i64_plusX(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_plusY(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_plusZ(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_minusX(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_minusY(void);
 
MRC_API MR_Vector3i64 MR_Vector3i64_minusZ(void);
 
MRC_API const MR_int64_t *MR_Vector3i64_index_const(const MR_Vector3i64 *_this, int32_t e);
 
MRC_API MR_int64_t *MR_Vector3i64_index(MR_Vector3i64 *_this, int32_t e);
 
MRC_API MR_int64_t MR_Vector3i64_lengthSq(const MR_Vector3i64 *_this);
 
MRC_API double MR_Vector3i64_length(const MR_Vector3i64 *_this);
 
MRC_API MR_Vector3i64 MR_Vector3i64_furthestBasisVector(const MR_Vector3i64 *_this);
 
MRC_API bool MR_equal_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
MRC_API bool MR_not_equal_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *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_Vector3i64 *MR_pos_MR_Vector3i64(const MR_Vector3i64 *a);
 
MRC_API MR_Vector3i64 MR_neg_MR_Vector3i64(const MR_Vector3i64 *a);
 
MRC_API MR_Vector3i64 MR_add_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
MRC_API MR_Vector3i64 MR_sub_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
MRC_API MR_Vector3i64 MR_mul_int64_t_MR_Vector3i64(MR_int64_t a, const MR_Vector3i64 *b);
 
MRC_API MR_Vector3i64 MR_mul_MR_Vector3i64_int64_t(const MR_Vector3i64 *b, MR_int64_t a);
 
MRC_API MR_Vector3i64 MR_div_MR_Vector3i64_int64_t(MR_Vector3i64 b, MR_int64_t a);
 
MRC_API MR_Vector3i64 *MR_add_assign_MR_Vector3i64(MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
MRC_API MR_Vector3i64 *MR_sub_assign_MR_Vector3i64(MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
MRC_API MR_Vector3i64 *MR_mul_assign_MR_Vector3i64_int64_t(MR_Vector3i64 *a, MR_int64_t b);
 
MRC_API MR_Vector3i64 *MR_div_assign_MR_Vector3i64_int64_t(MR_Vector3i64 *a, MR_int64_t b);
 
MRC_API const int32_t *MR_Vector3f_Get_elements(void);
 
MRC_API MR_Vector3f MR_Vector3f_DefaultConstruct(void);
 
MRC_API MR_Vector3f *MR_Vector3f_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector3f MR_Vector3f_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector3f MR_Vector3f_Construct_3(float x, float y, float z);
 
// Here `T == U` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
//   when generating the bindings, and looks out of place there.
MRC_API MR_Vector3f MR_Vector3f_Construct_double(const MR_Vector3d *v);
 
// Here `T == U` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
//   when generating the bindings, and looks out of place there.
MRC_API MR_Vector3f MR_Vector3f_Construct_int32_t(const MR_Vector3i *v);
 
MRC_API MR_Vector3f MR_Vector3f_diagonal(float a);
 
MRC_API MR_Vector3f MR_Vector3f_plusX(void);
 
MRC_API MR_Vector3f MR_Vector3f_plusY(void);
 
MRC_API MR_Vector3f MR_Vector3f_plusZ(void);
 
MRC_API MR_Vector3f MR_Vector3f_minusX(void);
 
MRC_API MR_Vector3f MR_Vector3f_minusY(void);
 
MRC_API MR_Vector3f MR_Vector3f_minusZ(void);
 
MRC_API const float *MR_Vector3f_index_const(const MR_Vector3f *_this, int32_t e);
 
MRC_API float *MR_Vector3f_index(MR_Vector3f *_this, int32_t e);
 
MRC_API float MR_Vector3f_lengthSq(const MR_Vector3f *_this);
 
MRC_API float MR_Vector3f_length(const MR_Vector3f *_this);
 
MRC_API MR_Vector3f MR_Vector3f_normalized(const MR_Vector3f *_this);
 
MRC_API MR_Vector3f MR_Vector3f_furthestBasisVector(const MR_Vector3f *_this);
 
MRC_API MR_std_pair_MR_Vector3f_MR_Vector3f *MR_Vector3f_perpendicular(const MR_Vector3f *_this);
 
MRC_API MR_Vector3f MR_Vector3f_transformed(const MR_Vector3f *_this, const MR_AffineXf3f *xf);
 
MRC_API void MR_Vector3f_unsignZeroValues(MR_Vector3f *_this);
 
MRC_API bool MR_Vector3f_isFinite(const MR_Vector3f *_this);
 
MRC_API bool MR_equal_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API bool MR_not_equal_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *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_Vector3f *MR_pos_MR_Vector3f(const MR_Vector3f *a);
 
MRC_API MR_Vector3f MR_neg_MR_Vector3f(const MR_Vector3f *a);
 
MRC_API MR_Vector3f MR_add_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API MR_Vector3f MR_sub_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API MR_Vector3f MR_mul_float_MR_Vector3f(float a, const MR_Vector3f *b);
 
MRC_API MR_Vector3f MR_mul_MR_Vector3f_float(const MR_Vector3f *b, float a);
 
MRC_API MR_Vector3f MR_div_MR_Vector3f_float(MR_Vector3f b, float a);
 
MRC_API MR_Vector3f *MR_add_assign_MR_Vector3f(MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API MR_Vector3f *MR_sub_assign_MR_Vector3f(MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API MR_Vector3f *MR_mul_assign_MR_Vector3f_float(MR_Vector3f *a, float b);
 
MRC_API MR_Vector3f *MR_div_assign_MR_Vector3f_float(MR_Vector3f *a, float b);
 
MRC_API const int32_t *MR_Vector3d_Get_elements(void);
 
MRC_API MR_Vector3d MR_Vector3d_DefaultConstruct(void);
 
MRC_API MR_Vector3d *MR_Vector3d_DefaultConstructArray(size_t num_elems);
 
MRC_API MR_Vector3d MR_Vector3d_Construct_1(const MR_NoInit *_1);
 
MRC_API MR_Vector3d MR_Vector3d_Construct_3(double x, double y, double z);
 
// Here `T == U` doesn't seem to cause any issues in the C++ code, but we're still disabling it because it somehow gets emitted
//   when generating the bindings, and looks out of place there.
MRC_API MR_Vector3d MR_Vector3d_Construct_float(const MR_Vector3f *v);
 
MRC_API MR_Vector3d MR_Vector3d_diagonal(double a);
 
MRC_API MR_Vector3d MR_Vector3d_plusX(void);
 
MRC_API MR_Vector3d MR_Vector3d_plusY(void);
 
MRC_API MR_Vector3d MR_Vector3d_plusZ(void);
 
MRC_API MR_Vector3d MR_Vector3d_minusX(void);
 
MRC_API MR_Vector3d MR_Vector3d_minusY(void);
 
MRC_API MR_Vector3d MR_Vector3d_minusZ(void);
 
MRC_API const double *MR_Vector3d_index_const(const MR_Vector3d *_this, int32_t e);
 
MRC_API double *MR_Vector3d_index(MR_Vector3d *_this, int32_t e);
 
MRC_API double MR_Vector3d_lengthSq(const MR_Vector3d *_this);
 
MRC_API double MR_Vector3d_length(const MR_Vector3d *_this);
 
MRC_API MR_Vector3d MR_Vector3d_normalized(const MR_Vector3d *_this);
 
MRC_API MR_Vector3d MR_Vector3d_furthestBasisVector(const MR_Vector3d *_this);
 
MRC_API MR_std_pair_MR_Vector3d_MR_Vector3d *MR_Vector3d_perpendicular(const MR_Vector3d *_this);
 
MRC_API MR_Vector3d MR_Vector3d_transformed(const MR_Vector3d *_this, const MR_AffineXf3d *xf);
 
MRC_API void MR_Vector3d_unsignZeroValues(MR_Vector3d *_this);
 
MRC_API bool MR_Vector3d_isFinite(const MR_Vector3d *_this);
 
MRC_API bool MR_equal_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API bool MR_not_equal_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *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_Vector3d *MR_pos_MR_Vector3d(const MR_Vector3d *a);
 
MRC_API MR_Vector3d MR_neg_MR_Vector3d(const MR_Vector3d *a);
 
MRC_API MR_Vector3d MR_add_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API MR_Vector3d MR_sub_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API MR_Vector3d MR_mul_double_MR_Vector3d(double a, const MR_Vector3d *b);
 
MRC_API MR_Vector3d MR_mul_MR_Vector3d_double(const MR_Vector3d *b, double a);
 
MRC_API MR_Vector3d MR_div_MR_Vector3d_double(MR_Vector3d b, double a);
 
MRC_API MR_Vector3d *MR_add_assign_MR_Vector3d(MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API MR_Vector3d *MR_sub_assign_MR_Vector3d(MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API MR_Vector3d *MR_mul_assign_MR_Vector3d_double(MR_Vector3d *a, double b);
 
MRC_API MR_Vector3d *MR_div_assign_MR_Vector3d_double(MR_Vector3d *a, double b);
 
MRC_API float MR_dot_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);
 
MRC_API double MR_dot_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);
 
MRC_API int32_t MR_dot_bool_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *b);
 
MRC_API int32_t MR_dot_int32_t_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);
 
MRC_API MR_int64_t MR_dot_int64_t_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *b);
 
#ifdef __cplusplus
} // extern "C"
#endif