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>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_NoInit MR_NoInit; // Defined in `#include <MRCMesh/MRMeshFwd.h>`.
typedef struct MR_SimpleVolumeMinMax MR_SimpleVolumeMinMax; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
typedef struct MR_SimpleVolumeMinMaxU16 MR_SimpleVolumeMinMaxU16; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
typedef struct MR_VdbVolume MR_VdbVolume; // Defined in `#include <MRCVoxels/MRVoxelsVolume.h>`.
 
 
typedef struct MR_Box1i
{
    int32_t min;
    int32_t 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_uint16_t MR_Box_uint16_t;
 
MRC_API const int32_t *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 int32_t *min, const int32_t *max);
 
MRC_API MR_Box1i MR_Box1i_Construct_1(const MR_NoInit *_1);
 
MRC_API const int32_t *MR_Box1i_index_const(const MR_Box1i *_this, int32_t e);
 
MRC_API int32_t *MR_Box1i_index(MR_Box1i *_this, int32_t e);
 
MRC_API MR_Box1i MR_Box1i_fromMinAndSize(const int32_t *min, const int32_t *size);
 
MRC_API bool MR_Box1i_valid(const MR_Box1i *_this);
 
MRC_API int32_t MR_Box1i_center(const MR_Box1i *_this);
 
MRC_API int32_t MR_Box1i_corner(const MR_Box1i *_this, const bool *c);
 
MRC_API bool MR_Box1i_getMinBoxCorner(const int32_t *n);
 
MRC_API bool MR_Box1i_getMaxBoxCorner(const int32_t *n);
 
MRC_API int32_t MR_Box1i_size(const MR_Box1i *_this);
 
MRC_API int32_t MR_Box1i_diagonal(const MR_Box1i *_this);
 
MRC_API int32_t MR_Box1i_volume(const MR_Box1i *_this);
 
MRC_API void MR_Box1i_include_int32_t(MR_Box1i *_this, const int32_t *pt);
 
MRC_API void MR_Box1i_include_MR_Box1i(MR_Box1i *_this, const MR_Box1i *b);
 
MRC_API bool MR_Box1i_contains_int32_t(const MR_Box1i *_this, const int32_t *pt);
 
MRC_API bool MR_Box1i_contains_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *otherbox);
 
MRC_API int32_t MR_Box1i_getBoxClosestPointTo(const MR_Box1i *_this, const int32_t *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 int32_t MR_Box1i_getDistanceSq_MR_Box1i(const MR_Box1i *_this, const MR_Box1i *b);
 
MRC_API int32_t MR_Box1i_getDistanceSq_int32_t(const MR_Box1i *_this, const int32_t *pt);
 
MRC_API int32_t MR_Box1i_getProjection(const MR_Box1i *_this, const int32_t *pt);
 
MRC_API MR_Box1i MR_Box1i_expanded(const MR_Box1i *_this, const int32_t *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 const int32_t *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(const MR_Box1i64 *_this, int32_t e);
 
MRC_API MR_int64_t *MR_Box1i64_index(MR_Box1i64 *_this, int32_t 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 const int32_t *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 const MR_SimpleVolumeMinMax *MR_Box1f_StaticDowncastTo_MR_SimpleVolumeMinMax(const MR_Box1f *object);
 
MRC_API MR_SimpleVolumeMinMax *MR_Box1f_MutableStaticDowncastTo_MR_SimpleVolumeMinMax(MR_Box1f *object);
 
MRC_API const MR_VdbVolume *MR_Box1f_StaticDowncastTo_MR_VdbVolume(const MR_Box1f *object);
 
MRC_API MR_VdbVolume *MR_Box1f_MutableStaticDowncastTo_MR_VdbVolume(MR_Box1f *object);
 
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 MR_Box1f MR_Box1f_Construct_float(const MR_Box1f *a);
 
MRC_API const float *MR_Box1f_index_const(const MR_Box1f *_this, int32_t e);
 
MRC_API float *MR_Box1f_index(MR_Box1f *_this, int32_t 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 const int32_t *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(const MR_Box1d *_this, int32_t e);
 
MRC_API double *MR_Box1d_index(MR_Box1d *_this, int32_t 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 const int32_t *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(const MR_Box2i *_this, int32_t e);
 
MRC_API MR_Vector2i *MR_Box2i_index(MR_Box2i *_this, int32_t 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 int32_t MR_Box2i_diagonal(const MR_Box2i *_this);
 
MRC_API int32_t 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 int32_t MR_Box2i_getDistanceSq_MR_Box2i(const MR_Box2i *_this, const MR_Box2i *b);
 
MRC_API int32_t 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 const int32_t *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(const MR_Box2i64 *_this, int32_t e);
 
MRC_API MR_Vector2i64 *MR_Box2i64_index(MR_Box2i64 *_this, int32_t 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 const int32_t *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 MR_Box2f MR_Box2f_Construct_MR_Vector2f(const MR_Box2f *a);
 
MRC_API const MR_Vector2f *MR_Box2f_index_const(const MR_Box2f *_this, int32_t e);
 
MRC_API MR_Vector2f *MR_Box2f_index(MR_Box2f *_this, int32_t 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 const int32_t *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(const MR_Box2d *_this, int32_t e);
 
MRC_API MR_Vector2d *MR_Box2d_index(MR_Box2d *_this, int32_t 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 const int32_t *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 MR_Box3i MR_Box3i_Construct_MR_Vector3i(const MR_Box3i *a);
 
MRC_API const MR_Vector3i *MR_Box3i_index_const(const MR_Box3i *_this, int32_t e);
 
MRC_API MR_Vector3i *MR_Box3i_index(MR_Box3i *_this, int32_t 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 int32_t MR_Box3i_diagonal(const MR_Box3i *_this);
 
MRC_API int32_t 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 int32_t MR_Box3i_getDistanceSq_MR_Box3i(const MR_Box3i *_this, const MR_Box3i *b);
 
MRC_API int32_t 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 const int32_t *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(const MR_Box3i64 *_this, int32_t e);
 
MRC_API MR_Vector3i64 *MR_Box3i64_index(MR_Box3i64 *_this, int32_t 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 const int32_t *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 MR_Box3f MR_Box3f_Construct_MR_Vector3f(const MR_Box3f *a);
 
MRC_API const MR_Vector3f *MR_Box3f_index_const(const MR_Box3f *_this, int32_t e);
 
MRC_API MR_Vector3f *MR_Box3f_index(MR_Box3f *_this, int32_t 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 const int32_t *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 MR_Box3d MR_Box3d_Construct_MR_Vector3d(const MR_Box3d *a);
 
MRC_API const MR_Vector3d *MR_Box3d_index_const(const MR_Box3d *_this, int32_t e);
 
MRC_API MR_Vector3d *MR_Box3d_index(MR_Box3d *_this, int32_t 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 const int32_t *MR_Box_uint16_t_Get_elements(void);
 
MRC_API const uint16_t *MR_Box_uint16_t_Get_min(const MR_Box_uint16_t *_this);
 
MRC_API void MR_Box_uint16_t_Set_min(MR_Box_uint16_t *_this, uint16_t value);
 
MRC_API uint16_t *MR_Box_uint16_t_GetMutable_min(MR_Box_uint16_t *_this);
 
MRC_API const uint16_t *MR_Box_uint16_t_Get_max(const MR_Box_uint16_t *_this);
 
MRC_API void MR_Box_uint16_t_Set_max(MR_Box_uint16_t *_this, uint16_t value);
 
MRC_API uint16_t *MR_Box_uint16_t_GetMutable_max(MR_Box_uint16_t *_this);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_DefaultConstruct(void);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_DefaultConstructArray(size_t num_elems);
 
MRC_API const MR_Box_uint16_t *MR_Box_uint16_t_OffsetPtr(const MR_Box_uint16_t *ptr, ptrdiff_t i);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_OffsetMutablePtr(MR_Box_uint16_t *ptr, ptrdiff_t i);
 
MRC_API const MR_SimpleVolumeMinMaxU16 *MR_Box_uint16_t_StaticDowncastTo_MR_SimpleVolumeMinMaxU16(const MR_Box_uint16_t *object);
 
MRC_API MR_SimpleVolumeMinMaxU16 *MR_Box_uint16_t_MutableStaticDowncastTo_MR_SimpleVolumeMinMaxU16(MR_Box_uint16_t *object);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_ConstructFromAnother(const MR_Box_uint16_t *_other);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_Construct_2(const uint16_t *min, const uint16_t *max);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_Construct_1(const MR_NoInit *_1);
 
MRC_API void MR_Box_uint16_t_Destroy(const MR_Box_uint16_t *_this);
 
MRC_API void MR_Box_uint16_t_DestroyArray(const MR_Box_uint16_t *_this);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_AssignFromAnother(MR_Box_uint16_t *_this, const MR_Box_uint16_t *_other);
 
MRC_API const uint16_t *MR_Box_uint16_t_index_const(const MR_Box_uint16_t *_this, int32_t e);
 
MRC_API uint16_t *MR_Box_uint16_t_index(MR_Box_uint16_t *_this, int32_t e);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_fromMinAndSize(const uint16_t *min, const uint16_t *size);
 
MRC_API bool MR_Box_uint16_t_valid(const MR_Box_uint16_t *_this);
 
MRC_API uint16_t MR_Box_uint16_t_center(const MR_Box_uint16_t *_this);
 
MRC_API uint16_t MR_Box_uint16_t_corner(const MR_Box_uint16_t *_this, const bool *c);
 
MRC_API bool MR_Box_uint16_t_getMinBoxCorner(const uint16_t *n);
 
MRC_API bool MR_Box_uint16_t_getMaxBoxCorner(const uint16_t *n);
 
MRC_API uint16_t MR_Box_uint16_t_size(const MR_Box_uint16_t *_this);
 
MRC_API uint16_t MR_Box_uint16_t_diagonal(const MR_Box_uint16_t *_this);
 
MRC_API uint16_t MR_Box_uint16_t_volume(const MR_Box_uint16_t *_this);
 
MRC_API void MR_Box_uint16_t_include_uint16_t(MR_Box_uint16_t *_this, const uint16_t *pt);
 
MRC_API void MR_Box_uint16_t_include_MR_Box_uint16_t(MR_Box_uint16_t *_this, const MR_Box_uint16_t *b);
 
MRC_API bool MR_Box_uint16_t_contains_uint16_t(const MR_Box_uint16_t *_this, const uint16_t *pt);
 
MRC_API bool MR_Box_uint16_t_contains_MR_Box_uint16_t(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *otherbox);
 
MRC_API uint16_t MR_Box_uint16_t_getBoxClosestPointTo(const MR_Box_uint16_t *_this, const uint16_t *pt);
 
MRC_API bool MR_Box_uint16_t_intersects(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *b);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_intersection(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *b);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_intersect(MR_Box_uint16_t *_this, const MR_Box_uint16_t *b);
 
MRC_API uint16_t MR_Box_uint16_t_getDistanceSq_MR_Box_uint16_t(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *b);
 
MRC_API uint16_t MR_Box_uint16_t_getDistanceSq_uint16_t(const MR_Box_uint16_t *_this, const uint16_t *pt);
 
MRC_API uint16_t MR_Box_uint16_t_getProjection(const MR_Box_uint16_t *_this, const uint16_t *pt);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_expanded(const MR_Box_uint16_t *_this, const uint16_t *expansion);
 
MRC_API MR_Box_uint16_t *MR_Box_uint16_t_insignificantlyExpanded(const MR_Box_uint16_t *_this);
 
MRC_API bool MR_equal_MR_Box_uint16_t(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *a);
 
MRC_API bool MR_not_equal_MR_Box_uint16_t(const MR_Box_uint16_t *_this, const MR_Box_uint16_t *a);
 
#ifdef __cplusplus
} // extern "C"
#endif