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.