acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
ellipse_type< NUMBER > Class Template Reference
Inheritance diagram for ellipse_type< NUMBER >:
rectangle_type< NUMBER > sequence_type< NUMBER, 4 > sequence_t_type< NUMBER, t_iSize > arc_type< ::i32 > arc_type< ::i64 > arc_type< ::f32 > arc_type< ::f64 > arc_type< NUMBER >

Public Member Functions

template<prototype_number NUMBER2>
 ellipse_type (const ellipse_type< NUMBER2 > &ellipse)
void set (const ::rectangle_type< NUMBER > &rectangle)
auto radius () const
bool contains (const ::point_type< NUMBER > &point)
Public Member Functions inherited from rectangle_type< NUMBER >
 rectangle_type (no_initialize_t)
template<prototype_number LEFT, prototype_number TOP, prototype_number RIGHT, prototype_number BOTTOM>
 rectangle_type (LEFT left, TOP top, RIGHT right, BOTTOM bottom)
template<prototype_number A, prototype_number B>
 rectangle_type (api_change_t, A a, B b)
template<prototype_number N>
 rectangle_type (api_change_t, N n)
template<prototype_point POINT, prototype_size SIZE>
 rectangle_type (const POINT &point, const SIZE &size)
template<prototype_size SIZE>
 rectangle_type (const SIZE &size)
template<prototype_point POINT1, prototype_point POINT2>
 rectangle_type (const POINT1 &point1, const POINT2 &point2)
template<prototype_rectangle RECTANGLE>
 rectangle_type (const RECTANGLE &t)
template<struct_rectangle RECTANGLE>
 rectangle_type (const RECTANGLE &r)
template<rectangle_source RECTANGLE_SOURCE>
 rectangle_type (RECTANGLE_SOURCE *prectanglesource)
template<prototype_origin_size ORIGIN_SIZE>
 rectangle_type (const ORIGIN_SIZE &originsize)
template<prototype_number NUMBER2>
 rectangle_type (const origin_size< NUMBER2 > &originsize)
auto & origin ()
const auto & origin () const
const auto & bottom_right () const
const auto & top_left () const
UNIT_TYPE center_x () const
UNIT_TYPE center_y () const
POINT_TYPE center () const
bool is_set () const
bool is_empty () const
bool is_null () const
bool is_null_or_positive () const
bool is_ok () const
bool has_area () const
template<prototype_point POINT>
bool contains (const POINT &point) const
bool contains_x (UNIT_TYPE x) const
bool contains_y (UNIT_TYPE y) const
template<typename SIZE>
rectangle_type & ensure_at_least (const SIZE &size)
template<prototype_point POINT>
inline ::f64_point to_point_rate (const POINT &point) const
UNIT_TYPE x_rate (::f64 xRate) const
UNIT_TYPE y_rate (::f64 yRate) const
POINT_TYPE from_point_rate (const ::f64_point &point) const
POINT_TYPE top_right () const
POINT_TYPE bottom_left () const
UNIT_TYPE minimum_dimension () const
UNIT_TYPE maximum_dimension () const
UNIT_TYPE max_border () const
UNIT_TYPE minimum_natural_dimension () const
UNIT_TYPE maximum_natural_dimension () const
UNIT_TYPE minimum_absolute_dimension () const
UNIT_TYPE maximum_absolute_dimension () const
UNIT_TYPE get_dimension (enum_orientation eorientation, ::collection::index i)
UNIT_TYPE get_normal_dimension (enum_orientation eorientation, ::collection::index i)
UNIT_TYPE get_first_dimension (enum_orientation eorientation)
UNIT_TYPE get_first_normal_dimension (enum_orientation eorientation)
UNIT_TYPE get_second_dimension (enum_orientation eorientation)
UNIT_TYPE get_second_normal_dimension (enum_orientation eorientation)
UNIT_TYPE get_total_dimension (enum_orientation eorientation)
UNIT_TYPE get_normal_total_dimension (enum_orientation eorientation)
UNIT_TYPE width () const
UNIT_TYPE height () const
SIZE_TYPE size () const
SIZE_TYPE radius () const
void set_width (UNIT_TYPE cx)
void set_height (UNIT_TYPE cy)
void set_size (UNIT_TYPE cx, UNIT_TYPE cy)
void set_size (const SIZE_TYPE &size)
void set_top_left (UNIT_TYPE leftNew, UNIT_TYPE topNew)
void set_top_left (const POINT_TYPE &point)
rectangle_type & set_center_and_half_size (const POINT_TYPE &center, const SIZE_TYPE &halfsize)
rectangle_type & set_square_with_center (const POINT_TYPE &center, const UNIT_TYPE &apothem)
rectangle_type & move_top_to (UNIT_TYPE top)
rectangle_type & move_left_to (UNIT_TYPE left)
rectangle_type & move_right_to (UNIT_TYPE right)
rectangle_type & move_bottom_to (UNIT_TYPE bottom)
rectangle_type & move_to (UNIT_TYPE left, UNIT_TYPE top)
rectangle_type & move_to (const POINT_TYPE &point)
POINT_TYPE & top_left ()
POINT_TYPE & bottom_right ()
void swap_left_right ()
 operator bool () const
bool operator! () const
rectangle_type & set (UNIT_TYPE i)
rectangle_type & set (UNIT_TYPE x, UNIT_TYPE y)
rectangle_type & set (UNIT_TYPE l, UNIT_TYPE t, UNIT_TYPE r, UNIT_TYPE b)
template<prototype_size SIZE>
rectangle_type & set (const SIZE &s)
template<prototype_point POINT1, prototype_point POINT2>
rectangle_type & set (const POINT1 &p1, const POINT2 &p2)
template<prototype_point POINT, prototype_size SIZE>
rectangle_type & set (const POINT &p, const SIZE &s)
template<prototype_rectangle RECTANGLE>
rectangle_type & set (const RECTANGLE &rectangle)
rectangle_type & set_dimension (UNIT_TYPE l, UNIT_TYPE t, UNIT_TYPE w, UNIT_TYPE h)
rectangle_type & clear ()
bool is_equal (const rectangle_type &rectangle) const
template<prototype_number NUMBERX, prototype_number NUMBERY>
rectangle_type & inflate (NUMBERX x, NUMBERY y)
template<prototype_size SIZE>
rectangle_type & inflate (const SIZE &size)
template<prototype_number NUMBERX, prototype_number NUMBERY>
rectangle_type & deflate (NUMBERX x, NUMBERY y)
template<prototype_size SIZE>
rectangle_type & deflate (const SIZE &size)
template<prototype_number NUMBERX, prototype_number NUMBERY>
rectangle_type & offset (NUMBERX x, NUMBERY y)
template<prototype_number NUMBERX>
rectangle_type & offset_x (NUMBERX x)
template<prototype_number NUMBERY>
rectangle_type & offset_y (NUMBERY y)
template<prototype_number NUMBERN>
rectangle_type & inflate (NUMBERN n)
template<prototype_number NUMBERN>
rectangle_type & deflate (NUMBERN n)
template<prototype_number NUMBERN>
rectangle_type & offset (const sequence_type< NUMBERN, 2 > &s)
bool x_intersects (const rectangle_type &rectangle) const
bool y_intersects (const rectangle_type &rectangle) const
bool intersects (const rectangle_type &rectangle) const
bool intersect_x (const rectangle_type &rect1, const rectangle_type &rect2)
bool intersect_y (const rectangle_type &rect1, const rectangle_type &rect2)
bool intersect (const rectangle_type &rect1, const rectangle_type &rect2)
rectangle_type & intersect (const rectangle_type &rectangle)
rectangle_type & constrain_to (const rectangle_type &rectangle)
rectangle_type & constrain (rectangle_type &rectangle) const
rectangle_type intersection (const rectangle_type &rect1) const
rectangle_type outside_of (const rectangle_type &rect1) const
bool null_intersect (const rectangle_type &rect1, const rectangle_type &rect2)
bool top_left_null_intersect (const rectangle_type &rect1, const rectangle_type &rect2)
rectangle_type & unite (const rectangle_type &rectangle1, const rectangle_type &rectangle2)
rectangle_type & unite (const rectangle_type &rectangle)
rectangle_type get_union (const rectangle_type &rect1) const
rectangle_type left_difference (const rectangle_type &rectangle) const
rectangle_type top_difference (const rectangle_type &rectangle) const
rectangle_type right_difference (const rectangle_type &rectangle) const
rectangle_type bottom_difference (const rectangle_type &rectangle) const
rectangle_type left_plus_difference (const rectangle_type &rectangle) const
rectangle_type top_plus_difference (const rectangle_type &rectangle) const
rectangle_type right_plus_difference (const rectangle_type &rectangle) const
rectangle_type bottom_plus_difference (const rectangle_type &rectangle) const
rectangle_type & operator= (const rectangle_type &rectangle)=default
bool operator== (const rectangle_type &rectangle) const
template<prototype_integral INTEGRAL>
constexpr bool operator< (INTEGRAL i) const
template<prototype_sequence2 SEQUENCE>
rectangle_type & operator+= (const SEQUENCE &s)
rectangle_type & operator+= (const rectangle_type &rectangle)
rectangle_type & operator*= (const rectangle_type &rectangle)
template<prototype_number NUMBER2>
rectangle_type & operator*= (NUMBER2 n)
template<prototype_number NUMBERN>
rectangle_type & operator-= (const sequence_type< NUMBERN, 2 > &s)
rectangle_type & operator-= (const rectangle_type &rectangle)
rectangle_type & operator&= (const rectangle_type &rectangle)
rectangle_type & operator|= (const rectangle_type &rectangle)
template<prototype_sequence2 SEQUENCE>
rectangle_type operator+ (const SEQUENCE &s) const
template<prototype_sequence2 SEQUENCE>
rectangle_type operator- (const SEQUENCE &s) const
rectangle_type operator+ (const rectangle_type &rectangleAdd) const
rectangle_type operator- (const rectangle_type &rectangleSub) const
rectangle_type operator& (const rectangle_type &rect2) const
rectangle_type operator| (const rectangle_type &rectangleOr) const
rectangle_type & subtract (const rectangle_type &rectangleSrc1, const rectangle_type &rectangleSrc2)
void normalize ()
template<prototype_rectangle RECTANGLE>
void inflate (const RECTANGLE &rectangle)
void inflate (UNIT_TYPE l, UNIT_TYPE t, UNIT_TYPE r, UNIT_TYPE b)
template<prototype_rectangle RECTANGLE>
void deflate (const RECTANGLE &rectangle)
void deflate (UNIT_TYPE l, UNIT_TYPE t, UNIT_TYPE r, UNIT_TYPE b)
UNIT_TYPE area () const
void rate (::f64 d)
rectangle_type operator* (::f64 d) const
void DeflateBottomRightSizeByRate (::f64 dRate)
void SetBottomRightSize (UNIT_TYPE iWidth, UNIT_TYPE iHeight)
void SetBottomRightSize (const SIZE_TYPE &size)
void ExtendOnCenter (const rectangle_type &rectangle)
void FitOnCenterOf (const rectangle_type &rectangle, const SIZE_TYPE &size)
void FitOnCenterOf (const rectangle_type &rectangle)
void CenterOf (const rectangle_type &rectangle, const SIZE_TYPE &size)
void CenterOf (const rectangle_type &rectangle)
void ScaleRect (::f64 Δx, ::f64 Δy, UNIT_TYPE ix, UNIT_TYPE iy)
void ScaleHeightAspect (UNIT_TYPE iNewHeight, UNIT_TYPE iCenterX, UNIT_TYPE iCenterY)
void Align (::e_align ealign, const rectangle_type &rectangle)
void _001Align (::f64 x, ::f64 y, const rectangle_type &rectangle)
void _001AlignX (::f64 dRate, const rectangle_type &rectangle)
void _001AlignY (::f64 dRate, const rectangle_type &rectangle)
::f64_size aspect_size (const rectangle_type &rectangle) const
void aspect_fit (const rectangle_type &rectangle)
void aspect_align_fit (::f64 x, ::f64 y, const rectangle_type &rectangle)
void align_rate (::f64 x, ::f64 y, const rectangle_type &rectangle)
void align_x (::f64 dRate, const rectangle_type &rectangle)
void align_y (::f64 dRate, const rectangle_type &rectangle)
void _005Constrain (const rectangle_type &rectangle, const SIZE_TYPE &sizeMin)
void _007Constrain (const rectangle_type &rectangle)
void _001Constrain (const rectangle_type &rectangle)
void _001ConstrainX (const rectangle_type &rectangle)
void _001ConstrainY (const rectangle_type &rectangle)
template<prototype_rectangle RECTANGLE>
void _001Constrain (const rectangle_type &rectangle, RECTANGLE &rectangleBounding)
template<prototype_rectangle RECTANGLE>
void _001ConstrainX (const rectangle_type &rectangle, RECTANGLE &rectangleBounding)
template<prototype_rectangle RECTANGLE>
void _001ConstrainY (const rectangle_type &rectangle, RECTANGLE &rectangleBounding)
template<prototype_rectangle RECTANGLE>
bool contains (const RECTANGLE &rectangle) const
void SubtractRectMajor (const rectangle_type &rectangleMajor, const rectangle_type &rectangleMinor)
UNIT_TYPE minimum_signed_absolute_dimension (bool bNegativePreference=true) const
UNIT_TYPE maximum_signed_absolute_dimension (bool bPositivePreference=true) const
void assign (const rectangle_type &rectangle, enum_orientation eorientation)
void assign_normal (const rectangle_type &rectangle, enum_orientation eorientation)
bool operator== (nullptr_t) const
template<prototype_size SIZE>
bool operator== (const SIZE &size) const
template<prototype_size SIZE>
bool operator!= (const SIZE &size) const
template<prototype_size SIZE>
bool operator> (const SIZE &size) const
template<prototype_size SIZE>
bool operator>= (const SIZE &size) const
template<prototype_size SIZE>
bool operator< (const SIZE &size) const
template<prototype_size SIZE>
bool operator<= (const SIZE &size) const
template<prototype_size SIZE>
bool any_gt (const SIZE &size) const
template<prototype_size SIZE>
bool any_ge (const SIZE &size) const
template<prototype_size SIZE>
bool any_lt (const SIZE &size) const
template<prototype_size SIZE>
bool any_le (const SIZE &size) const
void maximum_minimum ()
void expand_bounding_box (POINT_TYPE &top_left, POINT_TYPE &bottom_right) const
template<prototype_array ARRAY>
ARRAY & add_clockwise_edges (ARRAY &a) const
template<prototype_array ARRAY>
ARRAY & set_clockwise_edges (ARRAY &a, ::collection::index iOffset=0) const
void rotateOn90InsideDimension (NUMBER dimHeight)
void rotateOn180InsideDimension (NUMBER dimWidth, NUMBER dimHeight)
void rotateOn270InsideDimension (NUMBER dimWidth)
Public Member Functions inherited from sequence_type< NUMBER, 4 >
sequence_type< NUMBER, t_iSize > operator* (const matrix_type< FLOATING1, 3 > &M) const
sequence_type< NUMBER, t_iSize > operator* (const matrix_type< FLOATING1, 4 > &M) const
constexpr ::collection::count get_size () const
constexpr ::collection::count get_count () const
void set_null ()
sequence_type & null ()
constexpr COORDINATE & set_coordinate (::collection::index i, COORDINATE coordinate)
constexpr COORDINATE coordinate (::collection::index i) const
void set_all (COORDINATE coordinate)
bool is_all (COORDINATE coordinate) const
void add2 (const sequence_type &a)
void sub2 (const sequence_type &a)
void mul2 (UNIT_TYPE n)
void set2 (UNIT_TYPE a, UNIT_TYPE b)
void add3 (const sequence_type &a)
void sub3 (const sequence_type &a)
void mul3 (UNIT_TYPE n)
void set3 (UNIT_TYPE a, UNIT_TYPE b, UNIT_TYPE c)
void add4 (const sequence_type &q)
void sub4 (const sequence_type &q)
void mul4 (UNIT_TYPE n)
void set4 (UNIT_TYPE a, UNIT_TYPE b, UNIT_TYPE c, UNIT_TYPE d)
sequence_type operator- () const
sequence_type operator+ (const sequence_type &b) const
sequence_type & operator+= (const sequence_type &a)
sequence_type & operator-= (const sequence_type &a)
sequence_type & operator*= (const sequence_type &a)
sequence_type & operator/= (const sequence_type &a)
bool operator== (const sequence_type &a) const
bool is_every (PREDICATE predicate) const
bool is_empty () const
bool is_set () const
bool is_all_set () const
bool is_all_positive () const
sequence_type prefer_self_coordinate_if (const sequence_type &vectorOther, PREDICATE predicate) const
sequence_type prefer_self_coordinate_if_set (const sequence_type &vectorOther) const
sequence_type prefer_self_coordinate_if_positive (const sequence_type &vectorOther) const
sequence_type pred_prefer_self_coordinate_if (PREDICATE predicate, SOURCE_PREDICATE sourcepredicate) const
sequence_type pred_prefer_self_coordinate_if_set (SOURCE_PREDICATE sourcepredicate) const
sequence_type pred_prefer_self_coordinate_if_positive (SOURCE_PREDICATE sourcepredicate) const
constexpr bool operator!= (const sequence_type &a) const
constexpr const COORDINATE & operator[] (::collection::count i) const
COORDINATE dot_with_left_perpendicular_of (const sequence_type &b)
COORDINATE angle (const sequence_type &b)
sequence_type maximum (const sequence_type &vector) const
sequence_type minimum (const sequence_type &vector) const
sequence_type & operator= (const sequence_type &sequence)
COORDINATE dotted (const sequence_type &vector) const
sequence_type make_unitary () const
const UNIT_TYPE & get_dimension (enum_orientation eorientation) const
const UNIT_TYPE & get_normal_dimension (enum_orientation eorientation) const
UNIT_TYPE & set_dimension (enum_orientation eorientation, UNIT_TYPE l) noexcept
UNIT_TYPE & set_orthogonal_dimension (enum_orientation eorientation, UNIT_TYPE l) noexcept
sequence_type< COORDINATE, 3 > crossed (const sequence_type< COORDINATE, 3 > &b) const
NUMBER squared_modulus () const
NUMBER modulus () const
NUMBER length () const
NUMBER distance (const sequence_type &b) const
sequence_type & normalize ()
sequence_type normalized () const
sequence_type mix (const sequence_type &b, FLOATING t) const
constexpr sequence_type front_right (const sequence_type &sequence3WorldUp)
constexpr sequence_type right_up (const sequence_type &front)
sequence_type cos () const
sequence_type sin () const
auto as_translation_matrix () const
auto as_scaling_matrix () const

Static Public Member Functions

static bool contains (const ::point_type< NUMBER > &center, const ::size_type< NUMBER > &radius, const ::point_type< NUMBER > &point)
Static Public Member Functions inherited from rectangle_type< NUMBER >
static rectangle_type with_center_and_half_size (const POINT_TYPE &center, const SIZE_TYPE &halfsize)
static rectangle_type square_with_center_and_apothem (const POINT_TYPE &center, const UNIT_TYPE &apothem)
Static Public Member Functions inherited from sequence_type< NUMBER, 4 >
static sequence_type Null ()
static void mix2 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
static void mix3 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
static void mix4 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)

Additional Inherited Members

Public Types inherited from rectangle_type< NUMBER >
using UNIT_TYPE = NUMBER
using POINT_TYPE = point_type < NUMBER >
using SIZE_TYPE = size_type < NUMBER >
Public Types inherited from sequence_type< NUMBER, 4 >
using sequence_tag
using sequence_size
using SEQUENCE_T
using COORDINATE
using UNIT_TYPE
Public Types inherited from sequence_t_type< NUMBER, t_iSize >
using sequence_tag = sequence_t
using sequence_size = sequence_size_t<t_iSize>
using COORDINATE = NUMBER
using UNIT_TYPE = NUMBER
Static Public Attributes inherited from sequence_type< NUMBER, 4 >
static const ::i32 SIZE
static constexpr bool IS_MATRIX
Static Public Attributes inherited from sequence_t_type< NUMBER, t_iSize >
static const ::i32 SIZE = t_iSize

The documentation for this class was generated from the following files: