|
| float | sin (const An &ang) |
| |
| float | cos (const An &ang) |
| |
| float | tan (const An &ang) |
| |
| An | asin (float v) |
| |
| An | acos (float v) |
| |
| An | atan (float v) |
| |
| An | atan2 (float y, float x) |
| |
| An | operator+ (const An &lhs, const An &rhs) |
| |
| An | operator- (const An &lhs, const An &rhs) |
| |
| An | operator* (const An &lhs, float rhs) |
| |
| An | operator/ (const An &lhs, float rhs) |
| |
| An | operator* (float rhs, const An &lhs) |
| |
| std::string | string_from (const An &a) |
| |
| bool | operator< (const An &lhs, const An &rhs) |
| |
| bool | operator<= (const An &lhs, const An &rhs) |
| |
| bool | operator> (const An &lhs, const An &rhs) |
| |
| bool | operator>= (const An &lhs, const An &rhs) |
| |
| An | lerp_angle (const An &from, float v, const An &to) |
| |
| AA | rha (const n3 &axis, const An &angle) |
| |
| std::string | string_from (const AA &aa) |
| |
| std::string | string_from (const Ypr &ypr) |
| |
| constexpr float | float_from_int (int i) |
| |
| constexpr int | int_from_float (float f) |
| |
| constexpr std::size_t | sizet_from_int (int i) |
| |
| constexpr u32 | u32_from_sizet (std::size_t i) |
| |
| constexpr int | int_from_sizet (std::size_t i) |
| |
| constexpr int | int_from_unsigned_int (unsigned int i) |
| |
| float | linear_from_srgb (float value, float gamma) |
| |
| Lin_rgb | linear_from_srgb (const Rgb &value, float gamma) |
| |
| float | linear_from_srgb (float value) |
| |
| Lin_rgb | linear_from_srgb (const Rgb &value) |
| |
| float | srgb_from_linear (float value) |
| |
| Rgb | srgb_from_linear (const Lin_rgb &value) |
| |
| OkLab | oklab_from_linear (const Lin_rgb &c) |
| |
| Lin_rgb | linear_from_oklab (const OkLab &c) |
| |
| OkLch | oklch_from_oklab (const OkLab &c) |
| |
| OkLab | oklab_from_oklch (const OkLch &c) |
| |
| Lin_rgb | gamut_clip_preserve_chroma (const Lin_rgb &rgb) |
| |
| Lin_rgb | gamut_clip_project_to_0_5 (const Lin_rgb &rgb) |
| |
| Lin_rgb | gamut_clip_project_to_l_cusp (const Lin_rgb &rgb) |
| |
| Lin_rgb | gamut_clip_adaptive_L0_0_5 (const Lin_rgb &rgb, float alpha=0.05f) |
| |
| Lin_rgb | gamut_clip_adaptive_l0_l_cusp (const Lin_rgb &rgb, float alpha=0.05f) |
| |
| Rgb | srgb_from_okhsv (const OkHsv &hsv) |
| |
| OkHsv | okhsv_from_srgb (const Rgb &rgb) |
| |
| Rgb | srgb_from_okhsl (const OkHsl &hsl) |
| |
| OkHsl | okhsl_from_srgb (const Rgb &rgb) |
| |
| Rgb | srgb_from_hsl (const Hsl &hsl) |
| |
| Lin_rgb | keep_within (Lin_rgb c) |
| |
| bool | operator== (const Guid &lhs, const Guid &rhs) |
| |
| bool | operator!= (const Guid &lhs, const Guid &rhs) |
| |
| std::optional< Guid > | guid_from (const std::string &str) |
| | Parse a guid from a string.
|
| |
| std::string | string_from (const Guid &g) |
| | Convert a guid to a string representation, prefer fmt.
|
| |
| constexpr u64 | hash64 (const std::string_view str, u64 hash=0xcbf29ce484222325) |
| | fnv-1a hash.
|
| |
| | OP (==) OP(! |
| |
| std::string | string_from (const HshO &h) |
| |
| std::string | string_from (const m4 &m) |
| | Convert a matrix to a string representation, prefer fmt.
|
| |
| m4 | operator+ (const m4 &lhs, const m4 &rhs) |
| |
| m4 | operator- (const m4 &lhs, const m4 &rhs) |
| |
| m4 | operator* (const m4 &lhs, const m4 &rhs) |
| |
| v4 | operator* (const m4 &lhs, const v4 &rhs) |
| |
| MemoryChunkData | chunk_from_file (const std::string &path) |
| |
| constexpr float | cabs (float r) |
| |
| constexpr bool | is_zero (float r, float epsilon=kk::epsilon) |
| |
| constexpr bool | is_equal (float lhs, float rhs, float epsilon=kk::epsilon) |
| |
| int | floor_to_int (float v) |
| |
| int | ceil_to_int (float v) |
| |
| constexpr int | get_sign (float r) |
| | Calculates the sign as a positive or a negative int.
|
| |
| constexpr float | get_sign (bool b) |
| | Returns 1 if true or -1.
|
| |
| constexpr float | lerp_float (float f, float scale, float t) |
| |
| constexpr float | square (float r) |
| | Return r * r
|
| |
| constexpr float | min (float lhs, float rhs) |
| |
| constexpr float | max (float lhs, float rhs) |
| |
| constexpr float | clamp_zero (float value, float def=0.0f, float epsilon=kk::epsilon) |
| | If the value is close to zero, def is returned.
|
| |
| constexpr float | keep_within01 (float f) |
| |
| float | dot (const Q &lhs, const Q &rhs) |
| |
| std::string | string_from (const Q &v) |
| | Converts a quaternion to string, prefer fmt.
|
| |
| Q | operator* (const Q &lhs, const Q &rhs) |
| |
| Q | operator* (float scale, const Q &q) |
| |
| Q | operator* (const Q &q, float scale) |
| |
| template<typename T > |
| R< T > | make_range (T min, T max) |
| | Create a range from min to max (inclusive)
|
| |
| template<typename T > |
| R< T > | make_range (T max) |
| | Create a range from zero (0) to max (inclusive)
|
| |
| float | from_01f (float lower_bound, float upper_bound, float value) |
| |
| template<typename T > |
| T | from_01 (const R< T > &range, float value) |
| | Converts a value in 0-1 range to a custom range.
|
| |
| template<> |
| float | from_01 (const R< float > &range, float value) |
| |
| template<typename T > |
| float | to01 (const R< T > &range, T value) |
| | Converts a value in a range to the 0-1 range.
|
| |
| template<typename T > |
| T | get360_angular (const R< T > &range, float value) |
| |
| template<typename T , typename F > |
| T | remap_to (const R< F > &from, const R< T > &to, F value) |
| | Remaps a value from one range to another.
|
| |
| template<typename T > |
| bool | is_within (const R< T > &range, T value) |
| | Returns true if a value is withing a range.
|
| |
| template<typename T > |
| T | keep_within (const R< T > &range, T value) |
| | Returns a value that is kept within the range.
|
| |
| template<typename T > |
| T | wrap (const R< T > &range, T value) |
| | Returns a value that wraps around the range.
|
| |
| v2 | to_01 (const Rect &r, const v2 &from) |
| |
| v2 | from_01 (const Rect &r, const v2 &from) |
| |
| bool | is_within (const v2 &p, const Rect &r) |
| | is the point contained within the rect?
|
| |
| std::string | to_string (const Rect &r) |
| |
| constexpr bool | operator== (const Size &lhs, const Size &rhs) |
| |
| std::string | string_from (const Size &v) |
| | converts a 2d unit vector to a string, prefer fmt
|
| |
| v2 | operator+ (const v2 &lhs, const v2 &rhs) |
| |
| v2 | operator- (const v2 &lhs, const v2 &rhs) |
| |
| v2 | operator* (const v2 &lhs, float rhs) |
| |
| v2 | operator* (const v2 &lhs, const v2 &rhs) |
| |
| v2 | operator* (float lhs, const v2 &rhs) |
| |
| v2 | operator* (const n2 &lhs, float rhs) |
| |
| v2 | operator* (float lhs, const n2 &rhs) |
| |
| v2 | operator/ (const v2 &lhs, float rhs) |
| |
| float | dot (const v2 &lhs, const v2 &rhs) |
| |
| v2 | lerp_vec2f (const v2 &from, float v, const v2 &to) |
| |
| std::string | string_from (const v2 &v) |
| | converts a 2d vector to a string, prefer fmt
|
| |
| std::string | string_from (const n2 &v) |
| | converts a 2d unit vector to a string, prefer fmt
|
| |
| v3 | operator+ (const v3 &lhs, const v3 &rhs) |
| |
| v3 | operator- (const v3 &lhs, const v3 &rhs) |
| |
| v3 | operator* (float lhs, const v3 &rhs) |
| |
| v3 | operator* (const v3 &lhs, float rhs) |
| |
| v3 | operator/ (const v3 &lhs, float rhs) |
| |
| v3 | operator/ (float lhs, const v3 &rhs) |
| |
| v3 | lerp_v3 (const v3 &f, float v, const v3 &t) |
| |
| std::string | string_from (const v3 &v) |
| | convert a 3d vector to string, prefer fmt
|
| |
| std::string | string_from (const n3 &v) |
| | converts a 3d unit vector to string, prefer fmt
|
| |
| constexpr v3 | min (const v3 &lhs, const v3 &rhs) |
| | component wise min value
|
| |
| constexpr v3 | max (const v3 &lhs, const v3 &rhs) |
| | component wise max value
|
| |
| std::string | string_from (const v4 &v) |
| | converts a 4d vector to a string, prefer fmt
|
| |
