|
std::string | to_string (const Aabb &a) |
|
vec3f | get_random_point (Random *rand, const Aabb &a) |
|
Angle | get_random_angle (::eu::Random *random) |
|
float | sin (const Angle &ang) |
|
float | cos (const Angle &ang) |
|
float | tan (const Angle &ang) |
|
Angle | asin (float v) |
|
Angle | acos (float v) |
|
Angle | atan (float v) |
|
Angle | atan2 (float y, float x) |
|
Angle | operator+ (const Angle &lhs, const Angle &rhs) |
|
Angle | operator- (const Angle &lhs, const Angle &rhs) |
|
Angle | operator/ (const Angle &lhs, float rhs) |
|
Angle | operator* (const Angle &lhs, float rhs) |
|
Angle | operator* (float rhs, const Angle &lhs) |
|
std::string | to_string (const Angle &a) |
|
bool | operator< (const Angle &lhs, const Angle &rhs) |
|
bool | operator<= (const Angle &lhs, const Angle &rhs) |
|
bool | operator> (const Angle &lhs, const Angle &rhs) |
|
bool | operator>= (const Angle &lhs, const Angle &rhs) |
|
Angle | lerp_angle (const Angle &from, float v, const Angle &to) |
|
| DEFAULT_INTERPOLATE (Angle, lerp_angle) |
|
std::string | to_string (const AxisAngle &aa) |
|
int | c_sizet_to_int (size_t t) |
|
int | c_unsigned_int_to_int (unsigned int i) |
|
unsigned int | c_int_to_unsigned_int (int i) |
|
size_t | c_int_to_sizet (int i) |
|
U8 | c_int_to_u8 (unsigned int i) |
|
int | c_u64_to_int (U64 u) |
|
constexpr int | c_float_to_int (float f) |
|
constexpr float | c_sizet_to_float (std::size_t f) |
|
constexpr float | c_int_to_float (int i) |
|
constexpr float | c_u64_to_float (U64 i) |
|
constexpr U32 | c_bit_signed_to_unsigned (I32 i) |
|
constexpr double | c_float_to_double (float f) |
|
constexpr float | c_double_to_float (double f) |
|
template<typename T > |
T | default_interpolate (const T &from, float t, const T &to) |
|
std::string | add_quotes_and_combine_with_english_or (const std::vector< std::string > &matches) |
|
template<typename T , std::enable_if_t< StringParser< T >::value !=0, int > = 0> |
Result< T > | default_parse_function (const std::string &value) |
|
template<typename T , std::enable_if_t< std::is_enum< T >::value==false, int > = 0> |
std::optional< std::string > | default_describe () |
|
template<typename T , std::enable_if_t< StringParser< T >::value !=0, int > = 0> |
std::string | from_default_value_to_string (const T &t) |
|
int | calc_edit_distance (const std::string &source, const std::string &target) |
|
int | calc_edit_distance_fast (const std::string &the_row, const std::string &the_col) |
|
template<typename T > |
std::string | from_enum_to_string (T t) |
|
template<typename T > |
EnumToStringImplementation< T > | get_enum_to_string_implementation_from_enum () |
|
template<typename T > |
MatchedEnum< T > | from_string_to_enum (const std::string &input, size_t max_size=5) |
|
template<typename T > |
std::vector< std::string > | from_enum_to_string (const std::vector< T > &ts) |
|
template<typename T > |
std::vector< std::string > | get_all_names_from_enum () |
|
template<typename T > |
std::vector< T > | get_all_values_from_enum () |
|
template<typename A , typename B > |
std::vector< std::pair< A, B > > | zip (const std::vector< A > &as, const std::vector< B > &bs) |
|
template<typename A , typename B > |
std::vector< std::pair< A, B > > | zip_longest (const std::vector< A > &as, const std::vector< B > &bs, A da=A(), B db=B()) |
|
template<typename T , typename F = T, typename C > |
std::vector< T > | map (const std::vector< F > &fs, C convert) |
|
template<typename T , typename K , typename V , typename C > |
std::vector< T > | map (const std::map< K, V > &fs, C convert) |
|
template<typename T , typename C > |
std::vector< T > | filter (const std::vector< T > &ts, C check) |
|
template<typename T , typename C > |
bool | all (const std::vector< T > &ts, C check) |
|
template<typename T , typename C > |
bool | any (const std::vector< T > &ts, C check) |
|
template<typename T , typename R = T, typename C > |
R | fold (const std::vector< T > &ts, C concat, R zero) |
|
template<typename T > |
bool | operator== (const Lrud< T > &lhs, const Lrud< T > &rhs) |
|
template<typename T > |
bool | operator!= (const Lrud< T > &lhs, const Lrud< T > &rhs) |
|
std::string | to_string (const mat2f &m) |
|
mat2f | operator+ (const mat2f &lhs, const mat2f &rhs) |
|
mat2f | operator- (const mat2f &lhs, const mat2f &rhs) |
|
float | get_component_multiply_sum (const vec2f &lhs, const vec2f &rhs) |
|
mat2f | operator* (const mat2f &lhs, const mat2f &rhs) |
|
vec2f | operator* (const mat2f &lhs, const vec2f &rhs) |
|
std::string | to_string (const mat3f &m) |
|
mat3f | operator+ (const mat3f &lhs, const mat3f &rhs) |
|
mat3f | operator- (const mat3f &lhs, const mat3f &rhs) |
|
float | get_component_multiply_sum (const vec3f &lhs, const vec3f &rhs) |
|
mat3f | operator* (const mat3f &lhs, const mat3f &rhs) |
|
vec3f | operator* (const mat3f &lhs, const vec3f &rhs) |
|
std::string | to_string (const mat4f &m) |
|
mat4f | operator+ (const mat4f &lhs, const mat4f &rhs) |
|
mat4f | operator- (const mat4f &lhs, const mat4f &rhs) |
|
float | get_component_multiply_sum (const vec4f &lhs, const vec4f &rhs) |
|
mat4f | operator* (const mat4f &lhs, const mat4f &rhs) |
|
vec4f | operator* (const mat4f &lhs, const vec4f &rhs) |
|
void | copy_to_memory (MemoryChunk *memory, const void *src) |
|
std::shared_ptr< MemoryChunk > | create_memory_chunk_from_string (const std::string &content) |
|
template<std::size_t count, typename T , typename TContainer , typename TExtract > |
std::pair< std::array< T, count >, std::array< T, count > > | find_min_max_ranges (const TContainer &ts, TExtract extract) |
|
template<typename T , typename TContainer , typename TExtract > |
Range< T > | find_min_max_range (const TContainer &ts, TExtract extract) |
|
template<typename T , typename TContainer , typename TMinFunc , typename TMaxFunc > |
std::tuple< T, T > | find_min_max (const TContainer &ts, TMinFunc min_func, TMaxFunc max_func) |
|
bool | is_equal (int lhs, int rhs) |
|
bool | is_zero (int r) |
|
float | clamp_zero (float r) |
|
float | floor (float v) |
|
float | ceil (float v) |
|
int | floor_to_int (float v) |
|
int | ceil_to_int (float v) |
|
int | get_sign (float r) |
| Calculates the sign as a positive or a negative int. More...
|
|
int | get_sign (int r) |
|
float | get_sign (bool b) |
| Returns either 1 or -1. More...
|
|
float | lerp_float (float f, float scale, float t) |
|
float | square (float r) |
|
float | sqrt (float r) |
|
float | mod (float numer, float denumer) |
|
bool | is_within_inclusive_as_int (int min, int c, int max) |
|
float | round (float num, float gran) |
| Rounds a value to the nearest nice value. More...
|
|
constexpr float | abs (float r) |
|
constexpr bool | is_zero (float r) |
|
constexpr bool | is_equal (float lhs, float rhs) |
|
| DEFAULT_INTERPOLATE (float, lerp_float) |
|
template<typename T > |
T | get_default_if_close_to_zero (T value, T def, T epsilon) |
|
template<typename I > |
constexpr bool | is_each_nth (I i, I each) |
| returns true for a index each Nth loop. More...
|
|
std::optional< int > | locale_parse_int (const std::string &str) |
|
std::optional< float > | locale_parse_float (const std::string &str) |
|
std::optional< bool > | locale_parse_bool (const std::string &str) |
|
template<typename T > |
std::optional< T > | locale_parse_generic (const std::string &str) |
|
std::string | get_current_directory () |
|
DirectoryListing | list_directory (const std::string &path) |
|
bool | ends_with (const std::string &str, char c) |
|
std::string | join_path (const std::string &left, const std::string &right) |
|
std::string | get_extension (const std::string &path) |
|
std::string | get_file_name_including_extension (const std::string &path) |
|
std::string | get_file_name_without_extension (const std::string &path) |
|
unit3f | get_random_unit3 (Random *random) |
|
quatf | lerp_quatf (const quatf &f, const float scale, const quatf &t) |
|
quatf | slerp_fast (const quatf &qa, const float t, const quatf &qb) |
|
quatf | slerp_shortway (const quatf &from, const float scale, const quatf &to) |
|
std::string | to_string (const quatf &v) |
|
float | dot (const quatf &lhs, const quatf &rhs) |
|
quatf | operator* (const quatf &lhs, const quatf &rhs) |
|
quatf | operator* (float scale, const quatf &q) |
|
quatf | operator* (const quatf &q, float scale) |
|
quatf | operator+ (const quatf &lhs, const quatf &rhs) |
|
quatf | operator- (const quatf &lhs, const quatf &rhs) |
|
| DEFAULT_INTERPOLATE (quatf, slerp_shortway) |
|
float | get_random_gaussian_float01 (Random *rand) |
|
float | get_random_gaussian (Random *rand, float mean, float std_dev) |
|
float | get_random_gaussian (Random *rand, float mean, float std_dev, const Range< float > &r) |
|
vec2f | get_random_point_on_unit_circle_center_focused (Random *r) |
|
vec2f | get_random_point_on_unit_circle_uniform (Random *r) |
|
template<typename T > |
T | get_random_in_range (Random *rand, const Range< T > &range) |
|
template<typename T > |
T | get_random_in_range (Random *rand, T min, T max) |
|
template<typename T > |
T | get_random_in_range (Random *rand, T max) |
|
template<typename T > |
const T & | get_random_item_in_vector (Random *r, const std::vector< T > &v) |
|
template<typename T > |
const T & | get_random_item_in_vector (Random *r, const ranges::span< T > &v) |
|
float | from_01f (float lower_bound, float upper_bound, float value) |
|
template<> |
float | from_01 (const Range< float > &range, float value) |
|
template<typename T > |
Range< T > | make_range (T min, T max) |
|
template<typename T > |
Range< T > | make_range (T max) |
|
template<typename T > |
Range< int > | make_range (const std::vector< T > &v) |
|
template<typename T > |
T | from_01 (const Range< T > &range, float value) |
|
template<typename T > |
float | to01 (const Range< T > &range, T value) |
|
template<typename T > |
T | get360_angular (const Range< T > &range, float value) |
|
template<typename T , typename F > |
T | remap_to (const Range< F > &from, const Range< T > &to, F value) |
|
template<typename T > |
bool | is_within (const Range< T > &range, T value) |
|
template<typename T > |
T | keep_within (const Range< T > &range, T value) |
|
template<typename T > |
T | wrap (const Range< T > &range, T value) |
|
vec2f | to01 (const Rectf &r, const vec2f &from) |
|
vec2f | from_01 (const Rectf &r, const vec2f &from) |
|
bool | is_within (const Rectf &r, const vec2f &p) |
|
std::string | to_string (const Rectf &r) |
|
vec2f | to01 (const Recti &r, const vec2i &from) |
|
vec2i | from_01 (const Recti &r, const vec2f &from) |
|
bool | is_within (const Recti &r, const vec2i &p) |
|
bool | operator== (const Recti &lhs, const Recti &rhs) |
|
std::string | to_string (const Recti &r) |
|
vec2f | get_random_point (Random *random, const Rectf &r) |
|
vec2i | get_random_point (Random *random, const Recti &r) |
|
Rgb | operator+ (const Rgb &lhs, const Rgb &rhs) |
|
Rgb | operator- (const Rgb &lhs, const Rgb &rhs) |
|
Rgb | operator* (const Rgb &lhs, const Rgb &rhs) |
|
Rgb | operator/ (const Rgb &lhs, float rhs) |
|
Rgb | operator* (const Rgb &lhs, float rhs) |
|
Rgb | operator* (float lhs, const Rgb &rhs) |
|
float | dot (const Rgb &lhs, const Rgb &rhs) |
|
Rgb | clamp (const Rgb &c) |
|
std::string | to_string (const Rgbi &c) |
|
std::string | to_string (const Rgbai &c) |
|
std::string | to_string (const Rgb &v) |
|
std::string | to_string (const Rgba &v) |
|
std::string | to_string (const Hsl &v) |
|
bool | operator== (const Rgbi &lhs, const Rgbi &rhs) |
|
bool | operator!= (const Rgbi &lhs, const Rgbi &rhs) |
|
bool | operator== (const Rgbai &lhs, const Rgbai &rhs) |
|
bool | operator!= (const Rgbai &lhs, const Rgbai &rhs) |
|
Rgb | to_rgb (const Rgbi &c) |
|
Rgb | to_rgb (const Rgba &c) |
|
Rgb | to_rgb (const Rgbai &c) |
|
Rgb | to_rgb (const Hsl &hsl) |
|
Hsl | to_hsl (const Rgb &c) |
|
Rgbi | to_rgbi (const Rgb &c) |
|
Rgbi | to_rgbi (const Rgba &c) |
|
Rgbi | to_rgbi (const Rgbai &c) |
|
Rgba | to_rgba (const Rgbai &c) |
|
Rgbai | to_rgbai (const Rgba &c) |
|
Rgb | lerp_rgb (const Rgb &from, float v, const Rgb &to) |
|
std::string | to_js_hex_color (const Rgbi &c) |
|
std::string | to_html_rgb (const Rgbi &c) |
|
Hsl | get_saturated (const Hsl &ahsl, float amount, IsAbsolute method) |
|
Hsl | get_desaturated (const Hsl &ahsl, float amount, IsAbsolute method) |
|
Hsl | get_lightened (const Hsl &ahsl, float amount, IsAbsolute method) |
|
Hsl | get_darkened (const Hsl &ahsl, float amount, IsAbsolute method) |
|
Rgb | get_shaded_color (const Rgb &color, float percentage) |
| Makes a color brighter or darker. More...
|
|
Result< Rgbi > | to_rgbi (const std::string &original_value) |
|
| DEFAULT_INTERPOLATE (Rgb, lerp_rgb) |
|
size2f | min (const size2f lhs, const size2f rhs) |
|
size2f | max (const size2f lhs, const size2f rhs) |
|
size2f | operator+ (const size2f &lhs, const size2f &rhs) |
|
size2f | operator- (const size2f &lhs, const size2f &rhs) |
|
size2f | operator* (const size2f &lhs, float rhs) |
|
size2f | operator* (float lhs, const size2f &rhs) |
|
size2f | operator/ (const size2f &lhs, float rhs) |
|
std::string | to_string (const size2f &r) |
|
size2i | min (const size2i lhs, const size2i rhs) |
|
size2i | max (const size2i lhs, const size2i rhs) |
|
size2i | operator+ (const size2i &lhs, const size2i &rhs) |
|
size2i | operator- (const size2i &lhs, const size2i &rhs) |
|
size2i | operator* (const size2i &lhs, int rhs) |
|
size2i | operator* (int lhs, const size2i &rhs) |
|
std::string | to_string (const size2i &r) |
|
size2f | min (const size2f &lhs, const size2f &rhs) |
|
size2i | min (const size2i &lhs, const size2i &rhs) |
|
size2f | max (const size2f &lhs, const size2f &rhs) |
|
size2i | max (const size2i &lhs, const size2i &rhs) |
|
template<typename T > |
std::string | to_string_for_custom_argparser (const T &t) |
|
template<typename T > |
Result< T > | parse_for_custom_argparser (const std::string &value) |
|
std::pair< std::string, std::string > | get_last_string (const std::string &str, char sep) |
| for hello.dog gets .dog More...
|
|
std::string | get_first_chars (const std::string &str, std::size_t count) |
|
std::string | get_first_chars_with_ellipsis (const std::string &str, unsigned int count) |
|
std::string | strip_last_string (const std::string &str, char sep) |
| for hello.dog and . gets hello More...
|
|
std::string | trim_right (const std::string &string_to_trim, std::string_view trim_characters=space_characters) |
| Remove characters from the right, stops at a invalid character. More...
|
|
std::string | trim_left (const std::string &string_to_trim, std::string_view trim_characters=space_characters) |
| Remove characters from the left, stops at invalid character. More...
|
|
std::string | trim (const std::string &string_to_trim, std::string_view trim_characters=space_characters) |
| Remove characters from both the start and the end. More...
|
|
bool | begins_with (const std::string &string_to_test, const std::string &start) |
| Tests if a string starts with another string. More...
|
|
bool | ends_with (const std::string &string_to_test, const std::string &end) |
| Tests if a string ends with another string. More...
|
|
char | to_lower_char (char b) |
|
char | to_upper_char (char b) |
|
std::string | to_lower (const std::string &str) |
| Generate a string containing only lower characters. More...
|
|
std::vector< std::string > | to_lower (const std::vector< std::string > &str) |
|
std::string | to_upper (const std::string &str) |
|
std::string | from_char_to_string (char c, CharToStringStyle style) |
|
std::string::size_type | find_first_index_of_mismatch (const std::string &lhs, const std::string &rhs) |
|
void | replace_all (std::string *string, const std::string &to_find, const std::string &to_replace) |
| Replace all occurrences in a string. More...
|
|
std::string | replace_all (const std::string &string, const std::string &to_find, const std::string &to_replace) |
| Replace all occurrences in a string. More...
|
|
void | copy (char *dst, const std::string &src, const std::string::size_type &count) |
| Copy a string to a character buffer, adding null terminator at the end. More...
|
|
std::string | replace_with_character (const std::string &string, const std::string &to_find, char to_replace) |
|
std::string | remove_from_end (const std::string &str, const std::string &end) |
|
std::string | strip (const std::string &str, const std::string &ch) |
|
std::string | remove_consecutive (const std::string &str, const std::string &ch) |
|
std::vector< std::string > | split (const std::string &s, char delim) |
|
std::vector< std::string > | split_on_spaces (const std::string &string) |
|
std::string | get_string_or_empty (bool b, const std::string &str) |
|
bool | is_number (char b) |
|
int | parse_number (const char **aa) |
|
int | compare_string (const std::string &lhs, const std::string &rhs) |
|
template<typename TKey , typename TValue > |
std::vector< std::string > | to_string_vector (const std::map< TKey, TValue > &map) |
|
template<typename TKey , typename TValue > |
std::vector< std::string > | from_key_to_string_vector (const std::map< TKey, TValue > &map) |
|
template<typename T > |
std::vector< std::string > | to_string_vector (const std::vector< T > &data) |
|
template<typename T , typename C > |
std::vector< std::string > | to_string_vector (const std::vector< T > &data, C callback) |
|
vec2f | operator+ (const vec2f &lhs, const vec2f &rhs) |
| Math operators. More...
|
|
vec2f | operator- (const vec2f &lhs, const vec2f &rhs) |
|
vec2f | operator* (const vec2f &lhs, float rhs) |
|
vec2f | operator* (float lhs, const vec2f &rhs) |
|
vec2f | operator* (const unit2f &lhs, float rhs) |
|
vec2f | operator* (float lhs, const unit2f &rhs) |
|
vec2f | operator/ (const vec2f &lhs, float rhs) |
|
vec2i | operator+ (const vec2i &lhs, const vec2i &rhs) |
|
vec2i | operator- (const vec2i &lhs, const vec2i &rhs) |
|
vec2i | operator* (const vec2i &lhs, int rhs) |
|
vec2i | operator* (int lhs, const vec2i &rhs) |
|
bool | operator== (const vec2i &lhs, const vec2i &rhs) |
| Equality operators. More...
|
|
bool | operator!= (const vec2i &lhs, const vec2i &rhs) |
|
float | dot (const vec2f &lhs, const vec2f &rhs) |
| Functions. More...
|
|
vec2f | lerp_vec2f (const vec2f &from, float v, const vec2f &to) |
| Transform. More...
|
|
vec2i | lerp_vec2i (const vec2i &from, float v, const vec2i &to) |
|
std::string | to_string (const vec2f &v) |
| Printing. More...
|
|
std::string | to_string (const unit2f &v) |
|
std::string | to_string (const vec2i &v) |
|
unit2f | create_random_unit (Random *random) |
|
| DEFAULT_INTERPOLATE (vec2f, lerp_vec2f) |
|
| DEFAULT_INTERPOLATE (vec2i, lerp_vec2i) |
|
vec3f | operator+ (const vec3f &lhs, const vec3f &rhs) |
| Math operators. More...
|
|
vec3f | operator- (const vec3f &lhs, const vec3f &rhs) |
|
vec3f | operator* (float lhs, const vec3f &rhs) |
|
vec3f | operator* (const vec3f &lhs, float rhs) |
|
vec3f | operator/ (const vec3f &lhs, float rhs) |
|
vec3f | operator/ (float lhs, const vec3f &rhs) |
|
vec3f | lerp_vec3f (const vec3f &f, float v, const vec3f &t) |
| Functions. More...
|
|
std::string | to_string (const vec3f &v) |
| Transformations. More...
|
|
std::string | to_string (const unit3f &v) |
|
std::string | to_string (const Scale3f &v) |
|
constexpr vec3f | min (const vec3f &lhs, const vec3f &rhs) |
|
constexpr vec3f | max (const vec3f &lhs, const vec3f &rhs) |
|
std::string | to_string (const vec4f &v) |
|