godot/scene/animation/tween.cpp

/**************************************************************************/
/*  tween.cpp                                                             */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "tween.h"

#include "scene/animation/easing_equations.h"
#include "scene/main/node.h"
#include "scene/resources/animation.h"

#define CHECK_VALID() …

Tween::interpolater Tween::interpolaters[Tween::TRANS_MAX][Tween::EASE_MAX] = …;

void Tweener::set_tween(const Ref<Tween> &p_tween) { … }

Ref<Tween> Tweener::_get_tween() { … }

void Tweener::_finish() { … }

void Tweener::_bind_methods() { … }

bool Tween::_validate_type_match(const Variant &p_from, Variant &r_to) { … }

void Tween::_start_tweeners() { … }

void Tween::_stop_internal(bool p_reset) { … }

Ref<PropertyTweener> Tween::tween_property(const Object *p_target, const NodePath &p_property, Variant p_to, double p_duration) { … }

Ref<IntervalTweener> Tween::tween_interval(double p_time) { … }

Ref<CallbackTweener> Tween::tween_callback(const Callable &p_callback) { … }

Ref<MethodTweener> Tween::tween_method(const Callable &p_callback, const Variant p_from, Variant p_to, double p_duration) { … }

void Tween::append(Ref<Tweener> p_tweener) { … }

void Tween::stop() { … }

void Tween::pause() { … }

void Tween::play() { … }

void Tween::kill() { … }

bool Tween::is_running() { … }

bool Tween::is_valid() { … }

void Tween::clear() { … }

Ref<Tween> Tween::bind_node(const Node *p_node) { … }

Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) { … }

Tween::TweenProcessMode Tween::get_process_mode() { … }

Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) { … }

Tween::TweenPauseMode Tween::get_pause_mode() { … }

Ref<Tween> Tween::set_parallel(bool p_parallel) { … }

Ref<Tween> Tween::set_loops(int p_loops) { … }

int Tween::get_loops_left() const { … }

Ref<Tween> Tween::set_speed_scale(float p_speed) { … }

Ref<Tween> Tween::set_trans(TransitionType p_trans) { … }

Tween::TransitionType Tween::get_trans() { … }

Ref<Tween> Tween::set_ease(EaseType p_ease) { … }

Tween::EaseType Tween::get_ease() { … }

Ref<Tween> Tween::parallel() { … }

Ref<Tween> Tween::chain() { … }

bool Tween::custom_step(double p_delta) { … }

bool Tween::step(double p_delta) { … }

bool Tween::can_process(bool p_tree_paused) const { … }

Node *Tween::get_bound_node() const { … }

double Tween::get_total_time() const { … }

real_t Tween::run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t p_time, real_t p_initial, real_t p_delta, real_t p_duration) { … }

Variant Tween::interpolate_variant(const Variant &p_initial_val, const Variant &p_delta_val, double p_time, double p_duration, TransitionType p_trans, EaseType p_ease) { … }

String Tween::to_string() { … }

void Tween::_bind_methods() { … }

Tween::Tween() { … }

Tween::Tween(bool p_valid) { … }

Ref<PropertyTweener> PropertyTweener::from(const Variant &p_value) { … }

Ref<PropertyTweener> PropertyTweener::from_current() { … }

Ref<PropertyTweener> PropertyTweener::as_relative() { … }

Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) { … }

Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) { … }

Ref<PropertyTweener> PropertyTweener::set_custom_interpolator(const Callable &p_method) { … }

Ref<PropertyTweener> PropertyTweener::set_delay(double p_delay) { … }

void PropertyTweener::start() { … }

bool PropertyTweener::step(double &r_delta) { … }

void PropertyTweener::set_tween(const Ref<Tween> &p_tween) { … }

void PropertyTweener::_bind_methods() { … }

PropertyTweener::PropertyTweener(const Object *p_target, const Vector<StringName> &p_property, const Variant &p_to, double p_duration) { … }

PropertyTweener::PropertyTweener() { … }

void IntervalTweener::start() { … }

bool IntervalTweener::step(double &r_delta) { … }

IntervalTweener::IntervalTweener(double p_time) { … }

IntervalTweener::IntervalTweener() { … }

Ref<CallbackTweener> CallbackTweener::set_delay(double p_delay) { … }

void CallbackTweener::start() { … }

bool CallbackTweener::step(double &r_delta) { … }

void CallbackTweener::_bind_methods() { … }

CallbackTweener::CallbackTweener(const Callable &p_callback) { … }

CallbackTweener::CallbackTweener() { … }

Ref<MethodTweener> MethodTweener::set_delay(double p_delay) { … }

Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) { … }

Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) { … }

void MethodTweener::start() { … }

bool MethodTweener::step(double &r_delta) { … }

void MethodTweener::set_tween(const Ref<Tween> &p_tween) { … }

void MethodTweener::_bind_methods() { … }

MethodTweener::MethodTweener(const Callable &p_callback, const Variant &p_from, const Variant &p_to, double p_duration) { … }

MethodTweener::MethodTweener() { … }