acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
sequence_type< NUMBER, t_iSize > Struct Template Reference
Inheritance diagram for sequence_type< NUMBER, t_iSize >:
sequence_t_type< NUMBER, t_iSize >

Public Types

using sequence_tag = sequence_t
using sequence_size = sequence_size_t < t_iSize >
using SEQUENCE_T = sequence_t_type< NUMBER, t_iSize >
using COORDINATE = typename SEQUENCE_T::COORDINATE
using UNIT_TYPE = typename SEQUENCE_T::COORDINATE
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

Public Member Functions

 sequence_type (no_initialize_t)
constexpr sequence_type (UNIT_TYPE n)
template<prototype_sequence2 S2>
requires (SIZE == 2)
constexpr sequence_type (const S2 &s2)
template<prototype_sequence3 S3>
requires (SIZE == 3)
constexpr sequence_type (const S3 &s3)
template<prototype_sequence4 S4>
requires (SIZE >= 4)
constexpr sequence_type (const S4 &s4)
template<prototype_number NUMBER1>
constexpr sequence_type (const NUMBER1 *p)
template<prototype_number NUMBER1>
requires (SIZE >= 4)
constexpr sequence_type (const sequence_t_type< NUMBER1, 4 > &sequence)
template<prototype_number NUMBER0, prototype_number NUMBER1>
requires (SIZE == 2)
constexpr sequence_type (NUMBER0 coordinate0, NUMBER1 coordinate1)
template<prototype_number NUMBER0, prototype_number NUMBER1, prototype_number NUMBER2>
requires (SIZE == 3)
constexpr sequence_type (NUMBER0 coordinate0, NUMBER1 coordinate1, NUMBER2 coordinate2)
template<prototype_number NUMBER0, prototype_number NUMBER1, prototype_number NUMBER2, prototype_number NUMBER3>
requires (SIZE == 4)
constexpr sequence_type (NUMBER0 coordinate0, NUMBER1 coordinate1, NUMBER2 coordinate2, NUMBER3 coordinate3)
template<prototype_number NUMBER0, prototype_number NUMBER3>
requires (SIZE == 4)
constexpr sequence_type (const sequence_type< NUMBER0, 3 > &seq3, NUMBER3 coordinate3)
template<prototype_number NUMBER0, prototype_number NUMBER1>
requires (SIZE == 4)
constexpr sequence_type (NUMBER0 coordinate0, const sequence_type< NUMBER1, 3 > &seq3)
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
constexpr COORDINATE & coordinate (::collection::index i)
void set_all (COORDINATE coordinate)
bool is_all (COORDINATE coordinate) const
template<::collection::count S = SIZE>
void add2 (const sequence_type &a)
template<::collection::count S = SIZE>
void sub2 (const sequence_type &a)
template<::collection::count S = SIZE>
void mul2 (UNIT_TYPE n)
template<::collection::count S = SIZE>
void set2 (UNIT_TYPE a, UNIT_TYPE b)
template<::collection::count S = SIZE>
void add3 (const sequence_type &a)
template<::collection::count S = SIZE>
void sub3 (const sequence_type &a)
template<::collection::count S = SIZE>
void mul3 (UNIT_TYPE n)
template<::collection::count S = SIZE>
void set3 (UNIT_TYPE a, UNIT_TYPE b, UNIT_TYPE c)
template<::collection::count S = SIZE>
void add4 (const sequence_type &q)
template<::collection::count S = SIZE>
void sub4 (const sequence_type &q)
template<::collection::count S = SIZE>
void mul4 (UNIT_TYPE n)
template<::collection::count S = SIZE>
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 &b) const
template<prototype_floating FLOATING1>
requires (t_iSize == 3 && ::std::is_same_v<FLOATING1, NUMBER>)
sequence_type operator* (const matrix_type< FLOATING1, 3 > &M) const
template<prototype_floating FLOATING1>
requires (t_iSize == 4 && ::std::is_same_v<FLOATING1, NUMBER>)
sequence_type operator* (const matrix_type< FLOATING1, 4 > &M) const
template<prototype_number NUMBER1>
sequence_type< largest_number< UNIT_TYPE, NUMBER1 >, SIZE > operator* (NUMBER1 n) const
sequence_type & operator*= (const sequence_type &a)
template<prototype_number NUMBER1>
sequence_type< largest_number< UNIT_TYPE, NUMBER1 >, SIZE > operator/ (NUMBER1 n) const
sequence_type & operator/= (const sequence_type &a)
template<prototype_number NUMBER1>
sequence_type & operator/= (const NUMBER1 &n)
bool operator== (const sequence_type &a) const
template<typename PREDICATE>
bool is_every (PREDICATE predicate) const
bool is_empty () const
bool is_set () const
bool is_all_set () const
bool is_all_positive () const
template<typename PREDICATE>
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
template<typename PREDICATE, typename SOURCE_PREDICATE>
sequence_type pred_prefer_self_coordinate_if (PREDICATE predicate, SOURCE_PREDICATE sourcepredicate) const
template<typename SOURCE_PREDICATE>
sequence_type pred_prefer_self_coordinate_if_set (SOURCE_PREDICATE sourcepredicate) const
template<typename SOURCE_PREDICATE>
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
constexpr COORDINATE & operator[] (::collection::count i)
template<::collection::count S = SIZE, std::enable_if_t<(S==2), ::i32 > = 0>
COORDINATE dot_with_left_perpendicular_of (const sequence_type &b)
template<::collection::count S = SIZE, std::enable_if_t<(S==2), ::i32 > = 0>
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)
UNIT_TYPE minimum () const
UNIT_TYPE maximum () const
COORDINATE dotted (const sequence_type &vector) const
sequence_type make_unitary () const
const UNIT_TYPE & get_dimension (enum_orientation eorientation) const
UNIT_TYPE & get_dimension (enum_orientation eorientation)
template<::collection::count S = SIZE, std::enable_if_t< S==2, ::i32 > = 0>
const UNIT_TYPE & get_normal_dimension (enum_orientation eorientation) const
template<::collection::count S = SIZE, std::enable_if_t< S==2, ::i32 > = 0>
UNIT_TYPE & get_normal_dimension (enum_orientation eorientation)
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 squared_modulus () 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
template<prototype_floating FLOATING>
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
template<prototype_floating FLOATING1>
requires (t_iSize == 3 && std::is_same_v < FLOATING1, NUMBER >)
sequence_type< NUMBER, t_iSize > operator* (const matrix_type< FLOATING1, 3 > &M) const
template<prototype_floating FLOATING1>
requires (t_iSize == 4 && ::std::is_same_v<FLOATING1, NUMBER>)
sequence_type< NUMBER, t_iSize > operator* (const matrix_type< FLOATING1, 4 > &M) const

Static Public Member Functions

static sequence_type Null ()
template<::collection::count S = SIZE>
static void mix2 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
template<::collection::count S = SIZE>
static void mix3 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
template<::collection::count S = SIZE>
static void mix4 (const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)

Static Public Attributes

static const ::i32 SIZE = t_iSize
static constexpr bool IS_MATRIX = false
Static Public Attributes inherited from sequence_t_type< NUMBER, t_iSize >
static const ::i32 SIZE = t_iSize

Friends

sequence_type operator- (const sequence_type &a, const sequence_type &b)
sequence_type operator/ (const sequence_type &a, const sequence_type &b)

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