pub const MSDFGEN_CUBIC_SEARCH_STARTS: u32 = 4;
pub const MSDFGEN_CUBIC_SEARCH_STEPS: u32 = 4;
pub const MSDFGEN_VERSION: &'static [u8; 4usize] = b"1.6\0";
pub type std_size_t = ::std::os::raw::c_ulong;
pub type std_integral_constant_value_type<_Tp> = _Tp;
pub type std_integral_constant_type = u8;
pub type std_true_type = u8;
pub type std_false_type = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___and_ {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_is_empty {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_make_unsigned {
pub _address: u8,
}
pub type std_make_unsigned_type = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub union std_aligned_storage_type {
pub __data: *mut ::std::os::raw::c_uchar,
pub __align: std_aligned_storage_type__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_aligned_storage_type__bindgen_ty_1 {
pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_aligned_storage_type() {
assert_eq!(
::std::mem::size_of::<std_aligned_storage_type>(),
8usize,
concat!("Size of: ", stringify!(std_aligned_storage_type))
);
assert_eq!(
::std::mem::align_of::<std_aligned_storage_type>(),
8usize,
concat!("Alignment of ", stringify!(std_aligned_storage_type))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___detector {
pub _address: u8,
}
pub type std___detector_value_t = std_false_type;
pub type std___detector_type<_Default> = _Default;
pub type std___detected_or = std___detector;
pub type std___detected_or_t = std___detected_or;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_iterator {
pub _address: u8,
}
pub type std_iterator_iterator_category<_Category> = _Category;
pub type std_iterator_value_type<_Tp> = _Tp;
pub type std_iterator_difference_type<_Distance> = _Distance;
pub type std_iterator_pointer<_Pointer> = _Pointer;
pub type std_iterator_reference<_Reference> = _Reference;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___iterator_traits {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_iterator_traits {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___undefined {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___get_first_arg {
pub _address: u8,
}
pub type std___get_first_arg_type = std___undefined;
pub type std___get_first_arg_t = std___get_first_arg;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___replace_first_arg {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_pointer_traits {
pub _address: u8,
}
pub type std_pointer_traits___element_type = [u8; 0usize];
pub type std_pointer_traits___difference_type = [u8; 0usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_pointer_traits___rebind {
pub _address: u8,
}
pub type std_pointer_traits_pointer<_Ptr> = _Ptr;
pub type std_pointer_traits_element_type = std___detected_or_t;
pub type std_pointer_traits_difference_type = std___detected_or_t;
pub type std_pointer_traits_rebind = std_pointer_traits___rebind;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_reverse_iterator<_Iterator> {
pub current: _Iterator,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>,
}
pub type std_reverse_iterator___traits_type = std_iterator_traits;
pub type std_reverse_iterator_iterator_type<_Iterator> = _Iterator;
pub type std_reverse_iterator_difference_type = std_reverse_iterator___traits_type;
pub type std_reverse_iterator_pointer = std_reverse_iterator___traits_type;
pub type std_reverse_iterator_reference = std_reverse_iterator___traits_type;
pub type std___allocator_base = __gnu_cxx_new_allocator;
#[repr(C)]
#[derive(Debug)]
pub struct std_allocator {
pub _address: u8,
}
pub type std_allocator_size_type = std_size_t;
pub type std_allocator_difference_type = isize;
pub type std_allocator_pointer<_Tp> = *mut _Tp;
pub type std_allocator_const_pointer<_Tp> = *const _Tp;
pub type std_allocator_reference<_Tp> = *mut _Tp;
pub type std_allocator_const_reference<_Tp> = *const _Tp;
pub type std_allocator_value_type<_Tp> = _Tp;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_rebind {
pub _address: u8,
}
pub type std_allocator_rebind_other = std_allocator;
pub type std_allocator_propagate_on_container_move_assignment = std_true_type;
pub type std_allocator_is_always_equal = std_true_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___allocator_traits_base {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std___allocator_traits_base___rebind {
pub _address: u8,
}
pub type std___allocator_traits_base___pointer = [u8; 0usize];
pub type std___allocator_traits_base___c_pointer = [u8; 0usize];
pub type std___allocator_traits_base___v_pointer = [u8; 0usize];
pub type std___allocator_traits_base___cv_pointer = [u8; 0usize];
pub type std___allocator_traits_base___pocca = [u8; 0usize];
pub type std___allocator_traits_base___pocma = [u8; 0usize];
pub type std___allocator_traits_base___pocs = [u8; 0usize];
pub type std___allocator_traits_base___equal = [u8; 0usize];
#[test]
fn bindgen_test_layout_std___allocator_traits_base() {
assert_eq!(
::std::mem::size_of::<std___allocator_traits_base>(),
1usize,
concat!("Size of: ", stringify!(std___allocator_traits_base))
);
assert_eq!(
::std::mem::align_of::<std___allocator_traits_base>(),
1usize,
concat!("Alignment of ", stringify!(std___allocator_traits_base))
);
}
pub type std___alloc_rebind = std___allocator_traits_base;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits {
pub _address: u8,
}
pub type std_allocator_traits_allocator_type<_Alloc> = _Alloc;
pub type std_allocator_traits_value_type = [u8; 0usize];
pub type std_allocator_traits_pointer = std___detected_or_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits__Ptr {
pub _address: u8,
}
pub type std_allocator_traits__Ptr_type = [u8; 0usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits__Diff {
pub _address: u8,
}
pub type std_allocator_traits__Diff_type = std_pointer_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits__Size {
pub _address: u8,
}
pub type std_allocator_traits_const_pointer = [u8; 0usize];
pub type std_allocator_traits_void_pointer = std_allocator_traits__Ptr;
pub type std_allocator_traits_const_void_pointer = std_allocator_traits__Ptr;
pub type std_allocator_traits_difference_type = [u8; 0usize];
pub type std_allocator_traits_size_type = [u8; 0usize];
pub type std_allocator_traits_propagate_on_container_copy_assignment = std___detected_or_t;
pub type std_allocator_traits_propagate_on_container_move_assignment = std___detected_or_t;
pub type std_allocator_traits_propagate_on_container_swap = std___detected_or_t;
pub type std_allocator_traits_is_always_equal = std___detected_or_t;
pub type std_allocator_traits_rebind_alloc = std___alloc_rebind;
pub type std_allocator_traits_rebind_traits = std_allocator_traits;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_allocator_traits___construct_helper {
pub _address: u8,
}
pub type std_allocator_traits___construct_helper_type<_Alloc> = _Alloc;
pub type std_allocator_traits___has_construct = std_allocator_traits___construct_helper;
#[repr(C)]
pub struct std__Vector_base {
pub _M_impl: std__Vector_base__Vector_impl,
}
pub type std__Vector_base__Tp_alloc_type = [u8; 0usize];
pub type std__Vector_base_pointer = [u8; 0usize];
#[repr(C)]
pub struct std__Vector_base__Vector_impl {
pub _M_start: std__Vector_base_pointer,
pub _M_finish: std__Vector_base_pointer,
pub _M_end_of_storage: std__Vector_base_pointer,
}
pub type std__Vector_base_allocator_type<_Alloc> = _Alloc;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct std_vector {
pub _address: u8,
}
pub type std_vector__Base = std__Vector_base;
pub type std_vector__Tp_alloc_type = std_vector__Base;
pub type std_vector__Alloc_traits = __gnu_cxx___alloc_traits;
pub type std_vector_value_type<_Tp> = _Tp;
pub type std_vector_pointer = std_vector__Base;
pub type std_vector_const_pointer = std_vector__Alloc_traits;
pub type std_vector_reference = std_vector__Alloc_traits;
pub type std_vector_const_reference = std_vector__Alloc_traits;
pub type std_vector_iterator = __gnu_cxx___normal_iterator<std_vector_pointer>;
pub type std_vector_const_iterator = __gnu_cxx___normal_iterator<std_vector_const_pointer>;
pub type std_vector_const_reverse_iterator = std_reverse_iterator<std_vector_const_iterator>;
pub type std_vector_reverse_iterator = std_reverse_iterator<std_vector_iterator>;
pub type std_vector_size_type = std_size_t;
pub type std_vector_difference_type = isize;
pub type std_vector_allocator_type<_Alloc> = _Alloc;
#[repr(C)]
#[derive(Debug)]
pub struct std_vector__Temporary_value {
pub _M_this: *mut u8,
pub __buf: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __gnu_cxx___normal_iterator<_Iterator> {
pub _M_current: _Iterator,
pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>,
}
pub type __gnu_cxx___normal_iterator___traits_type = std_iterator_traits;
pub type __gnu_cxx___normal_iterator_iterator_type<_Iterator> = _Iterator;
pub type __gnu_cxx___normal_iterator_iterator_category = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_value_type = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_difference_type = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_reference = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_pointer = __gnu_cxx___normal_iterator___traits_type;
#[repr(C)]
#[derive(Debug)]
pub struct __gnu_cxx_new_allocator {
pub _address: u8,
}
pub type __gnu_cxx_new_allocator_size_type = std_size_t;
pub type __gnu_cxx_new_allocator_difference_type = isize;
pub type __gnu_cxx_new_allocator_pointer<_Tp> = *mut _Tp;
pub type __gnu_cxx_new_allocator_const_pointer<_Tp> = *const _Tp;
pub type __gnu_cxx_new_allocator_reference<_Tp> = *mut _Tp;
pub type __gnu_cxx_new_allocator_const_reference<_Tp> = *const _Tp;
pub type __gnu_cxx_new_allocator_value_type<_Tp> = _Tp;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __gnu_cxx_new_allocator_rebind {
pub _address: u8,
}
pub type __gnu_cxx_new_allocator_rebind_other = __gnu_cxx_new_allocator;
pub type __gnu_cxx_new_allocator_propagate_on_container_move_assignment = std_true_type;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __gnu_cxx___alloc_traits {
pub _address: u8,
}
pub type __gnu_cxx___alloc_traits_allocator_type<_Alloc> = _Alloc;
pub type __gnu_cxx___alloc_traits__Base_type = std_allocator_traits;
pub type __gnu_cxx___alloc_traits_value_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_pointer = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_const_pointer = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_size_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_difference_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_reference = *mut __gnu_cxx___alloc_traits_value_type;
pub type __gnu_cxx___alloc_traits_const_reference = *const __gnu_cxx___alloc_traits_value_type;
pub type __gnu_cxx___alloc_traits___is_custom_pointer = std___and_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __gnu_cxx___alloc_traits_rebind {
pub _address: u8,
}
pub type __gnu_cxx___alloc_traits_rebind_other = __gnu_cxx___alloc_traits__Base_type;
pub type size_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
#[doc = " A 2-dimensional euclidean vector with double precision."]
#[doc = " Implementation based on the Vector2 template from Artery Engine."]
#[doc = " @author Viktor Chlumsky"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct msdfgen_Vector2 {
pub x: f64,
pub y: f64,
}
#[test]
fn bindgen_test_layout_msdfgen_Vector2() {
assert_eq!(
::std::mem::size_of::<msdfgen_Vector2>(),
16usize,
concat!("Size of: ", stringify!(msdfgen_Vector2))
);
assert_eq!(
::std::mem::align_of::<msdfgen_Vector2>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_Vector2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Vector2>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Vector2),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Vector2>())).y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Vector2),
"::",
stringify!(y)
)
);
}
extern "C" {
#[doc = " Sets the vector to zero."]
#[link_name = "\u{1}_ZN7msdfgen7Vector25resetEv"]
pub fn msdfgen_Vector2_reset(this: *mut msdfgen_Vector2);
}
extern "C" {
#[doc = " Sets individual elements of the vector."]
#[link_name = "\u{1}_ZN7msdfgen7Vector23setEdd"]
pub fn msdfgen_Vector2_set(this: *mut msdfgen_Vector2, x: f64, y: f64);
}
extern "C" {
#[doc = " Returns the vector's length."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector26lengthEv"]
pub fn msdfgen_Vector2_length(this: *const msdfgen_Vector2) -> f64;
}
extern "C" {
#[doc = " Returns the angle of the vector in radians (atan2)."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector29directionEv"]
pub fn msdfgen_Vector2_direction(this: *const msdfgen_Vector2) -> f64;
}
extern "C" {
#[doc = " Returns the normalized vector - one that has the same direction but unit length."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector29normalizeEb"]
pub fn msdfgen_Vector2_normalize(
this: *const msdfgen_Vector2,
allowZero: bool,
) -> msdfgen_Vector2;
}
extern "C" {
#[doc = " Returns a vector with the same length that is orthogonal to this one."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector213getOrthogonalEb"]
pub fn msdfgen_Vector2_getOrthogonal(
this: *const msdfgen_Vector2,
polarity: bool,
) -> msdfgen_Vector2;
}
extern "C" {
#[doc = " Returns a vector with unit length that is orthogonal to this one."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector214getOrthonormalEbb"]
pub fn msdfgen_Vector2_getOrthonormal(
this: *const msdfgen_Vector2,
polarity: bool,
allowZero: bool,
) -> msdfgen_Vector2;
}
extern "C" {
#[doc = " Returns a vector projected along this one."]
#[link_name = "\u{1}_ZNK7msdfgen7Vector27projectERKS0_b"]
pub fn msdfgen_Vector2_project(
this: *const msdfgen_Vector2,
vector: *const msdfgen_Vector2,
positive: bool,
) -> msdfgen_Vector2;
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen7Vector2C1Ed"]
pub fn msdfgen_Vector2_Vector2(this: *mut msdfgen_Vector2, val: f64);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen7Vector2C1Edd"]
pub fn msdfgen_Vector2_Vector21(this: *mut msdfgen_Vector2, x: f64, y: f64);
}
impl msdfgen_Vector2 {
#[inline]
pub unsafe fn reset(&mut self) {
msdfgen_Vector2_reset(self)
}
#[inline]
pub unsafe fn set(&mut self, x: f64, y: f64) {
msdfgen_Vector2_set(self, x, y)
}
#[inline]
pub unsafe fn length(&self) -> f64 {
msdfgen_Vector2_length(self)
}
#[inline]
pub unsafe fn direction(&self) -> f64 {
msdfgen_Vector2_direction(self)
}
#[inline]
pub unsafe fn normalize(&self, allowZero: bool) -> msdfgen_Vector2 {
msdfgen_Vector2_normalize(self, allowZero)
}
#[inline]
pub unsafe fn getOrthogonal(&self, polarity: bool) -> msdfgen_Vector2 {
msdfgen_Vector2_getOrthogonal(self, polarity)
}
#[inline]
pub unsafe fn getOrthonormal(&self, polarity: bool, allowZero: bool) -> msdfgen_Vector2 {
msdfgen_Vector2_getOrthonormal(self, polarity, allowZero)
}
#[inline]
pub unsafe fn project(
&self,
vector: *const msdfgen_Vector2,
positive: bool,
) -> msdfgen_Vector2 {
msdfgen_Vector2_project(self, vector, positive)
}
#[inline]
pub unsafe fn new(val: f64) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_Vector2_Vector2(__bindgen_tmp.as_mut_ptr(), val);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(x: f64, y: f64) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_Vector2_Vector21(__bindgen_tmp.as_mut_ptr(), x, y);
__bindgen_tmp.assume_init()
}
}
#[doc = " A vector may also represent a point, which shall be differentiated semantically using the alias Point2."]
pub type msdfgen_Point2 = msdfgen_Vector2;
pub const msdfgen_FillRule_FILL_NONZERO: msdfgen_FillRule = 0;
pub const msdfgen_FillRule_FILL_ODD: msdfgen_FillRule = 1;
pub const msdfgen_FillRule_FILL_POSITIVE: msdfgen_FillRule = 2;
pub const msdfgen_FillRule_FILL_NEGATIVE: msdfgen_FillRule = 3;
#[doc = " Fill rule dictates how intersection total is interpreted during rasterization."]
pub type msdfgen_FillRule = u32;
extern "C" {
#[doc = " Resolves the number of intersection into a binary fill value based on fill rule."]
#[link_name = "\u{1}_ZN7msdfgen17interpretFillRuleEiNS_8FillRuleE"]
pub fn msdfgen_interpretFillRule(
intersections: ::std::os::raw::c_int,
fillRule: msdfgen_FillRule,
) -> bool;
}
#[doc = " Represents a horizontal scanline intersecting a shape."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_Scanline {
pub intersections: [u64; 3usize],
pub lastIndex: ::std::os::raw::c_int,
}
#[doc = " An intersection with the scanline."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct msdfgen_Scanline_Intersection {
#[doc = " X coordinate."]
pub x: f64,
#[doc = " Normalized Y direction of the oriented edge at the point of intersection."]
pub direction: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_msdfgen_Scanline_Intersection() {
assert_eq!(
::std::mem::size_of::<msdfgen_Scanline_Intersection>(),
16usize,
concat!("Size of: ", stringify!(msdfgen_Scanline_Intersection))
);
assert_eq!(
::std::mem::align_of::<msdfgen_Scanline_Intersection>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_Scanline_Intersection))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Scanline_Intersection>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Scanline_Intersection),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<msdfgen_Scanline_Intersection>())).direction as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Scanline_Intersection),
"::",
stringify!(direction)
)
);
}
#[test]
fn bindgen_test_layout_msdfgen_Scanline() {
assert_eq!(
::std::mem::size_of::<msdfgen_Scanline>(),
32usize,
concat!("Size of: ", stringify!(msdfgen_Scanline))
);
assert_eq!(
::std::mem::align_of::<msdfgen_Scanline>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_Scanline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Scanline>())).intersections as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Scanline),
"::",
stringify!(intersections)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Scanline>())).lastIndex as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Scanline),
"::",
stringify!(lastIndex)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen8Scanline7overlapERKS0_S2_ddNS_8FillRuleE"]
pub fn msdfgen_Scanline_overlap(
a: *const msdfgen_Scanline,
b: *const msdfgen_Scanline,
xFrom: f64,
xTo: f64,
fillRule: msdfgen_FillRule,
) -> f64;
}
extern "C" {
#[doc = " Populates the intersection list."]
#[link_name = "\u{1}_ZN7msdfgen8Scanline16setIntersectionsERKSt6vectorINS0_12IntersectionESaIS2_EE"]
pub fn msdfgen_Scanline_setIntersections(
this: *mut msdfgen_Scanline,
intersections: *const [u64; 3usize],
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen8Scanline16setIntersectionsEOSt6vectorINS0_12IntersectionESaIS2_EE"]
pub fn msdfgen_Scanline_setIntersections1(
this: *mut msdfgen_Scanline,
intersections: *mut [u64; 3usize],
);
}
extern "C" {
#[doc = " Returns the number of intersections left of x."]
#[link_name = "\u{1}_ZNK7msdfgen8Scanline18countIntersectionsEd"]
pub fn msdfgen_Scanline_countIntersections(
this: *const msdfgen_Scanline,
x: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Returns the total sign of intersections left of x."]
#[link_name = "\u{1}_ZNK7msdfgen8Scanline16sumIntersectionsEd"]
pub fn msdfgen_Scanline_sumIntersections(
this: *const msdfgen_Scanline,
x: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Decides whether the scanline is filled at x based on fill rule."]
#[link_name = "\u{1}_ZNK7msdfgen8Scanline6filledEdNS_8FillRuleE"]
pub fn msdfgen_Scanline_filled(
this: *const msdfgen_Scanline,
x: f64,
fillRule: msdfgen_FillRule,
) -> bool;
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen8ScanlineC1Ev"]
pub fn msdfgen_Scanline_Scanline(this: *mut msdfgen_Scanline);
}
impl msdfgen_Scanline {
#[inline]
pub unsafe fn overlap(
a: *const msdfgen_Scanline,
b: *const msdfgen_Scanline,
xFrom: f64,
xTo: f64,
fillRule: msdfgen_FillRule,
) -> f64 {
msdfgen_Scanline_overlap(a, b, xFrom, xTo, fillRule)
}
#[inline]
pub unsafe fn setIntersections(&mut self, intersections: *const [u64; 3usize]) {
msdfgen_Scanline_setIntersections(self, intersections)
}
#[inline]
pub unsafe fn setIntersections1(&mut self, intersections: *mut [u64; 3usize]) {
msdfgen_Scanline_setIntersections1(self, intersections)
}
#[inline]
pub unsafe fn countIntersections(&self, x: f64) -> ::std::os::raw::c_int {
msdfgen_Scanline_countIntersections(self, x)
}
#[inline]
pub unsafe fn sumIntersections(&self, x: f64) -> ::std::os::raw::c_int {
msdfgen_Scanline_sumIntersections(self, x)
}
#[inline]
pub unsafe fn filled(&self, x: f64, fillRule: msdfgen_FillRule) -> bool {
msdfgen_Scanline_filled(self, x, fillRule)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_Scanline_Scanline(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
#[doc = " Represents a signed distance and alignment, which together can be compared to uniquely determine the closest edge segment."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct msdfgen_SignedDistance {
pub distance: f64,
pub dot: f64,
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen14SignedDistance8INFINITEE"]
pub static msdfgen_SignedDistance_INFINITE: msdfgen_SignedDistance;
}
#[test]
fn bindgen_test_layout_msdfgen_SignedDistance() {
assert_eq!(
::std::mem::size_of::<msdfgen_SignedDistance>(),
16usize,
concat!("Size of: ", stringify!(msdfgen_SignedDistance))
);
assert_eq!(
::std::mem::align_of::<msdfgen_SignedDistance>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_SignedDistance))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_SignedDistance>())).distance as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_SignedDistance),
"::",
stringify!(distance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_SignedDistance>())).dot as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_SignedDistance),
"::",
stringify!(dot)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen14SignedDistanceC1Ev"]
pub fn msdfgen_SignedDistance_SignedDistance(this: *mut msdfgen_SignedDistance);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen14SignedDistanceC1Edd"]
pub fn msdfgen_SignedDistance_SignedDistance1(
this: *mut msdfgen_SignedDistance,
dist: f64,
d: f64,
);
}
impl msdfgen_SignedDistance {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_SignedDistance_SignedDistance(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(dist: f64, d: f64) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_SignedDistance_SignedDistance1(__bindgen_tmp.as_mut_ptr(), dist, d);
__bindgen_tmp.assume_init()
}
}
pub const msdfgen_EdgeColor_BLACK: msdfgen_EdgeColor = 0;
pub const msdfgen_EdgeColor_RED: msdfgen_EdgeColor = 1;
pub const msdfgen_EdgeColor_GREEN: msdfgen_EdgeColor = 2;
pub const msdfgen_EdgeColor_YELLOW: msdfgen_EdgeColor = 3;
pub const msdfgen_EdgeColor_BLUE: msdfgen_EdgeColor = 4;
pub const msdfgen_EdgeColor_MAGENTA: msdfgen_EdgeColor = 5;
pub const msdfgen_EdgeColor_CYAN: msdfgen_EdgeColor = 6;
pub const msdfgen_EdgeColor_WHITE: msdfgen_EdgeColor = 7;
#[doc = " Edge color specifies which color channels an edge belongs to."]
pub type msdfgen_EdgeColor = u32;
#[repr(C)]
pub struct msdfgen_EdgeSegment__bindgen_vtable(::std::os::raw::c_void);
#[doc = " An abstract edge segment."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_EdgeSegment {
pub vtable_: *const msdfgen_EdgeSegment__bindgen_vtable,
pub color: msdfgen_EdgeColor,
}
#[test]
fn bindgen_test_layout_msdfgen_EdgeSegment() {
assert_eq!(
::std::mem::size_of::<msdfgen_EdgeSegment>(),
16usize,
concat!("Size of: ", stringify!(msdfgen_EdgeSegment))
);
assert_eq!(
::std::mem::align_of::<msdfgen_EdgeSegment>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_EdgeSegment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_EdgeSegment>())).color as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_EdgeSegment),
"::",
stringify!(color)
)
);
}
extern "C" {
#[doc = " Converts a previously retrieved signed distance from origin to pseudo-distance."]
#[link_name = "\u{1}_ZNK7msdfgen11EdgeSegment24distanceToPseudoDistanceERNS_14SignedDistanceENS_7Vector2Ed"]
pub fn msdfgen_EdgeSegment_distanceToPseudoDistance(
this: *mut ::std::os::raw::c_void,
distance: *mut msdfgen_SignedDistance,
origin: msdfgen_Point2,
param: f64,
);
}
#[doc = " A line segment."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_LinearSegment {
pub _base: msdfgen_EdgeSegment,
pub p: [msdfgen_Point2; 2usize],
}
#[test]
fn bindgen_test_layout_msdfgen_LinearSegment() {
assert_eq!(
::std::mem::size_of::<msdfgen_LinearSegment>(),
48usize,
concat!("Size of: ", stringify!(msdfgen_LinearSegment))
);
assert_eq!(
::std::mem::align_of::<msdfgen_LinearSegment>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_LinearSegment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_LinearSegment>())).p as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_LinearSegment),
"::",
stringify!(p)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen13LinearSegmentC1ENS_7Vector2ES1_NS_9EdgeColorE"]
pub fn msdfgen_LinearSegment_LinearSegment(
this: *mut msdfgen_LinearSegment,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
impl msdfgen_LinearSegment {
#[inline]
pub unsafe fn new(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_LinearSegment_LinearSegment(__bindgen_tmp.as_mut_ptr(), p0, p1, edgeColor);
__bindgen_tmp.assume_init()
}
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment5cloneEv"]
pub fn msdfgen_LinearSegment_clone(
this: *mut ::std::os::raw::c_void,
) -> *mut msdfgen_LinearSegment;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment5pointEd"]
pub fn msdfgen_LinearSegment_point(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Point2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment9directionEd"]
pub fn msdfgen_LinearSegment_direction(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Vector2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment14signedDistanceENS_7Vector2ERd"]
pub fn msdfgen_LinearSegment_signedDistance(
this: *mut ::std::os::raw::c_void,
origin: msdfgen_Point2,
param: *mut f64,
) -> msdfgen_SignedDistance;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment21scanlineIntersectionsEPdPid"]
pub fn msdfgen_LinearSegment_scanlineIntersections(
this: *mut ::std::os::raw::c_void,
x: *mut f64,
dy: *mut ::std::os::raw::c_int,
y: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment6boundsERdS1_S1_S1_"]
pub fn msdfgen_LinearSegment_bounds(
this: *mut ::std::os::raw::c_void,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen13LinearSegment14moveStartPointENS_7Vector2E"]
pub fn msdfgen_LinearSegment_moveStartPoint(
this: *mut ::std::os::raw::c_void,
to: msdfgen_Point2,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen13LinearSegment12moveEndPointENS_7Vector2E"]
pub fn msdfgen_LinearSegment_moveEndPoint(
this: *mut ::std::os::raw::c_void,
to: msdfgen_Point2,
);
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen13LinearSegment13splitInThirdsERPNS_11EdgeSegmentES3_S3_"]
pub fn msdfgen_LinearSegment_splitInThirds(
this: *mut ::std::os::raw::c_void,
part1: *mut *mut msdfgen_EdgeSegment,
part2: *mut *mut msdfgen_EdgeSegment,
part3: *mut *mut msdfgen_EdgeSegment,
);
}
#[doc = " A quadratic Bezier curve."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_QuadraticSegment {
pub _base: msdfgen_EdgeSegment,
pub p: [msdfgen_Point2; 3usize],
}
#[test]
fn bindgen_test_layout_msdfgen_QuadraticSegment() {
assert_eq!(
::std::mem::size_of::<msdfgen_QuadraticSegment>(),
64usize,
concat!("Size of: ", stringify!(msdfgen_QuadraticSegment))
);
assert_eq!(
::std::mem::align_of::<msdfgen_QuadraticSegment>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_QuadraticSegment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_QuadraticSegment>())).p as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_QuadraticSegment),
"::",
stringify!(p)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen16QuadraticSegmentC1ENS_7Vector2ES1_S1_NS_9EdgeColorE"]
pub fn msdfgen_QuadraticSegment_QuadraticSegment(
this: *mut msdfgen_QuadraticSegment,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
impl msdfgen_QuadraticSegment {
#[inline]
pub unsafe fn new(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_QuadraticSegment_QuadraticSegment(
__bindgen_tmp.as_mut_ptr(),
p0,
p1,
p2,
edgeColor,
);
__bindgen_tmp.assume_init()
}
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment5cloneEv"]
pub fn msdfgen_QuadraticSegment_clone(
this: *mut ::std::os::raw::c_void,
) -> *mut msdfgen_QuadraticSegment;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment5pointEd"]
pub fn msdfgen_QuadraticSegment_point(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Point2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment9directionEd"]
pub fn msdfgen_QuadraticSegment_direction(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Vector2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment14signedDistanceENS_7Vector2ERd"]
pub fn msdfgen_QuadraticSegment_signedDistance(
this: *mut ::std::os::raw::c_void,
origin: msdfgen_Point2,
param: *mut f64,
) -> msdfgen_SignedDistance;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment21scanlineIntersectionsEPdPid"]
pub fn msdfgen_QuadraticSegment_scanlineIntersections(
this: *mut ::std::os::raw::c_void,
x: *mut f64,
dy: *mut ::std::os::raw::c_int,
y: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment6boundsERdS1_S1_S1_"]
pub fn msdfgen_QuadraticSegment_bounds(
this: *mut ::std::os::raw::c_void,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen16QuadraticSegment14moveStartPointENS_7Vector2E"]
pub fn msdfgen_QuadraticSegment_moveStartPoint(
this: *mut ::std::os::raw::c_void,
to: msdfgen_Point2,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen16QuadraticSegment12moveEndPointENS_7Vector2E"]
pub fn msdfgen_QuadraticSegment_moveEndPoint(
this: *mut ::std::os::raw::c_void,
to: msdfgen_Point2,
);
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen16QuadraticSegment13splitInThirdsERPNS_11EdgeSegmentES3_S3_"]
pub fn msdfgen_QuadraticSegment_splitInThirds(
this: *mut ::std::os::raw::c_void,
part1: *mut *mut msdfgen_EdgeSegment,
part2: *mut *mut msdfgen_EdgeSegment,
part3: *mut *mut msdfgen_EdgeSegment,
);
}
#[doc = " A cubic Bezier curve."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_CubicSegment {
pub _base: msdfgen_EdgeSegment,
pub p: [msdfgen_Point2; 4usize],
}
#[test]
fn bindgen_test_layout_msdfgen_CubicSegment() {
assert_eq!(
::std::mem::size_of::<msdfgen_CubicSegment>(),
80usize,
concat!("Size of: ", stringify!(msdfgen_CubicSegment))
);
assert_eq!(
::std::mem::align_of::<msdfgen_CubicSegment>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_CubicSegment))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_CubicSegment>())).p as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_CubicSegment),
"::",
stringify!(p)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen12CubicSegmentC1ENS_7Vector2ES1_S1_S1_NS_9EdgeColorE"]
pub fn msdfgen_CubicSegment_CubicSegment(
this: *mut msdfgen_CubicSegment,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
p3: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
impl msdfgen_CubicSegment {
#[inline]
pub unsafe fn new(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
p3: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_CubicSegment_CubicSegment(__bindgen_tmp.as_mut_ptr(), p0, p1, p2, p3, edgeColor);
__bindgen_tmp.assume_init()
}
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment5cloneEv"]
pub fn msdfgen_CubicSegment_clone(
this: *mut ::std::os::raw::c_void,
) -> *mut msdfgen_CubicSegment;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment5pointEd"]
pub fn msdfgen_CubicSegment_point(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Point2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment9directionEd"]
pub fn msdfgen_CubicSegment_direction(
this: *mut ::std::os::raw::c_void,
param: f64,
) -> msdfgen_Vector2;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment14signedDistanceENS_7Vector2ERd"]
pub fn msdfgen_CubicSegment_signedDistance(
this: *mut ::std::os::raw::c_void,
origin: msdfgen_Point2,
param: *mut f64,
) -> msdfgen_SignedDistance;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment21scanlineIntersectionsEPdPid"]
pub fn msdfgen_CubicSegment_scanlineIntersections(
this: *mut ::std::os::raw::c_void,
x: *mut f64,
dy: *mut ::std::os::raw::c_int,
y: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment6boundsERdS1_S1_S1_"]
pub fn msdfgen_CubicSegment_bounds(
this: *mut ::std::os::raw::c_void,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen12CubicSegment14moveStartPointENS_7Vector2E"]
pub fn msdfgen_CubicSegment_moveStartPoint(
this: *mut ::std::os::raw::c_void,
to: msdfgen_Point2,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen12CubicSegment12moveEndPointENS_7Vector2E"]
pub fn msdfgen_CubicSegment_moveEndPoint(this: *mut ::std::os::raw::c_void, to: msdfgen_Point2);
}
extern "C" {
#[link_name = "\u{1}_ZNK7msdfgen12CubicSegment13splitInThirdsERPNS_11EdgeSegmentES3_S3_"]
pub fn msdfgen_CubicSegment_splitInThirds(
this: *mut ::std::os::raw::c_void,
part1: *mut *mut msdfgen_EdgeSegment,
part2: *mut *mut msdfgen_EdgeSegment,
part3: *mut *mut msdfgen_EdgeSegment,
);
}
#[doc = " Container for a single edge of dynamic type."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_EdgeHolder {
pub edgeSegment: *mut msdfgen_EdgeSegment,
}
#[test]
fn bindgen_test_layout_msdfgen_EdgeHolder() {
assert_eq!(
::std::mem::size_of::<msdfgen_EdgeHolder>(),
8usize,
concat!("Size of: ", stringify!(msdfgen_EdgeHolder))
);
assert_eq!(
::std::mem::align_of::<msdfgen_EdgeHolder>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_EdgeHolder))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_EdgeHolder>())).edgeSegment as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_EdgeHolder),
"::",
stringify!(edgeSegment)
)
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1Ev"]
pub fn msdfgen_EdgeHolder_EdgeHolder(this: *mut msdfgen_EdgeHolder);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1EPNS_11EdgeSegmentE"]
pub fn msdfgen_EdgeHolder_EdgeHolder1(
this: *mut msdfgen_EdgeHolder,
segment: *mut msdfgen_EdgeSegment,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1ENS_7Vector2ES1_NS_9EdgeColorE"]
pub fn msdfgen_EdgeHolder_EdgeHolder2(
this: *mut msdfgen_EdgeHolder,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1ENS_7Vector2ES1_S1_NS_9EdgeColorE"]
pub fn msdfgen_EdgeHolder_EdgeHolder3(
this: *mut msdfgen_EdgeHolder,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1ENS_7Vector2ES1_S1_S1_NS_9EdgeColorE"]
pub fn msdfgen_EdgeHolder_EdgeHolder4(
this: *mut msdfgen_EdgeHolder,
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
p3: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1ERKS0_"]
pub fn msdfgen_EdgeHolder_EdgeHolder5(
this: *mut msdfgen_EdgeHolder,
orig: *const msdfgen_EdgeHolder,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderC1EOS0_"]
pub fn msdfgen_EdgeHolder_EdgeHolder6(
this: *mut msdfgen_EdgeHolder,
orig: *mut msdfgen_EdgeHolder,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen10EdgeHolderD1Ev"]
pub fn msdfgen_EdgeHolder_EdgeHolder_destructor(this: *mut msdfgen_EdgeHolder);
}
impl msdfgen_EdgeHolder {
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new1(segment: *mut msdfgen_EdgeSegment) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder1(__bindgen_tmp.as_mut_ptr(), segment);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new2(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder2(__bindgen_tmp.as_mut_ptr(), p0, p1, edgeColor);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new3(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder3(__bindgen_tmp.as_mut_ptr(), p0, p1, p2, edgeColor);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new4(
p0: msdfgen_Point2,
p1: msdfgen_Point2,
p2: msdfgen_Point2,
p3: msdfgen_Point2,
edgeColor: msdfgen_EdgeColor,
) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder4(__bindgen_tmp.as_mut_ptr(), p0, p1, p2, p3, edgeColor);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new5(orig: *const msdfgen_EdgeHolder) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder5(__bindgen_tmp.as_mut_ptr(), orig);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn new6(orig: *mut msdfgen_EdgeHolder) -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_EdgeHolder_EdgeHolder6(__bindgen_tmp.as_mut_ptr(), orig);
__bindgen_tmp.assume_init()
}
#[inline]
pub unsafe fn destruct(&mut self) {
msdfgen_EdgeHolder_EdgeHolder_destructor(self)
}
}
#[doc = " A single closed contour of a shape."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_Contour {
#[doc = " The sequence of edges that make up the contour."]
pub edges: [u64; 3usize],
}
#[test]
fn bindgen_test_layout_msdfgen_Contour() {
assert_eq!(
::std::mem::size_of::<msdfgen_Contour>(),
24usize,
concat!("Size of: ", stringify!(msdfgen_Contour))
);
assert_eq!(
::std::mem::align_of::<msdfgen_Contour>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_Contour))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Contour>())).edges as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Contour),
"::",
stringify!(edges)
)
);
}
extern "C" {
#[doc = " Adds an edge to the contour."]
#[link_name = "\u{1}_ZN7msdfgen7Contour7addEdgeERKNS_10EdgeHolderE"]
pub fn msdfgen_Contour_addEdge(this: *mut msdfgen_Contour, edge: *const msdfgen_EdgeHolder);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen7Contour7addEdgeEONS_10EdgeHolderE"]
pub fn msdfgen_Contour_addEdge1(this: *mut msdfgen_Contour, edge: *mut msdfgen_EdgeHolder);
}
extern "C" {
#[doc = " Creates a new edge in the contour and returns its reference."]
#[link_name = "\u{1}_ZN7msdfgen7Contour7addEdgeEv"]
pub fn msdfgen_Contour_addEdge2(this: *mut msdfgen_Contour) -> *mut msdfgen_EdgeHolder;
}
extern "C" {
#[doc = " Adjusts the bounding box to fit the contour."]
#[link_name = "\u{1}_ZNK7msdfgen7Contour6boundsERdS1_S1_S1_"]
pub fn msdfgen_Contour_bounds(
this: *const msdfgen_Contour,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
);
}
extern "C" {
#[doc = " Adjusts the bounding box to fit the contour border's mitered corners."]
#[link_name = "\u{1}_ZNK7msdfgen7Contour11miterBoundsERdS1_S1_S1_dd"]
pub fn msdfgen_Contour_miterBounds(
this: *const msdfgen_Contour,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
border: f64,
miterLimit: f64,
);
}
extern "C" {
#[doc = " Computes the winding of the contour. Returns 1 if positive, -1 if negative."]
#[link_name = "\u{1}_ZNK7msdfgen7Contour7windingEv"]
pub fn msdfgen_Contour_winding(this: *const msdfgen_Contour) -> ::std::os::raw::c_int;
}
impl msdfgen_Contour {
#[inline]
pub unsafe fn addEdge(&mut self, edge: *const msdfgen_EdgeHolder) {
msdfgen_Contour_addEdge(self, edge)
}
#[inline]
pub unsafe fn addEdge1(&mut self, edge: *mut msdfgen_EdgeHolder) {
msdfgen_Contour_addEdge1(self, edge)
}
#[inline]
pub unsafe fn addEdge2(&mut self) -> *mut msdfgen_EdgeHolder {
msdfgen_Contour_addEdge2(self)
}
#[inline]
pub unsafe fn bounds(&self, l: *mut f64, b: *mut f64, r: *mut f64, t: *mut f64) {
msdfgen_Contour_bounds(self, l, b, r, t)
}
#[inline]
pub unsafe fn miterBounds(
&self,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
border: f64,
miterLimit: f64,
) {
msdfgen_Contour_miterBounds(self, l, b, r, t, border, miterLimit)
}
#[inline]
pub unsafe fn winding(&self) -> ::std::os::raw::c_int {
msdfgen_Contour_winding(self)
}
}
#[doc = " Vector shape representation."]
#[repr(C)]
#[derive(Debug)]
pub struct msdfgen_Shape {
#[doc = " The list of contours the shape consists of."]
pub contours: [u64; 3usize],
#[doc = " Specifies whether the shape uses bottom-to-top (false) or top-to-bottom (true) Y coordinates."]
pub inverseYAxis: bool,
}
#[test]
fn bindgen_test_layout_msdfgen_Shape() {
assert_eq!(
::std::mem::size_of::<msdfgen_Shape>(),
32usize,
concat!("Size of: ", stringify!(msdfgen_Shape))
);
assert_eq!(
::std::mem::align_of::<msdfgen_Shape>(),
8usize,
concat!("Alignment of ", stringify!(msdfgen_Shape))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Shape>())).contours as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Shape),
"::",
stringify!(contours)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<msdfgen_Shape>())).inverseYAxis as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(msdfgen_Shape),
"::",
stringify!(inverseYAxis)
)
);
}
extern "C" {
#[doc = " Adds a contour."]
#[link_name = "\u{1}_ZN7msdfgen5Shape10addContourERKNS_7ContourE"]
pub fn msdfgen_Shape_addContour(this: *mut msdfgen_Shape, contour: *const msdfgen_Contour);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen5Shape10addContourEONS_7ContourE"]
pub fn msdfgen_Shape_addContour1(this: *mut msdfgen_Shape, contour: *mut msdfgen_Contour);
}
extern "C" {
#[doc = " Adds a blank contour and returns its reference."]
#[link_name = "\u{1}_ZN7msdfgen5Shape10addContourEv"]
pub fn msdfgen_Shape_addContour2(this: *mut msdfgen_Shape) -> *mut msdfgen_Contour;
}
extern "C" {
#[doc = " Normalizes the shape geometry for distance field generation."]
#[link_name = "\u{1}_ZN7msdfgen5Shape9normalizeEv"]
pub fn msdfgen_Shape_normalize(this: *mut msdfgen_Shape);
}
extern "C" {
#[doc = " Performs basic checks to determine if the object represents a valid shape."]
#[link_name = "\u{1}_ZNK7msdfgen5Shape8validateEv"]
pub fn msdfgen_Shape_validate(this: *const msdfgen_Shape) -> bool;
}
extern "C" {
#[doc = " Adjusts the bounding box to fit the shape."]
#[link_name = "\u{1}_ZNK7msdfgen5Shape6boundsERdS1_S1_S1_"]
pub fn msdfgen_Shape_bounds(
this: *const msdfgen_Shape,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
);
}
extern "C" {
#[doc = " Adjusts the bounding box to fit the shape border's mitered corners."]
#[link_name = "\u{1}_ZNK7msdfgen5Shape11miterBoundsERdS1_S1_S1_dd"]
pub fn msdfgen_Shape_miterBounds(
this: *const msdfgen_Shape,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
border: f64,
miterLimit: f64,
);
}
extern "C" {
#[doc = " Outputs the scanline that intersects the shape at y."]
#[link_name = "\u{1}_ZNK7msdfgen5Shape8scanlineERNS_8ScanlineEd"]
pub fn msdfgen_Shape_scanline(this: *const msdfgen_Shape, line: *mut msdfgen_Scanline, y: f64);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen5ShapeC1Ev"]
pub fn msdfgen_Shape_Shape(this: *mut msdfgen_Shape);
}
impl msdfgen_Shape {
#[inline]
pub unsafe fn addContour(&mut self, contour: *const msdfgen_Contour) {
msdfgen_Shape_addContour(self, contour)
}
#[inline]
pub unsafe fn addContour1(&mut self, contour: *mut msdfgen_Contour) {
msdfgen_Shape_addContour1(self, contour)
}
#[inline]
pub unsafe fn addContour2(&mut self) -> *mut msdfgen_Contour {
msdfgen_Shape_addContour2(self)
}
#[inline]
pub unsafe fn normalize(&mut self) {
msdfgen_Shape_normalize(self)
}
#[inline]
pub unsafe fn validate(&self) -> bool {
msdfgen_Shape_validate(self)
}
#[inline]
pub unsafe fn bounds(&self, l: *mut f64, b: *mut f64, r: *mut f64, t: *mut f64) {
msdfgen_Shape_bounds(self, l, b, r, t)
}
#[inline]
pub unsafe fn miterBounds(
&self,
l: *mut f64,
b: *mut f64,
r: *mut f64,
t: *mut f64,
border: f64,
miterLimit: f64,
) {
msdfgen_Shape_miterBounds(self, l, b, r, t, border, miterLimit)
}
#[inline]
pub unsafe fn scanline(&self, line: *mut msdfgen_Scanline, y: f64) {
msdfgen_Shape_scanline(self, line, y)
}
#[inline]
pub unsafe fn new() -> Self {
let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
msdfgen_Shape_Shape(__bindgen_tmp.as_mut_ptr());
__bindgen_tmp.assume_init()
}
}
pub type msdfgen_byte = ::std::os::raw::c_uchar;
extern "C" {
#[doc = " Assigns colors to edges of the shape in accordance to the multi-channel distance field technique."]
#[doc = " May split some edges if necessary."]
#[doc = " angleThreshold specifies the maximum angle (in radians) to be considered a corner, for example 3 (~172 degrees)."]
#[doc = " Values below 1/2 PI will be treated as the external angle."]
#[link_name = "\u{1}_ZN7msdfgen18edgeColoringSimpleERNS_5ShapeEdy"]
pub fn msdfgen_edgeColoringSimple(
shape: *mut msdfgen_Shape,
angleThreshold: f64,
seed: ::std::os::raw::c_ulonglong,
);
}
extern "C" {
#[doc = " Reconstructs the shape's appearance into output from the distance field sdf."]
#[link_name = "\u{1}_ZN7msdfgen9renderSDFERKNS_9BitmapRefIfLi1EEERKNS_14BitmapConstRefIfLi1EEEd"]
pub fn msdfgen_renderSDF(output: *const u8, sdf: *const u8, pxRange: f64);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen9renderSDFERKNS_9BitmapRefIfLi3EEERKNS_14BitmapConstRefIfLi1EEEd"]
pub fn msdfgen_renderSDF1(output: *const u8, sdf: *const u8, pxRange: f64);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen9renderSDFERKNS_9BitmapRefIfLi1EEERKNS_14BitmapConstRefIfLi3EEEd"]
pub fn msdfgen_renderSDF2(output: *const u8, sdf: *const u8, pxRange: f64);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen9renderSDFERKNS_9BitmapRefIfLi3EEERKNS_14BitmapConstRefIfLi3EEEd"]
pub fn msdfgen_renderSDF3(output: *const u8, sdf: *const u8, pxRange: f64);
}
extern "C" {
#[doc = " Snaps the values of the floating-point bitmaps into one of the 256 values representable in a standard 8-bit bitmap."]
#[link_name = "\u{1}_ZN7msdfgen12simulate8bitERKNS_9BitmapRefIfLi1EEE"]
pub fn msdfgen_simulate8bit(bitmap: *const u8);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen12simulate8bitERKNS_9BitmapRefIfLi3EEE"]
pub fn msdfgen_simulate8bit1(bitmap: *const u8);
}
extern "C" {
#[doc = " Rasterizes the shape into a monochrome bitmap."]
#[link_name = "\u{1}_ZN7msdfgen9rasterizeERKNS_9BitmapRefIfLi1EEERKNS_5ShapeERKNS_7Vector2ES9_NS_8FillRuleE"]
pub fn msdfgen_rasterize(
output: *const u8,
shape: *const msdfgen_Shape,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
fillRule: msdfgen_FillRule,
);
}
extern "C" {
#[doc = " Fixes the sign of the input signed distance field, so that it matches the shape's rasterized fill."]
#[link_name = "\u{1}_ZN7msdfgen22distanceSignCorrectionERKNS_9BitmapRefIfLi1EEERKNS_5ShapeERKNS_7Vector2ES9_NS_8FillRuleE"]
pub fn msdfgen_distanceSignCorrection(
sdf: *const u8,
shape: *const msdfgen_Shape,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
fillRule: msdfgen_FillRule,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen22distanceSignCorrectionERKNS_9BitmapRefIfLi3EEERKNS_5ShapeERKNS_7Vector2ES9_NS_8FillRuleE"]
pub fn msdfgen_distanceSignCorrection1(
sdf: *const u8,
shape: *const msdfgen_Shape,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
fillRule: msdfgen_FillRule,
);
}
extern "C" {
#[doc = " Analytically constructs a scanline at y evaluating fill by linear interpolation of the SDF."]
#[link_name = "\u{1}_ZN7msdfgen11scanlineSDFERNS_8ScanlineERKNS_14BitmapConstRefIfLi1EEERKNS_7Vector2ES8_bd"]
pub fn msdfgen_scanlineSDF(
line: *mut msdfgen_Scanline,
sdf: *const u8,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
inverseYAxis: bool,
y: f64,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen11scanlineSDFERNS_8ScanlineERKNS_14BitmapConstRefIfLi3EEERKNS_7Vector2ES8_bd"]
pub fn msdfgen_scanlineSDF1(
line: *mut msdfgen_Scanline,
sdf: *const u8,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
inverseYAxis: bool,
y: f64,
);
}
extern "C" {
#[doc = " Estimates the portion of the area that will be filled incorrectly when rendering using the SDF."]
#[link_name = "\u{1}_ZN7msdfgen16estimateSDFErrorERKNS_14BitmapConstRefIfLi1EEERKNS_5ShapeERKNS_7Vector2ES9_iNS_8FillRuleE"]
pub fn msdfgen_estimateSDFError(
sdf: *const u8,
shape: *const msdfgen_Shape,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
scanlinesPerRow: ::std::os::raw::c_int,
fillRule: msdfgen_FillRule,
) -> f64;
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen16estimateSDFErrorERKNS_14BitmapConstRefIfLi3EEERKNS_5ShapeERKNS_7Vector2ES9_iNS_8FillRuleE"]
pub fn msdfgen_estimateSDFError1(
sdf: *const u8,
shape: *const msdfgen_Shape,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
scanlinesPerRow: ::std::os::raw::c_int,
fillRule: msdfgen_FillRule,
) -> f64;
}
extern "C" {
#[doc = " Generates a conventional single-channel signed distance field."]
#[link_name = "\u{1}_ZN7msdfgen11generateSDFERKNS_9BitmapRefIfLi1EEERKNS_5ShapeEdRKNS_7Vector2ES9_b"]
pub fn msdfgen_generateSDF(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
overlapSupport: bool,
);
}
extern "C" {
#[doc = " Generates a single-channel signed pseudo-distance field."]
#[link_name = "\u{1}_ZN7msdfgen17generatePseudoSDFERKNS_9BitmapRefIfLi1EEERKNS_5ShapeEdRKNS_7Vector2ES9_b"]
pub fn msdfgen_generatePseudoSDF(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
overlapSupport: bool,
);
}
extern "C" {
#[doc = " Generates a multi-channel signed distance field. Edge colors must be assigned first! (See edgeColoringSimple)"]
#[link_name = "\u{1}_ZN7msdfgen12generateMSDFERKNS_9BitmapRefIfLi3EEERKNS_5ShapeEdRKNS_7Vector2ES9_db"]
pub fn msdfgen_generateMSDF(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
edgeThreshold: f64,
overlapSupport: bool,
);
}
extern "C" {
#[doc = " Resolves multi-channel signed distance field values that may cause interpolation artifacts. (Already called by generateMSDF)"]
#[link_name = "\u{1}_ZN7msdfgen19msdfErrorCorrectionERKNS_9BitmapRefIfLi3EEERKNS_7Vector2E"]
pub fn msdfgen_msdfErrorCorrection(output: *const u8, threshold: *const msdfgen_Vector2);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen18generateSDF_legacyERKNS_9BitmapRefIfLi1EEERKNS_5ShapeEdRKNS_7Vector2ES9_"]
pub fn msdfgen_generateSDF_legacy(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen24generatePseudoSDF_legacyERKNS_9BitmapRefIfLi1EEERKNS_5ShapeEdRKNS_7Vector2ES9_"]
pub fn msdfgen_generatePseudoSDF_legacy(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen19generateMSDF_legacyERKNS_9BitmapRefIfLi3EEERKNS_5ShapeEdRKNS_7Vector2ES9_d"]
pub fn msdfgen_generateMSDF_legacy(
output: *const u8,
shape: *const msdfgen_Shape,
range: f64,
scale: *const msdfgen_Vector2,
translate: *const msdfgen_Vector2,
edgeThreshold: f64,
);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen19Contour_constructorEv"]
pub fn msdfgen_Contour_constructor() -> msdfgen_Contour;
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen18Contour_destructorERNS_7ContourE"]
pub fn msdfgen_Contour_destructor(self_: *mut msdfgen_Contour);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen16Shape_destructorERNS_5ShapeE"]
pub fn msdfgen_Shape_destructor(self_: *mut msdfgen_Shape);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen19Scanline_destructorERNS_8ScanlineE"]
pub fn msdfgen_Scanline_destructor(self_: *mut msdfgen_Scanline);
}
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen21EdgeHolder_setSegmentERNS_10EdgeHolderERKNS_11EdgeSegmentE"]
pub fn msdfgen_EdgeHolder_setSegment(
self_: *mut msdfgen_EdgeHolder,
segment: *const msdfgen_EdgeSegment,
);
}
pub const msdfgen_SegmentKind_LINEAR: msdfgen_SegmentKind = 0;
pub const msdfgen_SegmentKind_QUADRATIC: msdfgen_SegmentKind = 1;
pub const msdfgen_SegmentKind_CUBIC: msdfgen_SegmentKind = 2;
pub type msdfgen_SegmentKind = u32;
extern "C" {
#[link_name = "\u{1}_ZN7msdfgen19EdgeSegment_getKindERKNS_11EdgeSegmentE"]
pub fn msdfgen_EdgeSegment_getKind(self_: *const msdfgen_EdgeSegment) -> msdfgen_SegmentKind;
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_msdfgen_Scanline_Intersection_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_msdfgen_Scanline_Intersection_close0_instantiation_1()
{
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_msdfgen_Scanline_Intersection_close0_instantiation_2()
{
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_msdfgen_EdgeHolder_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}
#[test]
fn __bindgen_test_layout_std_allocator_open0_msdfgen_Contour_close0_instantiation() {
assert_eq!(
::std::mem::size_of::<std_allocator>(),
1usize,
concat!(
"Size of template specialization: ",
stringify!(std_allocator)
)
);
assert_eq!(
::std::mem::align_of::<std_allocator>(),
1usize,
concat!(
"Alignment of template specialization: ",
stringify!(std_allocator)
)
);
}