|
Unravel Engine C++ Reference
|
Provides a sequence-based action management system for controlling and scheduling actions. More...
Namespaces | |
| namespace | detail |
| namespace | ease |
| namespace | inspector |
| namespace | manager |
| namespace | scope |
Classes | |
| struct | seq_action |
| Represents an action within the sequence management system. Contains lifecycle events and management functions. More... | |
| struct | seq_inspect_info |
| Contains information for inspecting and debugging sequence actions. More... | |
| struct | seq_manager |
| Manages and coordinates multiple sequence actions with scoping, pausing, and updating capabilities. More... | |
| struct | seq_private |
Provides internal utilities for managing seq_action objects. These methods allow for direct control over actions' state, progression, and other properties. More... | |
| struct | seq_scope_policy |
| Defines policies for scoping actions in a sequence. More... | |
| struct | values_t |
Typedefs | |
| using | clock_t = std::chrono::steady_clock |
| Alias for the steady clock used for timing actions. | |
| using | timepoint_t = clock_t::time_point |
| Represents a point in time using the steady clock. | |
| using | duraiton_secs_t = std::chrono::duration<float> |
| Represents a duration in seconds as a floating-point value. | |
| using | duration_t = std::chrono::nanoseconds |
| Represents a duration in nanoseconds. | |
| using | sentinel_t = hpp::sentinel |
| Alias for a sentinel object used for lifecycle management. | |
| using | seq_id_t = size_t |
| Represents a unique identifier for sequence actions. | |
| using | ease_t = std::function<float(float)> |
| Represents an easing function for interpolation. | |
| template<typename T > | |
| using | interpolate_t = std::function<T(const T&, const T&, float, const ease_t&)> |
| Represents a function for interpolating values. | |
Enumerations | |
| enum class | state_t { running , paused , finished } |
| Represents the state of a sequence action. More... | |
Functions | |
| auto | start (seq_action action, const seq_scope_policy &scope_policy={}, hpp::source_location location=hpp::source_location::current()) -> seq_id_t |
| Starts a new action. | |
| void | stop (seq_id_t id) |
| Stops the action associated with the given ID. | |
| void | pause (seq_id_t id) |
| Pauses the action associated with the given ID. | |
| void | resume (seq_id_t id) |
| Resumes the action associated with the given ID. | |
| void | stop_when_finished (seq_id_t id) |
| Marks the action to stop when it finishes. | |
| void | stop_and_finish (seq_id_t id, duration_t finish_after=0ms) |
| Stops the action after a specified duration. | |
| auto | is_stopping (seq_id_t id) -> bool |
| Checks if the action is stopping. | |
| auto | is_running (seq_id_t id) -> bool |
| Checks if the action is running. | |
| auto | is_paused (seq_id_t id) -> bool |
| Checks if the action is paused. | |
| auto | is_finished (seq_id_t id) -> bool |
| Checks if the action has finished. | |
| auto | has_action_with_scope (const std::string &scope_id) -> bool |
| Checks if there is an action associated with the given scope ID. | |
| void | set_speed_multiplier (seq_id_t id, float speed_multiplier=1.0f) |
| Sets the speed multiplier for an action. | |
| auto | get_speed_multiplier (seq_id_t id) -> float |
| Gets the speed multiplier of an action. | |
| auto | get_elapsed (seq_id_t id) -> duration_t |
| Gets the elapsed duration of an action. | |
| void | set_elapsed (seq_id_t id, duration_t duration) |
| Sets the elapsed duration of an action. | |
| auto | get_duration (seq_id_t id) -> duration_t |
| Gets the total duration of an action. | |
| auto | get_overflow (seq_id_t id) -> duration_t |
| Gets the overflow duration of an action. | |
| void | update (seq_id_t id, duration_t duration) |
| Updates the elapsed duration of a specific action. | |
| auto | get_percent (seq_id_t id) -> float |
| Gets the percentage completion of an action. | |
| void | update (duration_t delta) |
| Updates the state of all actions with a time delta. | |
| void | update (duraiton_secs_t delta) |
| Updates the state of all actions with a time delta in seconds. | |
| void | shutdown () |
| Shuts down the action management system, stopping all actions. | |
| auto | sequence_impl (const std::vector< seq_action > &actions, const sentinel_t &sentinel, bool precise) -> seq_action |
| auto | sequence (const std::vector< seq_action > &actions, const sentinel_t &sentinel=hpp::eternal_sentinel()) -> seq_action |
| Creates a sequential action that executes a list of actions one after another. | |
| auto | sequence_precise (const std::vector< seq_action > &actions, const sentinel_t &sentinel=hpp::eternal_sentinel()) -> seq_action |
| Creates a precise sequential action that executes a list of actions with exact timing. | |
| auto | together (const std::vector< seq_action > &actions, const sentinel_t &sentinel=hpp::eternal_sentinel()) -> seq_action |
| Creates a simultaneous action that executes a list of actions together. | |
| auto | delay (const duration_t &duration, const sentinel_t &sentinel=hpp::eternal_sentinel()) -> seq_action |
| Creates a delay action. | |
| auto | repeat_impl (const seq_action &action, size_t times, bool precise, const sentinel_t &sentinel=hpp::eternal_sentinel()) -> seq_action |
| auto | repeat (const seq_action &action, size_t times=0) -> seq_action |
| Repeats an action a specified number of times. | |
| auto | repeat (const seq_action &action, const sentinel_t &sentinel, size_t times=0) -> seq_action |
| Repeats an action a specified number of times with a sentinel. | |
| auto | repeat_precise (const seq_action &action, size_t times=0) -> seq_action |
| Precisely repeats an action a specified number of times. | |
| auto | repeat_precise (const seq_action &action, const sentinel_t &sentinel, size_t times=0) -> seq_action |
| Precisely repeats an action a specified number of times with a sentinel. | |
| template<typename T > | |
| auto | change_from_to (T &object, const std::decay_t< T > &begin, const std::decay_t< T > &end, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change an object from one value to another over a specified duration. | |
| template<typename T > | |
| auto | change_from_to (const std::shared_ptr< T > &object, const std::decay_t< T > &begin, const std::decay_t< T > &end, const duration_t &duration, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change a shared object from one value to another over a specified duration. | |
| template<typename T > | |
| auto | change_to (T &object, const std::decay_t< T > &end, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change an object to a specified value over a specified duration. | |
| template<typename T > | |
| auto | change_to (const std::shared_ptr< T > &object, const std::decay_t< T > &end, const duration_t &duration, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change a shared object to a specified value over a specified duration. | |
| template<typename T > | |
| auto | change_by (T &object, const std::decay_t< T > &amount, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change an object by a specified amount over a specified duration. | |
| template<typename T > | |
| auto | change_by (const std::shared_ptr< T > &object, const std::decay_t< T > &amount, const duration_t &duration, const ease_t &ease_func=ease::linear) -> seq_action |
| Creates an action to change a shared object by a specified amount over a specified duration. | |
| template<typename... Args> | |
| auto | sequence (const seq_action &t1, const seq_action &t2, Args &&... actions) -> seq_action |
| Creates a sequential action with two or more actions. | |
| template<typename... Args> | |
| auto | sequence_precise (const seq_action &t1, const seq_action &t2, Args &&... actions) -> seq_action |
| Creates a precise sequential action with two or more actions. | |
| template<typename... Args> | |
| auto | together (const seq_action &t1, const seq_action &t2, Args &&... actions) -> seq_action |
| Creates a simultaneous action with two or more actions. | |
| template<typename Object , typename T , typename Setter , typename Getter > | |
| seq_action | create_from_to_impl (const std::string &creator_name, Object *object, const T &begin, const T &end, const Setter &setter_func, const Getter &getter_func, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func) |
| template<typename Object , typename T , typename Setter , typename Getter > | |
| seq_action | create_to_impl (const std::string &creator_name, Object *object, const T &end, const Setter &setter_func, const Getter &getter_func, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func) |
| template<typename Object , typename T , typename Setter , typename Getter > | |
| seq_action | create_by_impl (const std::string &creator_name, Object *object, const T &amount, const Setter &setter_func, const Getter &getter_func, const duration_t &duration, const sentinel_t &sentinel, const ease_t &ease_func) |
| auto | square (float x, int n) -> float |
| Computes the square of a number raised to a power. | |
| auto | flip (float x) -> float |
| Flips a normalized value (1.0 becomes 0.0, 0.0 becomes 1.0). | |
| auto | mix (float a, float b, float weight, float t) -> float |
| Mixes two values based on a weighted progress factor. | |
| auto | crossfade (float a, float b, float t) -> float |
| Creates a crossfade effect between two values based on progress. | |
| auto | scale (float a, float t) -> float |
| Scales a value by a factor. | |
| auto | reverse_scale (float a, float t) -> float |
| Scales a value in reverse by a factor. | |
| auto | arch (float t) -> float |
| Computes an arch effect (parabolic curve) based on progress. | |
| template<typename T > | |
| auto | lerp (const T &start, const T &end, float progress, const ease_t &ease_func=ease::linear) -> T |
| Linearly interpolates between two values based on progress. | |
| template<typename InType , typename OutType > | |
| auto | range_map (const InType &in, const decltype(in)&in_start, const decltype(in)&in_end, const OutType &out_start, const decltype(out_start)&out_end, const ease_t &ease_func=ease::linear) -> OutType |
| Maps a value from one range to another range, with optional easing. | |
| template<typename T > | |
| auto | clamp (const T &value, const T &min, const T &max) -> T |
| Clamps a value to lie between a minimum and maximum. | |
| template<typename Object , typename TargetType , typename InitializeFunc , typename UpdateFunc , typename Getter > | |
| auto | create_action_updater (Object *object, const TargetType &end, const sentinel_t &sentinel, InitializeFunc &&initialize_func, UpdateFunc &&update_func, Getter &&getter, const ease_t &ease_func=ease::linear, const interpolate_t< TargetType > &interpolate=lerp< TargetType >) |
| void | seq_update (seq::duration_t duration) |
| template<typename T > | |
| void | core_seq_test_impl (seq::seq_action &action, seq::duration_t duration, bool step_update, const values_t< T > &values, const T &begin, const T &end) |
| template<typename T > | |
| seq::seq_action | creator (const std::string &type, values_t< T > &values, T &begin, const T &end, seq::duration_t duration) |
| template<typename T > | |
| void | scenario (bool use_shared_ptr, bool step_update, const std::string &type, seq::duration_t duration, T begin, T end, T object_value) |
| template<typename T > | |
| void | core_seq_test (const std::string &type, const std::string &easing_type, seq::duration_t duration, T begin, T end, T object_value) |
| template<typename T > | |
| void | run_seq_test (const std::string &type, const std::string &easing_type, const T &begin, const T &end, const T &object) |
| void | test_scopes () |
| void | run (bool use_random_inputs) |
Variables | |
| seq_id_t | unique_id = 1 |
| int | SEQ_UPDATE_STEP_COUNT = 10 |
| seq::ease_t | EASING = seq::ease::linear |
Provides a sequence-based action management system for controlling and scheduling actions.
Provides mathematical utilities for interpolation, scaling, and easing functions.
Provides a sequence-based action management framework.
Provides functions for creating and managing sequence-based animations and transitions.
Provides a sequence management framework with utilities for time management, interpolation, and inspection.
Provides a sequence-based action management system for defining, updating, and managing actions.
| using seq::clock_t = std::chrono::steady_clock |
Alias for the steady clock used for timing actions.
Definition at line 23 of file seq_common.h.
| using seq::duraiton_secs_t = std::chrono::duration<float> |
Represents a duration in seconds as a floating-point value.
Definition at line 35 of file seq_common.h.
| using seq::duration_t = std::chrono::nanoseconds |
Represents a duration in nanoseconds.
Definition at line 41 of file seq_common.h.
| using seq::ease_t = std::function<float(float)> |
Represents an easing function for interpolation.
| t | A normalized time value (0 to 1). |
Definition at line 61 of file seq_common.h.
| using seq::interpolate_t = std::function<T(const T&, const T&, float, const ease_t&)> |
Represents a function for interpolating values.
| T | The type of value to interpolate. |
| start | The starting value. |
| end | The ending value. |
| t | A normalized time value (0 to 1). |
| ease | The easing function to apply. |
Definition at line 74 of file seq_common.h.
| using seq::sentinel_t = hpp::sentinel |
Alias for a sentinel object used for lifecycle management.
Definition at line 47 of file seq_common.h.
| using seq::seq_id_t = size_t |
Represents a unique identifier for sequence actions.
Definition at line 53 of file seq_common.h.
| using seq::timepoint_t = clock_t::time_point |
Represents a point in time using the steady clock.
Definition at line 29 of file seq_common.h.
|
strong |
Represents the state of a sequence action.
| Enumerator | |
|---|---|
| running | The action is running. |
| paused | The action is paused. |
| finished | The action has finished. |
Definition at line 80 of file seq_common.h.
| auto seq::arch | ( | float | t | ) | -> float |
Computes an arch effect (parabolic curve) based on progress.
| t | The progress factor (0.0f to 1.0f). |
Definition at line 40 of file seq_math.cpp.
| auto seq::change_by | ( | const std::shared_ptr< T > & | object, |
| const std::decay_t< T > & | amount, | ||
| const duration_t & | duration, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change a shared object by a specified amount over a specified duration.
| T | The type of the shared object being modified. |
| object | The shared object to modify. |
| amount | The amount to change by. |
| duration | The duration of the change. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 188 of file seq_core.hpp.
| auto seq::change_by | ( | T & | object, |
| const std::decay_t< T > & | amount, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change an object by a specified amount over a specified duration.
| T | The type of the object being modified. |
| object | The object to modify. |
| amount | The amount to change by. |
| duration | The duration of the change. |
| sentinel | A sentinel for managing the action lifecycle. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 139 of file seq_core.hpp.
| auto seq::change_from_to | ( | const std::shared_ptr< T > & | object, |
| const std::decay_t< T > & | begin, | ||
| const std::decay_t< T > & | end, | ||
| const duration_t & | duration, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change a shared object from one value to another over a specified duration.
| T | The type of the shared object being modified. |
| object | The shared object to modify. |
| begin | The starting value. |
| end | The ending value. |
| duration | The duration of the change. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 62 of file seq_core.hpp.
| auto seq::change_from_to | ( | T & | object, |
| const std::decay_t< T > & | begin, | ||
| const std::decay_t< T > & | end, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change an object from one value to another over a specified duration.
| T | The type of the object being modified. |
| object | The object to modify. |
| begin | The starting value. |
| end | The ending value. |
| duration | The duration of the change. |
| sentinel | A sentinel for managing the action lifecycle. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 11 of file seq_core.hpp.
| auto seq::change_to | ( | const std::shared_ptr< T > & | object, |
| const std::decay_t< T > & | end, | ||
| const duration_t & | duration, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change a shared object to a specified value over a specified duration.
| T | The type of the shared object being modified. |
| object | The shared object to modify. |
| end | The target value. |
| duration | The duration of the change. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 126 of file seq_core.hpp.
| auto seq::change_to | ( | T & | object, |
| const std::decay_t< T > & | end, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func = ease::linear ) -> seq_action |
Creates an action to change an object to a specified value over a specified duration.
| T | The type of the object being modified. |
| object | The object to modify. |
| end | The target value. |
| duration | The duration of the change. |
| sentinel | A sentinel for managing the action lifecycle. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 76 of file seq_core.hpp.
| auto seq::clamp | ( | const T & | value, |
| const T & | min, | ||
| const T & | max ) -> T |
Clamps a value to lie between a minimum and maximum.
| T | The type of the value. |
| value | The value to clamp. |
| min | The minimum bound. |
| max | The maximum bound. |
Definition at line 54 of file seq_math.h.
| void seq::core_seq_test | ( | const std::string & | type, |
| const std::string & | easing_type, | ||
| seq::duration_t | duration, | ||
| T | begin, | ||
| T | end, | ||
| T | object_value ) |
| void seq::core_seq_test_impl | ( | seq::seq_action & | action, |
| seq::duration_t | duration, | ||
| bool | step_update, | ||
| const values_t< T > & | values, | ||
| const T & | begin, | ||
| const T & | end ) |
| auto seq::create_action_updater | ( | Object * | object, |
| const TargetType & | end, | ||
| const sentinel_t & | sentinel, | ||
| InitializeFunc && | initialize_func, | ||
| UpdateFunc && | update_func, | ||
| Getter && | getter, | ||
| const ease_t & | ease_func = ease::linear, | ||
| const interpolate_t< TargetType > & | interpolate = lerp<TargetType> ) |
Definition at line 11 of file seq_updater.h.
| seq_action seq::create_by_impl | ( | const std::string & | creator_name, |
| Object * | object, | ||
| const T & | amount, | ||
| const Setter & | setter_func, | ||
| const Getter & | getter_func, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func ) |
| seq_action seq::create_from_to_impl | ( | const std::string & | creator_name, |
| Object * | object, | ||
| const T & | begin, | ||
| const T & | end, | ||
| const Setter & | setter_func, | ||
| const Getter & | getter_func, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func ) |
| seq_action seq::create_to_impl | ( | const std::string & | creator_name, |
| Object * | object, | ||
| const T & | end, | ||
| const Setter & | setter_func, | ||
| const Getter & | getter_func, | ||
| const duration_t & | duration, | ||
| const sentinel_t & | sentinel, | ||
| const ease_t & | ease_func ) |
| seq::seq_action seq::creator | ( | const std::string & | type, |
| values_t< T > & | values, | ||
| T & | begin, | ||
| const T & | end, | ||
| seq::duration_t | duration ) |
| auto seq::crossfade | ( | float | a, |
| float | b, | ||
| float | t ) -> float |
Creates a crossfade effect between two values based on progress.
| a | The first value. |
| b | The second value. |
| t | The progress factor (0.0f to 1.0f). |
Definition at line 25 of file seq_math.cpp.
| auto seq::delay | ( | const duration_t & | duration, |
| const sentinel_t & | sentinel = hpp::eternal_sentinel() ) -> seq_action |
Creates a delay action.
| duration | The duration of the delay. |
| sentinel | A sentinel for managing the action lifecycle (default is eternal). |
Definition at line 182 of file seq_core.cpp.
| auto seq::flip | ( | float | x | ) | -> float |
Flips a normalized value (1.0 becomes 0.0, 0.0 becomes 1.0).
| x | The normalized value to flip. |
Definition at line 14 of file seq_math.cpp.
| auto seq::get_duration | ( | seq_id_t | id | ) | -> duration_t |
| auto seq::get_elapsed | ( | seq_id_t | id | ) | -> duration_t |
| auto seq::get_overflow | ( | seq_id_t | id | ) | -> duration_t |
| auto seq::get_percent | ( | seq_id_t | id | ) | -> float |
| auto seq::get_speed_multiplier | ( | seq_id_t | id | ) | -> float |
| auto seq::has_action_with_scope | ( | const std::string & | scope_id | ) | -> bool |
| auto seq::is_finished | ( | seq_id_t | id | ) | -> bool |
| auto seq::is_paused | ( | seq_id_t | id | ) | -> bool |
| auto seq::is_running | ( | seq_id_t | id | ) | -> bool |
| auto seq::is_stopping | ( | seq_id_t | id | ) | -> bool |
| auto seq::lerp | ( | const T & | start, |
| const T & | end, | ||
| float | progress, | ||
| const ease_t & | ease_func = ease::linear ) -> T |
Linearly interpolates between two values based on progress.
| T | The type of the values to interpolate. |
| start | The starting value. |
| end | The ending value. |
| progress | The progress factor (0.0f to 1.0f). |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 8 of file seq_math.hpp.
| auto seq::mix | ( | float | a, |
| float | b, | ||
| float | weight, | ||
| float | t ) -> float |
Mixes two values based on a weighted progress factor.
| a | The first value. |
| b | The second value. |
| weight | The weight of the mix. |
| t | The progress factor (0.0f to 1.0f). |
Definition at line 19 of file seq_math.cpp.
| void seq::pause | ( | seq_id_t | id | ) |
| auto seq::range_map | ( | const InType & | in, |
| const decltype(in)& | in_start, | ||
| const decltype(in)& | in_end, | ||
| const OutType & | out_start, | ||
| const decltype(out_start)& | out_end, | ||
| const ease_t & | ease_func = ease::linear ) -> OutType |
Maps a value from one range to another range, with optional easing.
| InType | The type of the input range values. |
| OutType | The type of the output range values. |
| in | The input value. |
| in_start | The start of the input range. |
| in_end | The end of the input range. |
| out_start | The start of the output range. |
| out_end | The end of the output range. |
| ease_func | The easing function to apply (default is linear easing). |
Definition at line 25 of file seq_math.hpp.
| auto seq::repeat | ( | const seq_action & | action, |
| const sentinel_t & | sentinel, | ||
| size_t | times = 0 ) -> seq_action |
Repeats an action a specified number of times with a sentinel.
| action | The action to repeat. |
| sentinel | A sentinel for managing the action lifecycle. |
| times | The number of times to repeat the action (default is infinite if 0). |
Definition at line 321 of file seq_core.cpp.
| auto seq::repeat | ( | const seq_action & | action, |
| size_t | times = 0 ) -> seq_action |
Repeats an action a specified number of times.
| action | The action to repeat. |
| times | The number of times to repeat the action (default is infinite if 0). |
Definition at line 316 of file seq_core.cpp.
| auto seq::repeat_impl | ( | const seq_action & | action, |
| size_t | times, | ||
| bool | precise, | ||
| const sentinel_t & | sentinel = hpp::eternal_sentinel() ) -> seq_action |
Definition at line 221 of file seq_core.cpp.
| auto seq::repeat_precise | ( | const seq_action & | action, |
| const sentinel_t & | sentinel, | ||
| size_t | times = 0 ) -> seq_action |
Precisely repeats an action a specified number of times with a sentinel.
| action | The action to repeat. |
| sentinel | A sentinel for managing the action lifecycle. |
| times | The number of times to repeat the action (default is infinite if 0). |
Definition at line 331 of file seq_core.cpp.
| auto seq::repeat_precise | ( | const seq_action & | action, |
| size_t | times = 0 ) -> seq_action |
Precisely repeats an action a specified number of times.
| action | The action to repeat. |
| times | The number of times to repeat the action (default is infinite if 0). |
Definition at line 326 of file seq_core.cpp.
| void seq::resume | ( | seq_id_t | id | ) |
| auto seq::reverse_scale | ( | float | a, |
| float | t ) -> float |
Scales a value in reverse by a factor.
| a | The value to scale. |
| t | The scaling factor. |
Definition at line 35 of file seq_math.cpp.
| void seq::run_seq_test | ( | const std::string & | type, |
| const std::string & | easing_type, | ||
| const T & | begin, | ||
| const T & | end, | ||
| const T & | object ) |
| auto seq::scale | ( | float | a, |
| float | t ) -> float |
Scales a value by a factor.
| a | The value to scale. |
| t | The scaling factor. |
Definition at line 30 of file seq_math.cpp.
| void seq::scenario | ( | bool | use_shared_ptr, |
| bool | step_update, | ||
| const std::string & | type, | ||
| seq::duration_t | duration, | ||
| T | begin, | ||
| T | end, | ||
| T | object_value ) |
|
inline |
| auto seq::sequence | ( | const seq_action & | t1, |
| const seq_action & | t2, | ||
| Args &&... | actions ) -> seq_action |
Creates a sequential action with two or more actions.
| Args | Additional actions. |
| t1 | The first action. |
| t2 | The second action. |
| actions | Additional actions to include in the sequence. |
Definition at line 141 of file seq_core.h.
| auto seq::sequence | ( | const std::vector< seq_action > & | actions, |
| const sentinel_t & | sentinel = hpp::eternal_sentinel() ) -> seq_action |
Creates a sequential action that executes a list of actions one after another.
| actions | The list of actions to execute sequentially. |
| sentinel | A sentinel for managing the action lifecycle (default is eternal). |
Definition at line 99 of file seq_core.cpp.
| auto seq::sequence_impl | ( | const std::vector< seq_action > & | actions, |
| const sentinel_t & | sentinel, | ||
| bool | precise ) -> seq_action |
Definition at line 7 of file seq_core.cpp.
| auto seq::sequence_precise | ( | const seq_action & | t1, |
| const seq_action & | t2, | ||
| Args &&... | actions ) -> seq_action |
Creates a precise sequential action with two or more actions.
| Args | Additional actions. |
| t1 | The first action. |
| t2 | The second action. |
| actions | Additional actions to include in the sequence. |
Definition at line 155 of file seq_core.h.
| auto seq::sequence_precise | ( | const std::vector< seq_action > & | actions, |
| const sentinel_t & | sentinel = hpp::eternal_sentinel() ) -> seq_action |
Creates a precise sequential action that executes a list of actions with exact timing.
| actions | The list of actions to execute sequentially. |
| sentinel | A sentinel for managing the action lifecycle (default is eternal). |
Definition at line 104 of file seq_core.cpp.
| void seq::set_elapsed | ( | seq_id_t | id, |
| duration_t | duration ) |
| void seq::set_speed_multiplier | ( | seq_id_t | id, |
| float | speed_multiplier = 1.0f ) |
| void seq::shutdown | ( | ) |
| auto seq::square | ( | float | x, |
| int | n ) -> float |
Computes the square of a number raised to a power.
| x | The base value. |
| n | The exponent. |
Definition at line 5 of file seq_math.cpp.
| auto seq::start | ( | seq_action | action, |
| const seq_scope_policy & | scope_policy = {}, | ||
| hpp::source_location | location = hpp::source_location::current() ) -> seq_id_t |
Starts a new action.
| action | The action to be started. |
| scope_policy | The policy for the scope of the action (default is empty). |
| location | The source location where this function is called (default is the current location). |
| void seq::stop | ( | seq_id_t | id | ) |
| void seq::stop_and_finish | ( | seq_id_t | id, |
| duration_t | finish_after = 0ms ) |
| void seq::stop_when_finished | ( | seq_id_t | id | ) |
| auto seq::together | ( | const seq_action & | t1, |
| const seq_action & | t2, | ||
| Args &&... | actions ) -> seq_action |
Creates a simultaneous action with two or more actions.
| Args | Additional actions. |
| t1 | The first action. |
| t2 | The second action. |
| actions | Additional actions to include in the simultaneous action. |
Definition at line 178 of file seq_core.h.
| auto seq::together | ( | const std::vector< seq_action > & | actions, |
| const sentinel_t & | sentinel = hpp::eternal_sentinel() ) -> seq_action |
Creates a simultaneous action that executes a list of actions together.
| actions | The list of actions to execute together. |
| sentinel | A sentinel for managing the action lifecycle (default is eternal). |
Definition at line 109 of file seq_core.cpp.
| void seq::update | ( | duraiton_secs_t | delta | ) |
| void seq::update | ( | duration_t | delta | ) |
| void seq::update | ( | seq_id_t | id, |
| duration_t | duration ) |
| seq::ease_t seq::EASING = seq::ease::linear |
| seq_id_t seq::unique_id = 1 |
Definition at line 6 of file seq_action.cpp.