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>
 
#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_istream MR_std_istream; // Defined in `#include <MRCMisc/iostream.h>`.
typedef struct MR_std_ostream MR_std_ostream; // Defined in `#include <MRCMisc/iostream.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_Vector3i64
{
    MR_int64_t x;
    MR_int64_t y;
    MR_int64_t z;
} MR_Vector3i64;

typedef struct MR_Vector3_unsigned_char MR_Vector3_unsigned_char;

typedef struct MR_Vector3f
{
    float x;
    float y;
    float z;
} MR_Vector3f;

typedef struct MR_Vector3d
{
    double x;
    double y;
    double z;
} MR_Vector3d;

typedef struct MR_Vector3i
{
    int x;
    int y;
    int z;
} MR_Vector3i;

MRC_API const int *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 const bool *MR_Vector3b_index(const MR_Vector3b *_this, int e);

MRC_API bool *MR_Vector3b_index_mut(MR_Vector3b *_this, int 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 MR_std_ostream *MR_print_MR_Vector3b(MR_std_ostream *s, const MR_Vector3b *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3b(MR_std_istream *s, MR_Vector3b *vec);

MRC_API const int *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 MR_Vector3i64 *_this, int e);

MRC_API MR_int64_t *MR_Vector3i64_index_mut(MR_Vector3i64 *_this, int 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 MR_std_ostream *MR_print_MR_Vector3i64(MR_std_ostream *s, const MR_Vector3i64 *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3i64(MR_std_istream *s, MR_Vector3i64 *vec);

MRC_API const int *MR_Vector3_unsigned_char_Get_elements(void);

MRC_API const unsigned char *MR_Vector3_unsigned_char_Get_x(const MR_Vector3_unsigned_char *_this);

MRC_API void MR_Vector3_unsigned_char_Set_x(MR_Vector3_unsigned_char *_this, unsigned char value);

MRC_API unsigned char *MR_Vector3_unsigned_char_GetMutable_x(MR_Vector3_unsigned_char *_this);

MRC_API const unsigned char *MR_Vector3_unsigned_char_Get_y(const MR_Vector3_unsigned_char *_this);

MRC_API void MR_Vector3_unsigned_char_Set_y(MR_Vector3_unsigned_char *_this, unsigned char value);

MRC_API unsigned char *MR_Vector3_unsigned_char_GetMutable_y(MR_Vector3_unsigned_char *_this);

MRC_API const unsigned char *MR_Vector3_unsigned_char_Get_z(const MR_Vector3_unsigned_char *_this);

MRC_API void MR_Vector3_unsigned_char_Set_z(MR_Vector3_unsigned_char *_this, unsigned char value);

MRC_API unsigned char *MR_Vector3_unsigned_char_GetMutable_z(MR_Vector3_unsigned_char *_this);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_DefaultConstruct(void);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_DefaultConstructArray(size_t num_elems);

MRC_API const MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_OffsetPtr(const MR_Vector3_unsigned_char *ptr, ptrdiff_t i);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_OffsetMutablePtr(MR_Vector3_unsigned_char *ptr, ptrdiff_t i);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_ConstructFromAnother(const MR_Vector3_unsigned_char *_other);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_Construct_1(const MR_NoInit *_1);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_Construct_3(unsigned char x, unsigned char y, unsigned char z);

MRC_API void MR_Vector3_unsigned_char_Destroy(const MR_Vector3_unsigned_char *_this);

MRC_API void MR_Vector3_unsigned_char_DestroyArray(const MR_Vector3_unsigned_char *_this);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_AssignFromAnother(MR_Vector3_unsigned_char *_this, const MR_Vector3_unsigned_char *_other);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_diagonal(unsigned char a);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_plusX(void);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_plusY(void);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_plusZ(void);

MRC_API const unsigned char *MR_Vector3_unsigned_char_index(const MR_Vector3_unsigned_char *_this, int e);

MRC_API unsigned char *MR_Vector3_unsigned_char_index_mut(MR_Vector3_unsigned_char *_this, int e);

MRC_API unsigned char MR_Vector3_unsigned_char_lengthSq(const MR_Vector3_unsigned_char *_this);

MRC_API double MR_Vector3_unsigned_char_length(const MR_Vector3_unsigned_char *_this);

MRC_API MR_Vector3_unsigned_char *MR_Vector3_unsigned_char_furthestBasisVector(const MR_Vector3_unsigned_char *_this);

MRC_API bool MR_equal_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API bool MR_not_equal_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a, const MR_Vector3_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_Vector3_unsigned_char *MR_pos_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a);

MRC_API MR_Vector3i MR_neg_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a);

MRC_API MR_Vector3i MR_add_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API MR_Vector3i MR_sub_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API MR_Vector3i MR_mul_unsigned_char_MR_Vector3_unsigned_char(unsigned char a, const MR_Vector3_unsigned_char *b);

MRC_API MR_Vector3i MR_mul_MR_Vector3_unsigned_char_unsigned_char(const MR_Vector3_unsigned_char *b, unsigned char a);

MRC_API MR_Vector3i MR_div_MR_Vector3_unsigned_char_unsigned_char(const MR_Vector3_unsigned_char *b, unsigned char a);

MRC_API MR_Vector3_unsigned_char *MR_add_assign_MR_Vector3_unsigned_char(MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API MR_Vector3_unsigned_char *MR_sub_assign_MR_Vector3_unsigned_char(MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API MR_Vector3_unsigned_char *MR_mul_assign_MR_Vector3_unsigned_char_unsigned_char(MR_Vector3_unsigned_char *a, unsigned char b);

MRC_API MR_Vector3_unsigned_char *MR_div_assign_MR_Vector3_unsigned_char_unsigned_char(MR_Vector3_unsigned_char *a, unsigned char b);

MRC_API MR_std_ostream *MR_print_MR_Vector3_unsigned_char(MR_std_ostream *s, const MR_Vector3_unsigned_char *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3_unsigned_char(MR_std_istream *s, MR_Vector3_unsigned_char *vec);

MRC_API float MR_distanceSq_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API double MR_distanceSq_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API int MR_distanceSq_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);

MRC_API float MR_distance_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API double MR_distance_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API MR_Vector3f MR_cross_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API MR_Vector3d MR_cross_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API MR_Vector3i MR_cross_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *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 int MR_dot_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);

MRC_API int MR_dot_bool_MR_Vector3b(const MR_Vector3b *a, const MR_Vector3b *b);

MRC_API MR_int64_t MR_dot_int64_t_MR_Vector3i64(const MR_Vector3i64 *a, const MR_Vector3i64 *b);

MRC_API int MR_dot_unsigned_char_MR_Vector3_unsigned_char(const MR_Vector3_unsigned_char *a, const MR_Vector3_unsigned_char *b);

MRC_API float MR_sqr_float_MR_Vector3f(const MR_Vector3f *a);

MRC_API double MR_sqr_double_MR_Vector3d(const MR_Vector3d *a);

MRC_API int MR_sqr_int_MR_Vector3i(const MR_Vector3i *a);

MRC_API float MR_mixed_float(const MR_Vector3f *a, const MR_Vector3f *b, const MR_Vector3f *c);

MRC_API double MR_mixed_double(const MR_Vector3d *a, const MR_Vector3d *b, const MR_Vector3d *c);

MRC_API int MR_mixed_int(const MR_Vector3i *a, const MR_Vector3i *b, const MR_Vector3i *c);

MRC_API MR_Vector3f MR_mult_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API MR_Vector3d MR_mult_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API MR_Vector3i MR_mult_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);

MRC_API MR_Vector3f MR_div_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API MR_Vector3d MR_div_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API MR_Vector3i MR_div_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);

MRC_API float MR_angle_float_MR_Vector3f(const MR_Vector3f *a, const MR_Vector3f *b);

MRC_API double MR_angle_double_MR_Vector3d(const MR_Vector3d *a, const MR_Vector3d *b);

MRC_API int MR_angle_int_MR_Vector3i(const MR_Vector3i *a, const MR_Vector3i *b);

MRC_API MR_Vector3f MR_unitVector3_float(float azimuth, float altitude);

MRC_API MR_Vector3d MR_unitVector3_double(double azimuth, double altitude);

MRC_API const int *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_int(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 MR_Vector3f *_this, int e);

MRC_API float *MR_Vector3f_index_mut(MR_Vector3f *_this, int 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 MR_std_ostream *MR_print_MR_Vector3f(MR_std_ostream *s, const MR_Vector3f *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3f(MR_std_istream *s, MR_Vector3f *vec);

MRC_API const int *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 MR_Vector3d *_this, int e);

MRC_API double *MR_Vector3d_index_mut(MR_Vector3d *_this, int 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 MR_std_ostream *MR_print_MR_Vector3d(MR_std_ostream *s, const MR_Vector3d *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3d(MR_std_istream *s, MR_Vector3d *vec);

MRC_API const int *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(int x, int y, int 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(int 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 int *MR_Vector3i_index(const MR_Vector3i *_this, int e);

MRC_API int *MR_Vector3i_index_mut(MR_Vector3i *_this, int e);

MRC_API int 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_int_MR_Vector3i(int a, const MR_Vector3i *b);

MRC_API MR_Vector3i MR_mul_MR_Vector3i_int(const MR_Vector3i *b, int a);

MRC_API MR_Vector3i MR_div_MR_Vector3i_int(MR_Vector3i b, int 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_int(MR_Vector3i *a, int b);

MRC_API MR_Vector3i *MR_div_assign_MR_Vector3i_int(MR_Vector3i *a, int b);

MRC_API MR_std_ostream *MR_print_MR_Vector3i(MR_std_ostream *s, const MR_Vector3i *vec);

MRC_API MR_std_istream *MR_input_MR_Vector3i(MR_std_istream *s, MR_Vector3i *vec);
 
#ifdef __cplusplus
} // extern "C"
#endif