MRBox.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRVector2.h>
#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_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_Box1i
{
    int min;
    int max;
} MR_Box1i;

typedef struct MR_Box1i64
{
    MR_int64_t min;
    MR_int64_t max;
} MR_Box1i64;

typedef struct MR_Box1f
{
    float min;
    float max;
} MR_Box1f;

typedef struct MR_Box1d
{
    double min;
    double max;
} MR_Box1d;

typedef struct MR_Box2i
{
    MR_Vector2i min;
    MR_Vector2i max;
} MR_Box2i;

typedef struct MR_Box2i64
{
    MR_Vector2i64 min;
    MR_Vector2i64 max;
} MR_Box2i64;

typedef struct MR_Box2f
{
    MR_Vector2f min;
    MR_Vector2f max;
} MR_Box2f;

typedef struct MR_Box2d
{
    MR_Vector2d min;
    MR_Vector2d max;
} MR_Box2d;

typedef struct MR_Box3i
{
    MR_Vector3i min;
    MR_Vector3i max;
} MR_Box3i;

typedef struct MR_Box3i64
{
    MR_Vector3i64 min;
    MR_Vector3i64 max;
} MR_Box3i64;

typedef struct MR_Box3f
{
    MR_Vector3f min;
    MR_Vector3f max;
} MR_Box3f;

typedef struct MR_Box3d
{
    MR_Vector3d min;
    MR_Vector3d max;
} MR_Box3d;

typedef struct MR_Box_unsigned_short MR_Box_unsigned_short;

MRC_API const int *MR_Box1i_Get_elements(void);

MRC_API MR_Box1i MR_Box1i_DefaultConstruct(void);

MRC_API MR_Box1i *MR_Box1i_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box1i MR_Box1i_Construct_2(const int *min, const int *max);

MRC_API MR_Box1i MR_Box1i_Construct_1(const MR_NoInit *_1);

MRC_API const int *MR_Box1i_index(const MR_Box1i *_this, int e);

MRC_API int *MR_Box1i_index_mut(MR_Box1i *_this, int e);

MRC_API MR_Box1i MR_Box1i_fromMinAndSize(const int *min, const int *size);

MRC_API bool MR_Box1i_valid(const MR_Box1i *_this);

MRC_API int MR_Box1i_center(const MR_Box1i *_this);

MRC_API int MR_Box1i_corner(const MR_Box1i *_this, const bool *c);

MRC_API bool MR_Box1i_getMinBoxCorner(const int *n);

MRC_API bool MR_Box1i_getMaxBoxCorner(const int *n);

MRC_API int MR_Box1i_size(const MR_Box1i *_this);

MRC_API int MR_Box1i_diagonal(const MR_Box1i *_this);

MRC_API int MR_Box1i_volume(const MR_Box1i *_this);

MRC_API void MR_Box1i_include_int(MR_Box1i *_this, const int *pt);

MRC_API void MR_Box1i_include_MR_Box1i(MR_Box1i *_this, const MR_Box1i *b);

MRC_API bool MR_Box1i_contains_int(const MR_Box1i *_this, const int *pt);

MRC_API bool MR_Box1i_contains_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *otherbox);

MRC_API int MR_Box1i_getBoxClosestPointTo(const MR_Box1i *_this, const int *pt);

MRC_API bool MR_Box1i_intersects(const MR_Box1i *_this, const MR_Box1i *b);

MRC_API MR_Box1i MR_Box1i_intersection(const MR_Box1i *_this, const MR_Box1i *b);

MRC_API MR_Box1i *MR_Box1i_intersect(MR_Box1i *_this, const MR_Box1i *b);

MRC_API int MR_Box1i_getDistanceSq_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *b);

MRC_API int MR_Box1i_getDistanceSq_int(const MR_Box1i *_this, const int *pt);

MRC_API int MR_Box1i_getProjection(const MR_Box1i *_this, const int *pt);

MRC_API MR_Box1i MR_Box1i_expanded(const MR_Box1i *_this, const int *expansion);

MRC_API MR_Box1i MR_Box1i_insignificantlyExpanded(const MR_Box1i *_this);

MRC_API bool MR_equal_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *a);

MRC_API bool MR_not_equal_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *a);

MRC_API MR_std_ostream *MR_print_MR_Box1i(MR_std_ostream *s, const MR_Box1i *box);

MRC_API MR_std_istream *MR_input_MR_Box1i(MR_std_istream *s, MR_Box1i *box);

MRC_API const int *MR_Box1i64_Get_elements(void);

MRC_API MR_Box1i64 MR_Box1i64_DefaultConstruct(void);

MRC_API MR_Box1i64 *MR_Box1i64_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box1i64 MR_Box1i64_Construct_2(const MR_int64_t *min, const MR_int64_t *max);

MRC_API MR_Box1i64 MR_Box1i64_Construct_1(const MR_NoInit *_1);

MRC_API const MR_int64_t *MR_Box1i64_index(const MR_Box1i64 *_this, int e);

MRC_API MR_int64_t *MR_Box1i64_index_mut(MR_Box1i64 *_this, int e);

MRC_API MR_Box1i64 MR_Box1i64_fromMinAndSize(const MR_int64_t *min, const MR_int64_t *size);

MRC_API bool MR_Box1i64_valid(const MR_Box1i64 *_this);

MRC_API MR_int64_t MR_Box1i64_center(const MR_Box1i64 *_this);

MRC_API MR_int64_t MR_Box1i64_corner(const MR_Box1i64 *_this, const bool *c);

MRC_API bool MR_Box1i64_getMinBoxCorner(const MR_int64_t *n);

MRC_API bool MR_Box1i64_getMaxBoxCorner(const MR_int64_t *n);

MRC_API MR_int64_t MR_Box1i64_size(const MR_Box1i64 *_this);

MRC_API MR_int64_t MR_Box1i64_diagonal(const MR_Box1i64 *_this);

MRC_API MR_int64_t MR_Box1i64_volume(const MR_Box1i64 *_this);

MRC_API void MR_Box1i64_include_int64_t(MR_Box1i64 *_this, const MR_int64_t *pt);

MRC_API void MR_Box1i64_include_MR_Box1i64(MR_Box1i64 *_this, const MR_Box1i64 *b);

MRC_API bool MR_Box1i64_contains_int64_t(const MR_Box1i64 *_this, const MR_int64_t *pt);

MRC_API bool MR_Box1i64_contains_MR_Box1i64(const MR_Box1i64 *_this, const MR_Box1i64 *otherbox);

MRC_API MR_int64_t MR_Box1i64_getBoxClosestPointTo(const MR_Box1i64 *_this, const MR_int64_t *pt);

MRC_API bool MR_Box1i64_intersects(const MR_Box1i64 *_this, const MR_Box1i64 *b);

MRC_API MR_Box1i64 MR_Box1i64_intersection(const MR_Box1i64 *_this, const MR_Box1i64 *b);

MRC_API MR_Box1i64 *MR_Box1i64_intersect(MR_Box1i64 *_this, const MR_Box1i64 *b);

MRC_API MR_int64_t MR_Box1i64_getDistanceSq_MR_Box1i64(const MR_Box1i64 *_this, const MR_Box1i64 *b);

MRC_API MR_int64_t MR_Box1i64_getDistanceSq_int64_t(const MR_Box1i64 *_this, const MR_int64_t *pt);

MRC_API MR_int64_t MR_Box1i64_getProjection(const MR_Box1i64 *_this, const MR_int64_t *pt);

MRC_API MR_Box1i64 MR_Box1i64_expanded(const MR_Box1i64 *_this, const MR_int64_t *expansion);

MRC_API MR_Box1i64 MR_Box1i64_insignificantlyExpanded(const MR_Box1i64 *_this);

MRC_API bool MR_equal_MR_Box1i64(const MR_Box1i64 *_this, const MR_Box1i64 *a);

MRC_API bool MR_not_equal_MR_Box1i64(const MR_Box1i64 *_this, const MR_Box1i64 *a);

MRC_API MR_std_ostream *MR_print_MR_Box1i64(MR_std_ostream *s, const MR_Box1i64 *box);

MRC_API MR_std_istream *MR_input_MR_Box1i64(MR_std_istream *s, MR_Box1i64 *box);

MRC_API const int *MR_Box1f_Get_elements(void);

MRC_API MR_Box1f MR_Box1f_DefaultConstruct(void);

MRC_API MR_Box1f *MR_Box1f_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box1f MR_Box1f_Construct_2(const float *min, const float *max);

MRC_API MR_Box1f MR_Box1f_Construct_1(const MR_NoInit *_1);

MRC_API const float *MR_Box1f_index(const MR_Box1f *_this, int e);

MRC_API float *MR_Box1f_index_mut(MR_Box1f *_this, int e);

MRC_API MR_Box1f MR_Box1f_fromMinAndSize(const float *min, const float *size);

MRC_API bool MR_Box1f_valid(const MR_Box1f *_this);

MRC_API float MR_Box1f_center(const MR_Box1f *_this);

MRC_API float MR_Box1f_corner(const MR_Box1f *_this, const bool *c);

MRC_API bool MR_Box1f_getMinBoxCorner(const float *n);

MRC_API bool MR_Box1f_getMaxBoxCorner(const float *n);

MRC_API float MR_Box1f_size(const MR_Box1f *_this);

MRC_API float MR_Box1f_diagonal(const MR_Box1f *_this);

MRC_API float MR_Box1f_volume(const MR_Box1f *_this);

MRC_API void MR_Box1f_include_float(MR_Box1f *_this, const float *pt);

MRC_API void MR_Box1f_include_MR_Box1f(MR_Box1f *_this, const MR_Box1f *b);

MRC_API bool MR_Box1f_contains_float(const MR_Box1f *_this, const float *pt);

MRC_API bool MR_Box1f_contains_MR_Box1f(const MR_Box1f *_this, const MR_Box1f *otherbox);

MRC_API float MR_Box1f_getBoxClosestPointTo(const MR_Box1f *_this, const float *pt);

MRC_API bool MR_Box1f_intersects(const MR_Box1f *_this, const MR_Box1f *b);

MRC_API MR_Box1f MR_Box1f_intersection(const MR_Box1f *_this, const MR_Box1f *b);

MRC_API MR_Box1f *MR_Box1f_intersect(MR_Box1f *_this, const MR_Box1f *b);

MRC_API float MR_Box1f_getDistanceSq_MR_Box1f(const MR_Box1f *_this, const MR_Box1f *b);

MRC_API float MR_Box1f_getDistanceSq_float(const MR_Box1f *_this, const float *pt);

MRC_API float MR_Box1f_getProjection(const MR_Box1f *_this, const float *pt);

MRC_API MR_Box1f MR_Box1f_expanded(const MR_Box1f *_this, const float *expansion);

MRC_API MR_Box1f MR_Box1f_insignificantlyExpanded(const MR_Box1f *_this);

MRC_API bool MR_equal_MR_Box1f(const MR_Box1f *_this, const MR_Box1f *a);

MRC_API bool MR_not_equal_MR_Box1f(const MR_Box1f *_this, const MR_Box1f *a);

MRC_API MR_std_ostream *MR_print_MR_Box1f(MR_std_ostream *s, const MR_Box1f *box);

MRC_API MR_std_istream *MR_input_MR_Box1f(MR_std_istream *s, MR_Box1f *box);

MRC_API const int *MR_Box1d_Get_elements(void);

MRC_API MR_Box1d MR_Box1d_DefaultConstruct(void);

MRC_API MR_Box1d *MR_Box1d_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box1d MR_Box1d_Construct_2(const double *min, const double *max);

MRC_API MR_Box1d MR_Box1d_Construct_1(const MR_NoInit *_1);

MRC_API const double *MR_Box1d_index(const MR_Box1d *_this, int e);

MRC_API double *MR_Box1d_index_mut(MR_Box1d *_this, int e);

MRC_API MR_Box1d MR_Box1d_fromMinAndSize(const double *min, const double *size);

MRC_API bool MR_Box1d_valid(const MR_Box1d *_this);

MRC_API double MR_Box1d_center(const MR_Box1d *_this);

MRC_API double MR_Box1d_corner(const MR_Box1d *_this, const bool *c);

MRC_API bool MR_Box1d_getMinBoxCorner(const double *n);

MRC_API bool MR_Box1d_getMaxBoxCorner(const double *n);

MRC_API double MR_Box1d_size(const MR_Box1d *_this);

MRC_API double MR_Box1d_diagonal(const MR_Box1d *_this);

MRC_API double MR_Box1d_volume(const MR_Box1d *_this);

MRC_API void MR_Box1d_include_double(MR_Box1d *_this, const double *pt);

MRC_API void MR_Box1d_include_MR_Box1d(MR_Box1d *_this, const MR_Box1d *b);

MRC_API bool MR_Box1d_contains_double(const MR_Box1d *_this, const double *pt);

MRC_API bool MR_Box1d_contains_MR_Box1d(const MR_Box1d *_this, const MR_Box1d *otherbox);

MRC_API double MR_Box1d_getBoxClosestPointTo(const MR_Box1d *_this, const double *pt);

MRC_API bool MR_Box1d_intersects(const MR_Box1d *_this, const MR_Box1d *b);

MRC_API MR_Box1d MR_Box1d_intersection(const MR_Box1d *_this, const MR_Box1d *b);

MRC_API MR_Box1d *MR_Box1d_intersect(MR_Box1d *_this, const MR_Box1d *b);

MRC_API double MR_Box1d_getDistanceSq_MR_Box1d(const MR_Box1d *_this, const MR_Box1d *b);

MRC_API double MR_Box1d_getDistanceSq_double(const MR_Box1d *_this, const double *pt);

MRC_API double MR_Box1d_getProjection(const MR_Box1d *_this, const double *pt);

MRC_API MR_Box1d MR_Box1d_expanded(const MR_Box1d *_this, const double *expansion);

MRC_API MR_Box1d MR_Box1d_insignificantlyExpanded(const MR_Box1d *_this);

MRC_API bool MR_equal_MR_Box1d(const MR_Box1d *_this, const MR_Box1d *a);

MRC_API bool MR_not_equal_MR_Box1d(const MR_Box1d *_this, const MR_Box1d *a);

MRC_API MR_std_ostream *MR_print_MR_Box1d(MR_std_ostream *s, const MR_Box1d *box);

MRC_API MR_std_istream *MR_input_MR_Box1d(MR_std_istream *s, MR_Box1d *box);

MRC_API const int *MR_Box2i_Get_elements(void);

MRC_API MR_Box2i MR_Box2i_DefaultConstruct(void);

MRC_API MR_Box2i *MR_Box2i_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box2i MR_Box2i_Construct_2(const MR_Vector2i *min, const MR_Vector2i *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box2i MR_Box2i_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector2i *MR_Box2i_index(const MR_Box2i *_this, int e);

MRC_API MR_Vector2i *MR_Box2i_index_mut(MR_Box2i *_this, int e);

MRC_API MR_Box2i MR_Box2i_fromMinAndSize(const MR_Vector2i *min, const MR_Vector2i *size);

MRC_API bool MR_Box2i_valid(const MR_Box2i *_this);

MRC_API MR_Vector2i MR_Box2i_center(const MR_Box2i *_this);

MRC_API MR_Vector2i MR_Box2i_corner(const MR_Box2i *_this, const MR_Vector2b *c);

MRC_API MR_Vector2b MR_Box2i_getMinBoxCorner(const MR_Vector2i *n);

MRC_API MR_Vector2b MR_Box2i_getMaxBoxCorner(const MR_Vector2i *n);

MRC_API MR_Vector2i MR_Box2i_size(const MR_Box2i *_this);

MRC_API int MR_Box2i_diagonal(const MR_Box2i *_this);

MRC_API int MR_Box2i_volume(const MR_Box2i *_this);

MRC_API void MR_Box2i_include_MR_Vector2i(MR_Box2i *_this, const MR_Vector2i *pt);

MRC_API void MR_Box2i_include_MR_Box2i(MR_Box2i *_this, const MR_Box2i *b);

MRC_API bool MR_Box2i_contains_MR_Vector2i(const MR_Box2i *_this, const MR_Vector2i *pt);

MRC_API bool MR_Box2i_contains_MR_Box2i(const MR_Box2i *_this, const MR_Box2i *otherbox);

MRC_API MR_Vector2i MR_Box2i_getBoxClosestPointTo(const MR_Box2i *_this, const MR_Vector2i *pt);

MRC_API bool MR_Box2i_intersects(const MR_Box2i *_this, const MR_Box2i *b);

MRC_API MR_Box2i MR_Box2i_intersection(const MR_Box2i *_this, const MR_Box2i *b);

MRC_API MR_Box2i *MR_Box2i_intersect(MR_Box2i *_this, const MR_Box2i *b);

MRC_API int MR_Box2i_getDistanceSq_MR_Box2i(const MR_Box2i *_this, const MR_Box2i *b);

MRC_API int MR_Box2i_getDistanceSq_MR_Vector2i(const MR_Box2i *_this, const MR_Vector2i *pt);

MRC_API MR_Vector2i MR_Box2i_getProjection(const MR_Box2i *_this, const MR_Vector2i *pt);

MRC_API MR_Box2i MR_Box2i_expanded(const MR_Box2i *_this, const MR_Vector2i *expansion);

MRC_API MR_Box2i MR_Box2i_insignificantlyExpanded(const MR_Box2i *_this);

MRC_API bool MR_equal_MR_Box2i(const MR_Box2i *_this, const MR_Box2i *a);

MRC_API bool MR_not_equal_MR_Box2i(const MR_Box2i *_this, const MR_Box2i *a);

MRC_API MR_std_ostream *MR_print_MR_Box2i(MR_std_ostream *s, const MR_Box2i *box);

MRC_API MR_std_istream *MR_input_MR_Box2i(MR_std_istream *s, MR_Box2i *box);

MRC_API const int *MR_Box2i64_Get_elements(void);

MRC_API MR_Box2i64 MR_Box2i64_DefaultConstruct(void);

MRC_API MR_Box2i64 *MR_Box2i64_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box2i64 MR_Box2i64_Construct_2(const MR_Vector2i64 *min, const MR_Vector2i64 *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box2i64 MR_Box2i64_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector2i64 *MR_Box2i64_index(const MR_Box2i64 *_this, int e);

MRC_API MR_Vector2i64 *MR_Box2i64_index_mut(MR_Box2i64 *_this, int e);

MRC_API MR_Box2i64 MR_Box2i64_fromMinAndSize(const MR_Vector2i64 *min, const MR_Vector2i64 *size);

MRC_API bool MR_Box2i64_valid(const MR_Box2i64 *_this);

MRC_API MR_Vector2i64 MR_Box2i64_center(const MR_Box2i64 *_this);

MRC_API MR_Vector2i64 MR_Box2i64_corner(const MR_Box2i64 *_this, const MR_Vector2b *c);

MRC_API MR_Vector2b MR_Box2i64_getMinBoxCorner(const MR_Vector2i64 *n);

MRC_API MR_Vector2b MR_Box2i64_getMaxBoxCorner(const MR_Vector2i64 *n);

MRC_API MR_Vector2i64 MR_Box2i64_size(const MR_Box2i64 *_this);

MRC_API MR_int64_t MR_Box2i64_diagonal(const MR_Box2i64 *_this);

MRC_API MR_int64_t MR_Box2i64_volume(const MR_Box2i64 *_this);

MRC_API void MR_Box2i64_include_MR_Vector2i64(MR_Box2i64 *_this, const MR_Vector2i64 *pt);

MRC_API void MR_Box2i64_include_MR_Box2i64(MR_Box2i64 *_this, const MR_Box2i64 *b);

MRC_API bool MR_Box2i64_contains_MR_Vector2i64(const MR_Box2i64 *_this, const MR_Vector2i64 *pt);

MRC_API bool MR_Box2i64_contains_MR_Box2i64(const MR_Box2i64 *_this, const MR_Box2i64 *otherbox);

MRC_API MR_Vector2i64 MR_Box2i64_getBoxClosestPointTo(const MR_Box2i64 *_this, const MR_Vector2i64 *pt);

MRC_API bool MR_Box2i64_intersects(const MR_Box2i64 *_this, const MR_Box2i64 *b);

MRC_API MR_Box2i64 MR_Box2i64_intersection(const MR_Box2i64 *_this, const MR_Box2i64 *b);

MRC_API MR_Box2i64 *MR_Box2i64_intersect(MR_Box2i64 *_this, const MR_Box2i64 *b);

MRC_API MR_int64_t MR_Box2i64_getDistanceSq_MR_Box2i64(const MR_Box2i64 *_this, const MR_Box2i64 *b);

MRC_API MR_int64_t MR_Box2i64_getDistanceSq_MR_Vector2i64(const MR_Box2i64 *_this, const MR_Vector2i64 *pt);

MRC_API MR_Vector2i64 MR_Box2i64_getProjection(const MR_Box2i64 *_this, const MR_Vector2i64 *pt);

MRC_API MR_Box2i64 MR_Box2i64_expanded(const MR_Box2i64 *_this, const MR_Vector2i64 *expansion);

MRC_API MR_Box2i64 MR_Box2i64_insignificantlyExpanded(const MR_Box2i64 *_this);

MRC_API bool MR_equal_MR_Box2i64(const MR_Box2i64 *_this, const MR_Box2i64 *a);

MRC_API bool MR_not_equal_MR_Box2i64(const MR_Box2i64 *_this, const MR_Box2i64 *a);

MRC_API MR_std_ostream *MR_print_MR_Box2i64(MR_std_ostream *s, const MR_Box2i64 *box);

MRC_API MR_std_istream *MR_input_MR_Box2i64(MR_std_istream *s, MR_Box2i64 *box);

MRC_API const int *MR_Box2f_Get_elements(void);

MRC_API MR_Box2f MR_Box2f_DefaultConstruct(void);

MRC_API MR_Box2f *MR_Box2f_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box2f MR_Box2f_Construct_2(const MR_Vector2f *min, const MR_Vector2f *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box2f MR_Box2f_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector2f *MR_Box2f_index(const MR_Box2f *_this, int e);

MRC_API MR_Vector2f *MR_Box2f_index_mut(MR_Box2f *_this, int e);

MRC_API MR_Box2f MR_Box2f_fromMinAndSize(const MR_Vector2f *min, const MR_Vector2f *size);

MRC_API bool MR_Box2f_valid(const MR_Box2f *_this);

MRC_API MR_Vector2f MR_Box2f_center(const MR_Box2f *_this);

MRC_API MR_Vector2f MR_Box2f_corner(const MR_Box2f *_this, const MR_Vector2b *c);

MRC_API MR_Vector2b MR_Box2f_getMinBoxCorner(const MR_Vector2f *n);

MRC_API MR_Vector2b MR_Box2f_getMaxBoxCorner(const MR_Vector2f *n);

MRC_API MR_Vector2f MR_Box2f_size(const MR_Box2f *_this);

MRC_API float MR_Box2f_diagonal(const MR_Box2f *_this);

MRC_API float MR_Box2f_volume(const MR_Box2f *_this);

MRC_API void MR_Box2f_include_MR_Vector2f(MR_Box2f *_this, const MR_Vector2f *pt);

MRC_API void MR_Box2f_include_MR_Box2f(MR_Box2f *_this, const MR_Box2f *b);

MRC_API bool MR_Box2f_contains_MR_Vector2f(const MR_Box2f *_this, const MR_Vector2f *pt);

MRC_API bool MR_Box2f_contains_MR_Box2f(const MR_Box2f *_this, const MR_Box2f *otherbox);

MRC_API MR_Vector2f MR_Box2f_getBoxClosestPointTo(const MR_Box2f *_this, const MR_Vector2f *pt);

MRC_API bool MR_Box2f_intersects(const MR_Box2f *_this, const MR_Box2f *b);

MRC_API MR_Box2f MR_Box2f_intersection(const MR_Box2f *_this, const MR_Box2f *b);

MRC_API MR_Box2f *MR_Box2f_intersect(MR_Box2f *_this, const MR_Box2f *b);

MRC_API float MR_Box2f_getDistanceSq_MR_Box2f(const MR_Box2f *_this, const MR_Box2f *b);

MRC_API float MR_Box2f_getDistanceSq_MR_Vector2f(const MR_Box2f *_this, const MR_Vector2f *pt);

MRC_API MR_Vector2f MR_Box2f_getProjection(const MR_Box2f *_this, const MR_Vector2f *pt);

MRC_API MR_Box2f MR_Box2f_expanded(const MR_Box2f *_this, const MR_Vector2f *expansion);

MRC_API MR_Box2f MR_Box2f_insignificantlyExpanded(const MR_Box2f *_this);

MRC_API bool MR_equal_MR_Box2f(const MR_Box2f *_this, const MR_Box2f *a);

MRC_API bool MR_not_equal_MR_Box2f(const MR_Box2f *_this, const MR_Box2f *a);

MRC_API MR_std_ostream *MR_print_MR_Box2f(MR_std_ostream *s, const MR_Box2f *box);

MRC_API MR_std_istream *MR_input_MR_Box2f(MR_std_istream *s, MR_Box2f *box);

MRC_API const int *MR_Box2d_Get_elements(void);

MRC_API MR_Box2d MR_Box2d_DefaultConstruct(void);

MRC_API MR_Box2d *MR_Box2d_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box2d MR_Box2d_Construct_2(const MR_Vector2d *min, const MR_Vector2d *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box2d MR_Box2d_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector2d *MR_Box2d_index(const MR_Box2d *_this, int e);

MRC_API MR_Vector2d *MR_Box2d_index_mut(MR_Box2d *_this, int e);

MRC_API MR_Box2d MR_Box2d_fromMinAndSize(const MR_Vector2d *min, const MR_Vector2d *size);

MRC_API bool MR_Box2d_valid(const MR_Box2d *_this);

MRC_API MR_Vector2d MR_Box2d_center(const MR_Box2d *_this);

MRC_API MR_Vector2d MR_Box2d_corner(const MR_Box2d *_this, const MR_Vector2b *c);

MRC_API MR_Vector2b MR_Box2d_getMinBoxCorner(const MR_Vector2d *n);

MRC_API MR_Vector2b MR_Box2d_getMaxBoxCorner(const MR_Vector2d *n);

MRC_API MR_Vector2d MR_Box2d_size(const MR_Box2d *_this);

MRC_API double MR_Box2d_diagonal(const MR_Box2d *_this);

MRC_API double MR_Box2d_volume(const MR_Box2d *_this);

MRC_API void MR_Box2d_include_MR_Vector2d(MR_Box2d *_this, const MR_Vector2d *pt);

MRC_API void MR_Box2d_include_MR_Box2d(MR_Box2d *_this, const MR_Box2d *b);

MRC_API bool MR_Box2d_contains_MR_Vector2d(const MR_Box2d *_this, const MR_Vector2d *pt);

MRC_API bool MR_Box2d_contains_MR_Box2d(const MR_Box2d *_this, const MR_Box2d *otherbox);

MRC_API MR_Vector2d MR_Box2d_getBoxClosestPointTo(const MR_Box2d *_this, const MR_Vector2d *pt);

MRC_API bool MR_Box2d_intersects(const MR_Box2d *_this, const MR_Box2d *b);

MRC_API MR_Box2d MR_Box2d_intersection(const MR_Box2d *_this, const MR_Box2d *b);

MRC_API MR_Box2d *MR_Box2d_intersect(MR_Box2d *_this, const MR_Box2d *b);

MRC_API double MR_Box2d_getDistanceSq_MR_Box2d(const MR_Box2d *_this, const MR_Box2d *b);

MRC_API double MR_Box2d_getDistanceSq_MR_Vector2d(const MR_Box2d *_this, const MR_Vector2d *pt);

MRC_API MR_Vector2d MR_Box2d_getProjection(const MR_Box2d *_this, const MR_Vector2d *pt);

MRC_API MR_Box2d MR_Box2d_expanded(const MR_Box2d *_this, const MR_Vector2d *expansion);

MRC_API MR_Box2d MR_Box2d_insignificantlyExpanded(const MR_Box2d *_this);

MRC_API bool MR_equal_MR_Box2d(const MR_Box2d *_this, const MR_Box2d *a);

MRC_API bool MR_not_equal_MR_Box2d(const MR_Box2d *_this, const MR_Box2d *a);

MRC_API MR_std_ostream *MR_print_MR_Box2d(MR_std_ostream *s, const MR_Box2d *box);

MRC_API MR_std_istream *MR_input_MR_Box2d(MR_std_istream *s, MR_Box2d *box);

MRC_API const int *MR_Box3i_Get_elements(void);

MRC_API MR_Box3i MR_Box3i_DefaultConstruct(void);

MRC_API MR_Box3i *MR_Box3i_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box3i MR_Box3i_Construct_2(const MR_Vector3i *min, const MR_Vector3i *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box3i MR_Box3i_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector3i *MR_Box3i_index(const MR_Box3i *_this, int e);

MRC_API MR_Vector3i *MR_Box3i_index_mut(MR_Box3i *_this, int e);

MRC_API MR_Box3i MR_Box3i_fromMinAndSize(const MR_Vector3i *min, const MR_Vector3i *size);

MRC_API bool MR_Box3i_valid(const MR_Box3i *_this);

MRC_API MR_Vector3i MR_Box3i_center(const MR_Box3i *_this);

MRC_API MR_Vector3i MR_Box3i_corner(const MR_Box3i *_this, const MR_Vector3b *c);

MRC_API MR_Vector3b MR_Box3i_getMinBoxCorner(const MR_Vector3i *n);

MRC_API MR_Vector3b MR_Box3i_getMaxBoxCorner(const MR_Vector3i *n);

MRC_API MR_Vector3i MR_Box3i_size(const MR_Box3i *_this);

MRC_API int MR_Box3i_diagonal(const MR_Box3i *_this);

MRC_API int MR_Box3i_volume(const MR_Box3i *_this);

MRC_API void MR_Box3i_include_MR_Vector3i(MR_Box3i *_this, const MR_Vector3i *pt);

MRC_API void MR_Box3i_include_MR_Box3i(MR_Box3i *_this, const MR_Box3i *b);

MRC_API bool MR_Box3i_contains_MR_Vector3i(const MR_Box3i *_this, const MR_Vector3i *pt);

MRC_API bool MR_Box3i_contains_MR_Box3i(const MR_Box3i *_this, const MR_Box3i *otherbox);

MRC_API MR_Vector3i MR_Box3i_getBoxClosestPointTo(const MR_Box3i *_this, const MR_Vector3i *pt);

MRC_API bool MR_Box3i_intersects(const MR_Box3i *_this, const MR_Box3i *b);

MRC_API MR_Box3i MR_Box3i_intersection(const MR_Box3i *_this, const MR_Box3i *b);

MRC_API MR_Box3i *MR_Box3i_intersect(MR_Box3i *_this, const MR_Box3i *b);

MRC_API int MR_Box3i_getDistanceSq_MR_Box3i(const MR_Box3i *_this, const MR_Box3i *b);

MRC_API int MR_Box3i_getDistanceSq_MR_Vector3i(const MR_Box3i *_this, const MR_Vector3i *pt);

MRC_API MR_Vector3i MR_Box3i_getProjection(const MR_Box3i *_this, const MR_Vector3i *pt);

MRC_API MR_Box3i MR_Box3i_expanded(const MR_Box3i *_this, const MR_Vector3i *expansion);

MRC_API MR_Box3i MR_Box3i_insignificantlyExpanded(const MR_Box3i *_this);

MRC_API bool MR_equal_MR_Box3i(const MR_Box3i *_this, const MR_Box3i *a);

MRC_API bool MR_not_equal_MR_Box3i(const MR_Box3i *_this, const MR_Box3i *a);

MRC_API MR_std_ostream *MR_print_MR_Box3i(MR_std_ostream *s, const MR_Box3i *box);

MRC_API MR_std_istream *MR_input_MR_Box3i(MR_std_istream *s, MR_Box3i *box);

MRC_API const int *MR_Box3i64_Get_elements(void);

MRC_API MR_Box3i64 MR_Box3i64_DefaultConstruct(void);

MRC_API MR_Box3i64 *MR_Box3i64_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box3i64 MR_Box3i64_Construct_2(const MR_Vector3i64 *min, const MR_Vector3i64 *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box3i64 MR_Box3i64_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector3i64 *MR_Box3i64_index(const MR_Box3i64 *_this, int e);

MRC_API MR_Vector3i64 *MR_Box3i64_index_mut(MR_Box3i64 *_this, int e);

MRC_API MR_Box3i64 MR_Box3i64_fromMinAndSize(const MR_Vector3i64 *min, const MR_Vector3i64 *size);

MRC_API bool MR_Box3i64_valid(const MR_Box3i64 *_this);

MRC_API MR_Vector3i64 MR_Box3i64_center(const MR_Box3i64 *_this);

MRC_API MR_Vector3i64 MR_Box3i64_corner(const MR_Box3i64 *_this, const MR_Vector3b *c);

MRC_API MR_Vector3b MR_Box3i64_getMinBoxCorner(const MR_Vector3i64 *n);

MRC_API MR_Vector3b MR_Box3i64_getMaxBoxCorner(const MR_Vector3i64 *n);

MRC_API MR_Vector3i64 MR_Box3i64_size(const MR_Box3i64 *_this);

MRC_API MR_int64_t MR_Box3i64_diagonal(const MR_Box3i64 *_this);

MRC_API MR_int64_t MR_Box3i64_volume(const MR_Box3i64 *_this);

MRC_API void MR_Box3i64_include_MR_Vector3i64(MR_Box3i64 *_this, const MR_Vector3i64 *pt);

MRC_API void MR_Box3i64_include_MR_Box3i64(MR_Box3i64 *_this, const MR_Box3i64 *b);

MRC_API bool MR_Box3i64_contains_MR_Vector3i64(const MR_Box3i64 *_this, const MR_Vector3i64 *pt);

MRC_API bool MR_Box3i64_contains_MR_Box3i64(const MR_Box3i64 *_this, const MR_Box3i64 *otherbox);

MRC_API MR_Vector3i64 MR_Box3i64_getBoxClosestPointTo(const MR_Box3i64 *_this, const MR_Vector3i64 *pt);

MRC_API bool MR_Box3i64_intersects(const MR_Box3i64 *_this, const MR_Box3i64 *b);

MRC_API MR_Box3i64 MR_Box3i64_intersection(const MR_Box3i64 *_this, const MR_Box3i64 *b);

MRC_API MR_Box3i64 *MR_Box3i64_intersect(MR_Box3i64 *_this, const MR_Box3i64 *b);

MRC_API MR_int64_t MR_Box3i64_getDistanceSq_MR_Box3i64(const MR_Box3i64 *_this, const MR_Box3i64 *b);

MRC_API MR_int64_t MR_Box3i64_getDistanceSq_MR_Vector3i64(const MR_Box3i64 *_this, const MR_Vector3i64 *pt);

MRC_API MR_Vector3i64 MR_Box3i64_getProjection(const MR_Box3i64 *_this, const MR_Vector3i64 *pt);

MRC_API MR_Box3i64 MR_Box3i64_expanded(const MR_Box3i64 *_this, const MR_Vector3i64 *expansion);

MRC_API MR_Box3i64 MR_Box3i64_insignificantlyExpanded(const MR_Box3i64 *_this);

MRC_API bool MR_equal_MR_Box3i64(const MR_Box3i64 *_this, const MR_Box3i64 *a);

MRC_API bool MR_not_equal_MR_Box3i64(const MR_Box3i64 *_this, const MR_Box3i64 *a);

MRC_API MR_std_ostream *MR_print_MR_Box3i64(MR_std_ostream *s, const MR_Box3i64 *box);

MRC_API MR_std_istream *MR_input_MR_Box3i64(MR_std_istream *s, MR_Box3i64 *box);

MRC_API const int *MR_Box3f_Get_elements(void);

MRC_API MR_Box3f MR_Box3f_DefaultConstruct(void);

MRC_API MR_Box3f *MR_Box3f_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box3f MR_Box3f_Construct_2(const MR_Vector3f *min, const MR_Vector3f *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box3f MR_Box3f_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector3f *MR_Box3f_index(const MR_Box3f *_this, int e);

MRC_API MR_Vector3f *MR_Box3f_index_mut(MR_Box3f *_this, int e);

MRC_API MR_Box3f MR_Box3f_fromMinAndSize(const MR_Vector3f *min, const MR_Vector3f *size);

MRC_API bool MR_Box3f_valid(const MR_Box3f *_this);

MRC_API MR_Vector3f MR_Box3f_center(const MR_Box3f *_this);

MRC_API MR_Vector3f MR_Box3f_corner(const MR_Box3f *_this, const MR_Vector3b *c);

MRC_API MR_Vector3b MR_Box3f_getMinBoxCorner(const MR_Vector3f *n);

MRC_API MR_Vector3b MR_Box3f_getMaxBoxCorner(const MR_Vector3f *n);

MRC_API MR_Vector3f MR_Box3f_size(const MR_Box3f *_this);

MRC_API float MR_Box3f_diagonal(const MR_Box3f *_this);

MRC_API float MR_Box3f_volume(const MR_Box3f *_this);

MRC_API void MR_Box3f_include_MR_Vector3f(MR_Box3f *_this, const MR_Vector3f *pt);

MRC_API void MR_Box3f_include_MR_Box3f(MR_Box3f *_this, const MR_Box3f *b);

MRC_API bool MR_Box3f_contains_MR_Vector3f(const MR_Box3f *_this, const MR_Vector3f *pt);

MRC_API bool MR_Box3f_contains_MR_Box3f(const MR_Box3f *_this, const MR_Box3f *otherbox);

MRC_API MR_Vector3f MR_Box3f_getBoxClosestPointTo(const MR_Box3f *_this, const MR_Vector3f *pt);

MRC_API bool MR_Box3f_intersects(const MR_Box3f *_this, const MR_Box3f *b);

MRC_API MR_Box3f MR_Box3f_intersection(const MR_Box3f *_this, const MR_Box3f *b);

MRC_API MR_Box3f *MR_Box3f_intersect(MR_Box3f *_this, const MR_Box3f *b);

MRC_API float MR_Box3f_getDistanceSq_MR_Box3f(const MR_Box3f *_this, const MR_Box3f *b);

MRC_API float MR_Box3f_getDistanceSq_MR_Vector3f(const MR_Box3f *_this, const MR_Vector3f *pt);

MRC_API MR_Vector3f MR_Box3f_getProjection(const MR_Box3f *_this, const MR_Vector3f *pt);

MRC_API MR_Box3f MR_Box3f_expanded(const MR_Box3f *_this, const MR_Vector3f *expansion);

MRC_API MR_Box3f MR_Box3f_insignificantlyExpanded(const MR_Box3f *_this);

MRC_API bool MR_equal_MR_Box3f(const MR_Box3f *_this, const MR_Box3f *a);

MRC_API bool MR_not_equal_MR_Box3f(const MR_Box3f *_this, const MR_Box3f *a);

MRC_API MR_std_ostream *MR_print_MR_Box3f(MR_std_ostream *s, const MR_Box3f *box);

MRC_API MR_std_istream *MR_input_MR_Box3f(MR_std_istream *s, MR_Box3f *box);

MRC_API const int *MR_Box3d_Get_elements(void);

MRC_API MR_Box3d MR_Box3d_DefaultConstruct(void);

MRC_API MR_Box3d *MR_Box3d_DefaultConstructArray(size_t num_elems);

MRC_API MR_Box3d MR_Box3d_Construct_2(const MR_Vector3d *min, const MR_Vector3d *max);
 
// If the compiler supports `requires`, use that instead of `std::enable_if` here.
// Not (only) because it looks cooler, but because of a bug in our binding generator that makes it choke on it: https://github.com/MeshInspector/mrbind/issues/19
MRC_API MR_Box3d MR_Box3d_Construct_1(const MR_NoInit *_1);

MRC_API const MR_Vector3d *MR_Box3d_index(const MR_Box3d *_this, int e);

MRC_API MR_Vector3d *MR_Box3d_index_mut(MR_Box3d *_this, int e);

MRC_API MR_Box3d MR_Box3d_fromMinAndSize(const MR_Vector3d *min, const MR_Vector3d *size);

MRC_API bool MR_Box3d_valid(const MR_Box3d *_this);

MRC_API MR_Vector3d MR_Box3d_center(const MR_Box3d *_this);

MRC_API MR_Vector3d MR_Box3d_corner(const MR_Box3d *_this, const MR_Vector3b *c);

MRC_API MR_Vector3b MR_Box3d_getMinBoxCorner(const MR_Vector3d *n);

MRC_API MR_Vector3b MR_Box3d_getMaxBoxCorner(const MR_Vector3d *n);

MRC_API MR_Vector3d MR_Box3d_size(const MR_Box3d *_this);

MRC_API double MR_Box3d_diagonal(const MR_Box3d *_this);

MRC_API double MR_Box3d_volume(const MR_Box3d *_this);

MRC_API void MR_Box3d_include_MR_Vector3d(MR_Box3d *_this, const MR_Vector3d *pt);

MRC_API void MR_Box3d_include_MR_Box3d(MR_Box3d *_this, const MR_Box3d *b);

MRC_API bool MR_Box3d_contains_MR_Vector3d(const MR_Box3d *_this, const MR_Vector3d *pt);

MRC_API bool MR_Box3d_contains_MR_Box3d(const MR_Box3d *_this, const MR_Box3d *otherbox);

MRC_API MR_Vector3d MR_Box3d_getBoxClosestPointTo(const MR_Box3d *_this, const MR_Vector3d *pt);

MRC_API bool MR_Box3d_intersects(const MR_Box3d *_this, const MR_Box3d *b);

MRC_API MR_Box3d MR_Box3d_intersection(const MR_Box3d *_this, const MR_Box3d *b);

MRC_API MR_Box3d *MR_Box3d_intersect(MR_Box3d *_this, const MR_Box3d *b);

MRC_API double MR_Box3d_getDistanceSq_MR_Box3d(const MR_Box3d *_this, const MR_Box3d *b);

MRC_API double MR_Box3d_getDistanceSq_MR_Vector3d(const MR_Box3d *_this, const MR_Vector3d *pt);

MRC_API MR_Vector3d MR_Box3d_getProjection(const MR_Box3d *_this, const MR_Vector3d *pt);

MRC_API MR_Box3d MR_Box3d_expanded(const MR_Box3d *_this, const MR_Vector3d *expansion);

MRC_API MR_Box3d MR_Box3d_insignificantlyExpanded(const MR_Box3d *_this);

MRC_API bool MR_equal_MR_Box3d(const MR_Box3d *_this, const MR_Box3d *a);

MRC_API bool MR_not_equal_MR_Box3d(const MR_Box3d *_this, const MR_Box3d *a);

MRC_API MR_std_ostream *MR_print_MR_Box3d(MR_std_ostream *s, const MR_Box3d *box);

MRC_API MR_std_istream *MR_input_MR_Box3d(MR_std_istream *s, MR_Box3d *box);

MRC_API const int *MR_Box_unsigned_short_Get_elements(void);

MRC_API const unsigned short *MR_Box_unsigned_short_Get_min(const MR_Box_unsigned_short *_this);

MRC_API void MR_Box_unsigned_short_Set_min(MR_Box_unsigned_short *_this, unsigned short value);

MRC_API unsigned short *MR_Box_unsigned_short_GetMutable_min(MR_Box_unsigned_short *_this);

MRC_API const unsigned short *MR_Box_unsigned_short_Get_max(const MR_Box_unsigned_short *_this);

MRC_API void MR_Box_unsigned_short_Set_max(MR_Box_unsigned_short *_this, unsigned short value);

MRC_API unsigned short *MR_Box_unsigned_short_GetMutable_max(MR_Box_unsigned_short *_this);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_DefaultConstruct(void);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_DefaultConstructArray(size_t num_elems);

MRC_API const MR_Box_unsigned_short *MR_Box_unsigned_short_OffsetPtr(const MR_Box_unsigned_short *ptr, ptrdiff_t i);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_OffsetMutablePtr(MR_Box_unsigned_short *ptr, ptrdiff_t i);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_ConstructFromAnother(const MR_Box_unsigned_short *_other);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_Construct_2(const unsigned short *min, const unsigned short *max);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_Construct_1(const MR_NoInit *_1);

MRC_API void MR_Box_unsigned_short_Destroy(const MR_Box_unsigned_short *_this);

MRC_API void MR_Box_unsigned_short_DestroyArray(const MR_Box_unsigned_short *_this);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_AssignFromAnother(MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *_other);

MRC_API const unsigned short *MR_Box_unsigned_short_index(const MR_Box_unsigned_short *_this, int e);

MRC_API unsigned short *MR_Box_unsigned_short_index_mut(MR_Box_unsigned_short *_this, int e);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_fromMinAndSize(const unsigned short *min, const unsigned short *size);

MRC_API bool MR_Box_unsigned_short_valid(const MR_Box_unsigned_short *_this);

MRC_API unsigned short MR_Box_unsigned_short_center(const MR_Box_unsigned_short *_this);

MRC_API unsigned short MR_Box_unsigned_short_corner(const MR_Box_unsigned_short *_this, const bool *c);

MRC_API bool MR_Box_unsigned_short_getMinBoxCorner(const unsigned short *n);

MRC_API bool MR_Box_unsigned_short_getMaxBoxCorner(const unsigned short *n);

MRC_API unsigned short MR_Box_unsigned_short_size(const MR_Box_unsigned_short *_this);

MRC_API unsigned short MR_Box_unsigned_short_diagonal(const MR_Box_unsigned_short *_this);

MRC_API unsigned short MR_Box_unsigned_short_volume(const MR_Box_unsigned_short *_this);

MRC_API void MR_Box_unsigned_short_include_unsigned_short(MR_Box_unsigned_short *_this, const unsigned short *pt);

MRC_API void MR_Box_unsigned_short_include_MR_Box_unsigned_short(MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *b);

MRC_API bool MR_Box_unsigned_short_contains_unsigned_short(const MR_Box_unsigned_short *_this, const unsigned short *pt);

MRC_API bool MR_Box_unsigned_short_contains_MR_Box_unsigned_short(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *otherbox);

MRC_API unsigned short MR_Box_unsigned_short_getBoxClosestPointTo(const MR_Box_unsigned_short *_this, const unsigned short *pt);

MRC_API bool MR_Box_unsigned_short_intersects(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *b);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_intersection(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *b);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_intersect(MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *b);

MRC_API unsigned short MR_Box_unsigned_short_getDistanceSq_MR_Box_unsigned_short(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *b);

MRC_API unsigned short MR_Box_unsigned_short_getDistanceSq_unsigned_short(const MR_Box_unsigned_short *_this, const unsigned short *pt);

MRC_API unsigned short MR_Box_unsigned_short_getProjection(const MR_Box_unsigned_short *_this, const unsigned short *pt);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_expanded(const MR_Box_unsigned_short *_this, const unsigned short *expansion);

MRC_API MR_Box_unsigned_short *MR_Box_unsigned_short_insignificantlyExpanded(const MR_Box_unsigned_short *_this);

MRC_API bool MR_equal_MR_Box_unsigned_short(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *a);

MRC_API bool MR_not_equal_MR_Box_unsigned_short(const MR_Box_unsigned_short *_this, const MR_Box_unsigned_short *a);

MRC_API MR_std_ostream *MR_print_MR_Box_unsigned_short(MR_std_ostream *s, const MR_Box_unsigned_short *box);

MRC_API MR_std_istream *MR_input_MR_Box_unsigned_short(MR_std_istream *s, MR_Box_unsigned_short *box);
 
#ifdef __cplusplus
} // extern "C"
#endif