From 00ee7002f33b60dcd153d653c0a07a55b4643351 Mon Sep 17 00:00:00 2001 From: Haibo Date: Tue, 20 Nov 2018 19:55:07 +0800 Subject: [PATCH] add: TweenAction refactoring TweenAction(s) & remove CallFunc & rename Animation to Frames --- core/base/Action.hpp | 10 +- .../{ActionInterval.cpp => ActionTween.cpp} | 297 +++++++++--------- core/base/{ActionInterval.h => ActionTween.h} | 185 ++++++----- core/base/Animation.cpp | 149 ++------- core/base/Animation.h | 67 +--- core/base/{CallFunc.cpp => Delay.cpp} | 39 ++- core/base/{CallFunc.h => Delay.h} | 29 +- core/base/Frames.cpp | 114 +++++++ core/base/Frames.h | 82 +++++ core/base/base.hpp | 4 +- core/easy2d.h | 2 +- core/math/ease.hpp | 82 +++++ core/math/scalar.hpp | 34 +- project/vs2013/Easy2D.vcxproj | 11 +- project/vs2013/Easy2D.vcxproj.filters | 25 +- project/vs2015/Easy2D.vcxproj | 11 +- project/vs2015/Easy2D.vcxproj.filters | 25 +- project/vs2017/Easy2D.vcxproj | 11 +- project/vs2017/Easy2D.vcxproj.filters | 25 +- 19 files changed, 712 insertions(+), 490 deletions(-) rename core/base/{ActionInterval.cpp => ActionTween.cpp} (56%) rename core/base/{ActionInterval.h => ActionTween.h} (61%) rename core/base/{CallFunc.cpp => Delay.cpp} (69%) rename core/base/{CallFunc.h => Delay.h} (80%) create mode 100644 core/base/Frames.cpp create mode 100644 core/base/Frames.h create mode 100644 core/math/ease.hpp diff --git a/core/base/Action.hpp b/core/base/Action.hpp index 3f27f08b..43cf2616 100644 --- a/core/base/Action.hpp +++ b/core/base/Action.hpp @@ -53,9 +53,7 @@ namespace easy2d virtual void Pause() { running_ = false; } // 停止动作 - virtual void Stop() { done_ = true; } - - virtual bool IsDone() const { return done_; } + virtual void Stop() { if (!done_) { done_ = true; cb_(); } } // 获取动作的拷贝 virtual spAction Clone() const = 0; @@ -70,6 +68,11 @@ namespace easy2d done_ = false; } + // 设置动作结束时的回调函数 + void SetCallback(std::function cb) { cb_ = cb; } + + virtual bool IsDone() const { return done_; } + protected: virtual void Start() { @@ -91,5 +94,6 @@ namespace easy2d bool running_; bool done_; bool initialized_; + std::function cb_; }; } diff --git a/core/base/ActionInterval.cpp b/core/base/ActionTween.cpp similarity index 56% rename from core/base/ActionInterval.cpp rename to core/base/ActionTween.cpp index be3a2988..90c97c3c 100644 --- a/core/base/ActionInterval.cpp +++ b/core/base/ActionTween.cpp @@ -18,54 +18,125 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -#include "ActionInterval.h" +#include "ActionTween.h" #include "Geometry.h" #include "base.hpp" #include "Node.h" +#include "../math/ease.hpp" #include +#include namespace easy2d { //------------------------------------------------------- - // IntervalAction + // Tween //------------------------------------------------------- - IntervalAction::IntervalAction(Duration const& duration) - : process_(0) - , duration_(duration) + Tween::Tween() + : elapsed_() + , duration_() + , ease_func_(math::Linear) + , ease_type_(EaseFunc::Linear) { } - void IntervalAction::Reset() + Tween::Tween(Duration const& duration, EaseFunc func) + : elapsed_() + , ease_func_(math::Linear) + , ease_type_(EaseFunc::Linear) + { + SetDuration(duration); + SetEaseFunction(func); + } + + void Tween::SetEaseFunction(EaseFunc func) + { + ease_type_ = func; + switch (func) + { + case EaseFunc::Linear: + ease_func_ = math::Linear; + break; + case EaseFunc::EaseIn: + ease_func_ = std::bind(math::EaseIn, std::placeholders::_1, 2.f); + break; + case EaseFunc::EaseOut: + ease_func_ = std::bind(math::EaseOut, std::placeholders::_1, 2.f); + break; + case EaseFunc::EaseInOut: + ease_func_ = std::bind(math::EaseInOut, std::placeholders::_1, 2.f); + break; + case EaseFunc::EaseExponentialIn: + ease_func_ = math::EaseExponentialIn; + break; + case EaseFunc::EaseExponentialOut: + ease_func_ = math::EaseExponentialOut; + break; + case EaseFunc::EaseExponentialInOut: + ease_func_ = math::EaseExponentialInOut; + break; + case EaseFunc::EaseSineIn: + ease_func_ = math::EaseSineIn; + break; + case EaseFunc::EaseSineOut: + ease_func_ = math::EaseSineOut; + break; + case EaseFunc::EaseSineInOut: + ease_func_ = math::EaseSineInOut; + break; + default: + break; + } + } + + void Tween::SetEaseFunction(std::function func) + { + ease_func_ = func; + ease_type_ = EaseFunc(-1); + } + + void Tween::Reset() { Action::Reset(); - process_ = 0; + elapsed_ = Duration{}; } - void IntervalAction::Init(Node* target) + Duration const & Tween::GetDuration() const + { + return duration_; + } + + void Tween::Init(Node* target) { Action::Init(target); } - void IntervalAction::Update(Node* target, Duration const& dt) + void Tween::Update(Node* target, Duration const& dt) { Action::Update(target, dt); + float step; if (duration_.IsZero()) { - process_ = 1.f; - this->Stop(); + step = 1.f; } else { - process_ += dt / duration_; - process_ = std::min(process_, 1.f); - - if (process_ >= 1) - { - this->Stop(); - } + elapsed_ += dt; + step = std::min(elapsed_ / duration_, 1.f); } + + if ((1.f - step) <= FLT_EPSILON) + { + this->Stop(); + } + + UpdateStep(target, ease_func_(step)); + } + + void Tween::SetDuration(Duration const & duration) + { + duration_ = duration; } @@ -73,15 +144,15 @@ namespace easy2d // Move Action //------------------------------------------------------- - MoveBy::MoveBy(Duration const& duration, Point const& vector) - : IntervalAction(duration) + MoveBy::MoveBy(Duration const& duration, Point const& vector, EaseFunc func) + : Tween(duration, func) { delta_pos_ = vector; } void MoveBy::Init(Node* target) { - IntervalAction::Init(target); + Tween::Init(target); if (target) { @@ -89,16 +160,14 @@ namespace easy2d } } - void MoveBy::Update(Node* target, Duration const& dt) + void MoveBy::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { Point diff = target->GetPosition() - prev_pos_; start_pos_ = start_pos_ + diff; - Point new_pos = start_pos_ + (delta_pos_ * process_); + Point new_pos = start_pos_ + (delta_pos_ * step); target->SetPosition(new_pos); prev_pos_ = new_pos; @@ -107,23 +176,23 @@ namespace easy2d spAction MoveBy::Clone() const { - return new (std::nothrow) MoveBy(duration_, delta_pos_); + return new (std::nothrow) MoveBy(duration_, delta_pos_, ease_type_); } spAction MoveBy::Reverse() const { - return new (std::nothrow) MoveBy(duration_, -delta_pos_); + return new (std::nothrow) MoveBy(duration_, -delta_pos_, ease_type_); } - MoveTo::MoveTo(Duration const& duration, Point const& pos) - : MoveBy(duration, Point()) + MoveTo::MoveTo(Duration const& duration, Point const& pos, EaseFunc func) + : MoveBy(duration, Point(), func) { end_pos_ = pos; } spAction MoveTo::Clone() const { - return new (std::nothrow) MoveTo(duration_, end_pos_); + return new (std::nothrow) MoveTo(duration_, end_pos_, ease_type_); } void MoveTo::Init(Node* target) @@ -137,8 +206,8 @@ namespace easy2d // Jump Action //------------------------------------------------------- - JumpBy::JumpBy(Duration const& duration, Point const& vec, float height, int jumps) - : IntervalAction(duration) + JumpBy::JumpBy(Duration const& duration, Point const& vec, float height, int jumps, EaseFunc func) + : Tween(duration, func) , delta_pos_(vec) , height_(height) , jumps_(jumps) @@ -147,17 +216,17 @@ namespace easy2d spAction JumpBy::Clone() const { - return new (std::nothrow) JumpBy(duration_, delta_pos_, height_, jumps_); + return new (std::nothrow) JumpBy(duration_, delta_pos_, height_, jumps_, ease_type_); } spAction JumpBy::Reverse() const { - return new (std::nothrow) JumpBy(duration_, -delta_pos_, height_, jumps_); + return new (std::nothrow) JumpBy(duration_, -delta_pos_, height_, jumps_, ease_type_); } void JumpBy::Init(Node* target) { - IntervalAction::Init(target); + Tween::Init(target); if (target) { @@ -165,16 +234,14 @@ namespace easy2d } } - void JumpBy::Update(Node* target, Duration const& dt) + void JumpBy::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { - float frac = fmod(process_ * jumps_, 1.f); - float x = delta_pos_.x * process_; + float frac = fmod(step * jumps_, 1.f); + float x = delta_pos_.x * step; float y = height_ * 4 * frac * (1 - frac); - y += delta_pos_.y * process_; + y += delta_pos_.y * step; Point diff = target->GetPosition() - prev_pos_; start_pos_ = diff + start_pos_; @@ -186,15 +253,15 @@ namespace easy2d } } - JumpTo::JumpTo(Duration const& duration, Point const& pos, float height, int jumps) - : JumpBy(duration, Point(), height, jumps) + JumpTo::JumpTo(Duration const& duration, Point const& pos, float height, int jumps, EaseFunc func) + : JumpBy(duration, Point(), height, jumps, func) , end_pos_(pos) { } spAction JumpTo::Clone() const { - return new (std::nothrow) JumpTo(duration_, end_pos_, height_, jumps_); + return new (std::nothrow) JumpTo(duration_, end_pos_, height_, jumps_, ease_type_); } void JumpTo::Init(Node* target) @@ -208,15 +275,15 @@ namespace easy2d // Scale Action //------------------------------------------------------- - ScaleBy::ScaleBy(Duration const& duration, float scale) - : IntervalAction(duration) + ScaleBy::ScaleBy(Duration const& duration, float scale, EaseFunc func) + : Tween(duration, func) { delta_x_ = scale; delta_y_ = scale; } - ScaleBy::ScaleBy(Duration const& duration, float scale_x, float scale_y) - : IntervalAction(duration) + ScaleBy::ScaleBy(Duration const& duration, float scale_x, float scale_y, EaseFunc func) + : Tween(duration, func) { delta_x_ = scale_x; delta_y_ = scale_y; @@ -224,7 +291,7 @@ namespace easy2d void ScaleBy::Init(Node* target) { - IntervalAction::Init(target); + Tween::Init(target); if (target) { @@ -233,35 +300,33 @@ namespace easy2d } } - void ScaleBy::Update(Node* target, Duration const& dt) + void ScaleBy::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { - target->SetScale(start_scale_x_ + delta_x_ * process_, start_scale_y_ + delta_y_ * process_); + target->SetScale(start_scale_x_ + delta_x_ * step, start_scale_y_ + delta_y_ * step); } } spAction ScaleBy::Clone() const { - return new (std::nothrow) ScaleBy(duration_, delta_x_, delta_y_); + return new (std::nothrow) ScaleBy(duration_, delta_x_, delta_y_, ease_type_); } spAction ScaleBy::Reverse() const { - return new (std::nothrow) ScaleBy(duration_, -delta_x_, -delta_y_); + return new (std::nothrow) ScaleBy(duration_, -delta_x_, -delta_y_, ease_type_); } - ScaleTo::ScaleTo(Duration const& duration, float scale) - : ScaleBy(duration, 0, 0) + ScaleTo::ScaleTo(Duration const& duration, float scale, EaseFunc func) + : ScaleBy(duration, 0, 0, func) { end_scale_x_ = scale; end_scale_y_ = scale; } - ScaleTo::ScaleTo(Duration const& duration, float scale_x, float scale_y) - : ScaleBy(duration, 0, 0) + ScaleTo::ScaleTo(Duration const& duration, float scale_x, float scale_y, EaseFunc func) + : ScaleBy(duration, 0, 0, func) { end_scale_x_ = scale_x; end_scale_y_ = scale_y; @@ -269,7 +334,7 @@ namespace easy2d spAction ScaleTo::Clone() const { - return new (std::nothrow) ScaleTo(duration_, end_scale_x_, end_scale_y_); + return new (std::nothrow) ScaleTo(duration_, end_scale_x_, end_scale_y_, ease_type_); } void ScaleTo::Init(Node* target) @@ -284,15 +349,15 @@ namespace easy2d // Opacity Action //------------------------------------------------------- - OpacityBy::OpacityBy(Duration const& duration, float opacity) - : IntervalAction(duration) + OpacityBy::OpacityBy(Duration const& duration, float opacity, EaseFunc func) + : Tween(duration, func) { delta_val_ = opacity; } void OpacityBy::Init(Node* target) { - IntervalAction::Init(target); + Tween::Init(target); if (target) { @@ -300,35 +365,33 @@ namespace easy2d } } - void OpacityBy::Update(Node* target, Duration const& dt) + void OpacityBy::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { - target->SetOpacity(start_val_ + delta_val_ * process_); + target->SetOpacity(start_val_ + delta_val_ * step); } } spAction OpacityBy::Clone() const { - return new (std::nothrow) OpacityBy(duration_, delta_val_); + return new (std::nothrow) OpacityBy(duration_, delta_val_, ease_type_); } spAction OpacityBy::Reverse() const { - return new (std::nothrow) OpacityBy(duration_, -delta_val_); + return new (std::nothrow) OpacityBy(duration_, -delta_val_, ease_type_); } - OpacityTo::OpacityTo(Duration const& duration, float opacity) - : OpacityBy(duration, 0) + OpacityTo::OpacityTo(Duration const& duration, float opacity, EaseFunc func) + : OpacityBy(duration, 0, func) { end_val_ = opacity; } spAction OpacityTo::Clone() const { - return new (std::nothrow) OpacityTo(duration_, end_val_); + return new (std::nothrow) OpacityTo(duration_, end_val_, ease_type_); } void OpacityTo::Init(Node* target) @@ -337,13 +400,13 @@ namespace easy2d delta_val_ = end_val_ - start_val_; } - FadeIn::FadeIn(Duration const& duration) - : OpacityTo(duration, 1) + FadeIn::FadeIn(Duration const& duration, EaseFunc func) + : OpacityTo(duration, 1, func) { } - FadeOut::FadeOut(Duration const& duration) - : OpacityTo(duration, 0) + FadeOut::FadeOut(Duration const& duration, EaseFunc func) + : OpacityTo(duration, 0, func) { } @@ -352,15 +415,15 @@ namespace easy2d // Rotate Action //------------------------------------------------------- - RotateBy::RotateBy(Duration const& duration, float rotation) - : IntervalAction(duration) + RotateBy::RotateBy(Duration const& duration, float rotation, EaseFunc func) + : Tween(duration, func) , delta_val_(rotation) { } void RotateBy::Init(Node* target) { - IntervalAction::Init(target); + Tween::Init(target); if (target) { @@ -368,35 +431,33 @@ namespace easy2d } } - void RotateBy::Update(Node* target, Duration const& dt) + void RotateBy::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { - target->SetRotation(start_val_ + delta_val_ * process_); + target->SetRotation(start_val_ + delta_val_ * step); } } spAction RotateBy::Clone() const { - return new (std::nothrow) RotateBy(duration_, delta_val_); + return new (std::nothrow) RotateBy(duration_, delta_val_, ease_type_); } spAction RotateBy::Reverse() const { - return new (std::nothrow) RotateBy(duration_, -delta_val_); + return new (std::nothrow) RotateBy(duration_, -delta_val_, ease_type_); } - RotateTo::RotateTo(Duration const& duration, float rotation) - : RotateBy(duration, 0) + RotateTo::RotateTo(Duration const& duration, float rotation, EaseFunc func) + : RotateBy(duration, 0, func) { end_val_ = rotation; } spAction RotateTo::Clone() const { - return new (std::nothrow) RotateTo(duration_, end_val_); + return new (std::nothrow) RotateTo(duration_, end_val_, ease_type_); } void RotateTo::Init(Node* target) @@ -410,8 +471,8 @@ namespace easy2d // PathAction //------------------------------------------------------- - PathAction::PathAction(Duration const & duration, spGeometry const& geo, bool rotating, float start, float end) - : IntervalAction(duration) + PathAction::PathAction(Duration const & duration, spGeometry const& geo, bool rotating, float start, float end, EaseFunc func) + : Tween(duration, func) , start_(start) , end_(end) , geo_(geo) @@ -421,22 +482,20 @@ namespace easy2d spAction PathAction::Clone() const { - return new PathAction(duration_, geo_, rotating_, start_, end_); + return new PathAction(duration_, geo_, rotating_, start_, end_, ease_type_); } spAction PathAction::Reverse() const { - return new PathAction(duration_, geo_, rotating_, end_, start_); + return new PathAction(duration_, geo_, rotating_, end_, start_, ease_type_); } - void PathAction::Update(Node * target, Duration const & dt) + void PathAction::UpdateStep(Node* target, float step) { - IntervalAction::Update(target, dt); - if (target) { - float percent = std::min(std::max((end_ - start_) * process_ + start_, 0.f), 1.f); - float length = geo_->GetLength() * percent; + float length = geo_->GetLength() * std::min(std::max((end_ - start_) * step + start_, 0.f), 1.f); + Point point, tangent; if (geo_->ComputePointAt(length, &point, &tangent)) { @@ -452,48 +511,4 @@ namespace easy2d } } - - //------------------------------------------------------- - // Delay - //------------------------------------------------------- - - Delay::Delay(Duration const& duration) - : delta_() - , delay_(duration) - { - } - - void Delay::Reset() - { - Action::Reset(); - delta_ = Duration{}; - } - - void Delay::Init(Node* target) - { - Action::Init(target); - } - - void Delay::Update(Node* target, Duration const& dt) - { - Action::Update(target, dt); - - delta_ += dt; - - if (delta_ >= delay_) - { - this->Stop(); - } - } - - spAction Delay::Clone() const - { - return new (std::nothrow) Delay(delay_); - } - - spAction Delay::Reverse() const - { - return new (std::nothrow) Delay(delay_); - } - } diff --git a/core/base/ActionInterval.h b/core/base/ActionTween.h similarity index 61% rename from core/base/ActionInterval.h rename to core/base/ActionTween.h index a8ed619d..92c2a986 100644 --- a/core/base/ActionInterval.h +++ b/core/base/ActionTween.h @@ -24,35 +24,71 @@ namespace easy2d { - class IntervalAction + enum class EaseFunc + { + Linear, // 线性 + EaseIn, // 由慢变快 + EaseOut, // 由快变慢 + EaseInOut, // 由慢变快, 再由快变慢 + EaseExponentialIn, // 由慢变极快 + EaseExponentialOut, // 由极快变慢 + EaseExponentialInOut, // 由慢至极快, 再由极快边慢 + EaseSineIn, // 由快变慢, 采用正弦变换速度 + EaseSineOut, // 由慢变快, 采用正弦变换速度 + EaseSineInOut // 由慢至快, 再由快至慢, 采用正弦变换速度 + }; + + class Tween : public Action { public: - explicit IntervalAction( - Duration const& duration + Tween(); + + explicit Tween( + Duration const& duration, + EaseFunc func + ); + + // 设置速度变化曲线 + void SetEaseFunction( + EaseFunc func + ); + + // 自定义速度变化曲线 + void SetEaseFunction( + std::function func ); virtual void Reset() override; + Duration const& GetDuration() const; + + void SetDuration(Duration const& duration); + protected: virtual void Init(Node* target) override; virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) = 0; + protected: Duration duration_; - float process_; + Duration elapsed_; + EaseFunc ease_type_; + std::function ease_func_; }; // 相对位移动作 class MoveBy - : public IntervalAction + : public Tween { public: explicit MoveBy( - Duration const& duration, /* 持续时长 */ - Point const& vector /* 移动距离 */ + Duration const& duration, /* 持续时长 */ + Point const& vector, /* 移动距离 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -64,7 +100,7 @@ namespace easy2d protected: virtual void Init(Node* target) override; - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: Point start_pos_; @@ -79,8 +115,9 @@ namespace easy2d { public: explicit MoveTo( - Duration const& duration, /* 持续时长 */ - Point const& pos /* 目的坐标 */ + Duration const& duration, /* 持续时长 */ + Point const& pos, /* 目的坐标 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -103,14 +140,15 @@ namespace easy2d // 相对跳跃动作 class JumpBy - : public IntervalAction + : public Tween { public: explicit JumpBy( - Duration const& duration, /* 持续时长 */ - Point const& vec, /* 跳跃距离 */ - float height, /* 跳跃高度 */ - int jumps = 1 /* 跳跃次数 */ + Duration const& duration, /* 持续时长 */ + Point const& vec, /* 跳跃距离 */ + float height, /* 跳跃高度 */ + int jumps = 1, /* 跳跃次数 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -122,7 +160,7 @@ namespace easy2d protected: virtual void Init(Node* target) override; - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: Point start_pos_; @@ -139,10 +177,11 @@ namespace easy2d { public: explicit JumpTo( - Duration const& duration, /* 持续时长 */ - Point const& pos, /* 目的坐标 */ - float height, /* 跳跃高度 */ - int jumps = 1 /* 跳跃次数 */ + Duration const& duration, /* 持续时长 */ + Point const& pos, /* 目的坐标 */ + float height, /* 跳跃高度 */ + int jumps = 1, /* 跳跃次数 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -165,18 +204,20 @@ namespace easy2d // 相对缩放动作 class ScaleBy - : public IntervalAction + : public Tween { public: explicit ScaleBy( - Duration const& duration, /* 持续时长 */ - float scale /* 相对变化值 */ + Duration const& duration, /* 持续时长 */ + float scale, /* 相对变化值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); explicit ScaleBy( - Duration const& duration, /* 持续时长 */ - float scale_x, /* 横向缩放相对变化值 */ - float scale_y /* 纵向缩放相对变化值 */ + Duration const& duration, /* 持续时长 */ + float scale_x, /* 横向缩放相对变化值 */ + float scale_y, /* 纵向缩放相对变化值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -188,7 +229,7 @@ namespace easy2d protected: virtual void Init(Node* target) override; - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: float start_scale_x_; @@ -204,14 +245,16 @@ namespace easy2d { public: explicit ScaleTo( - Duration const& duration, /* 持续时长 */ - float scale /* 目标值 */ + Duration const& duration, /* 持续时长 */ + float scale, /* 目标值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); explicit ScaleTo( - Duration const& duration, /* 持续时长 */ - float scale_x, /* 横向缩放目标值 */ - float scale_y /* 纵向缩放目标值 */ + Duration const& duration, /* 持续时长 */ + float scale_x, /* 横向缩放目标值 */ + float scale_y, /* 纵向缩放目标值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -235,12 +278,13 @@ namespace easy2d // 透明度相对渐变动作 class OpacityBy - : public IntervalAction + : public Tween { public: explicit OpacityBy( - Duration const& duration, /* 持续时长 */ - float opacity /* 相对变化值 */ + Duration const& duration, /* 持续时长 */ + float opacity, /* 相对变化值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -252,7 +296,7 @@ namespace easy2d protected: virtual void Init(Node* target) override; - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: float start_val_; @@ -266,8 +310,9 @@ namespace easy2d { public: explicit OpacityTo( - Duration const& duration, /* 持续时长 */ - float opacity /* 目标值 */ + Duration const& duration, /* 持续时长 */ + float opacity, /* 目标值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -295,7 +340,8 @@ namespace easy2d public: // 创建淡入动作 explicit FadeIn( - Duration const& duration /* 持续时长 */ + Duration const& duration, /* 持续时长 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); }; @@ -307,19 +353,21 @@ namespace easy2d public: // 创建淡出动作 explicit FadeOut( - Duration const& duration /* 持续时长 */ + Duration const& duration, /* 持续时长 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); }; // 相对旋转动作 class RotateBy - : public IntervalAction + : public Tween { public: explicit RotateBy( - Duration const& duration, /* 持续时长 */ - float rotation /* 相对变化值 */ + Duration const& duration, /* 持续时长 */ + float rotation, /* 相对变化值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -331,7 +379,7 @@ namespace easy2d protected: virtual void Init(Node* target) override; - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: float start_val_; @@ -345,8 +393,9 @@ namespace easy2d { public: explicit RotateTo( - Duration const& duration, /* 持续时长 */ - float rotation /* 目标值 */ + Duration const& duration, /* 持续时长 */ + float rotation, /* 目标值 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -369,15 +418,16 @@ namespace easy2d // 路径动作 class PathAction - : public IntervalAction + : public Tween { public: explicit PathAction( - Duration const& duration, /* 持续时长 */ - spGeometry const& geo, /* 几何图形 */ - bool rotating = false, /* 沿路径切线方向旋转 */ - float start = 0.f, /* 起点 */ - float end = 1.f /* 终点 */ + Duration const& duration, /* 持续时长 */ + spGeometry const& geo, /* 几何图形 */ + bool rotating = false, /* 沿路径切线方向旋转 */ + float start = 0.f, /* 起点 */ + float end = 1.f, /* 终点 */ + EaseFunc func = EaseFunc::Linear /* 速度变化 */ ); // 获取该动作的拷贝对象 @@ -387,7 +437,7 @@ namespace easy2d virtual spAction Reverse() const override; protected: - virtual void Update(Node* target, Duration const& dt) override; + virtual void UpdateStep(Node* target, float step) override; protected: bool rotating_; @@ -395,33 +445,4 @@ namespace easy2d float end_; spGeometry geo_; }; - - - // 延时动作 - class Delay - : public Action - { - public: - explicit Delay( - Duration const& duration /* 延迟时长（秒） */ - ); - - // 获取该动作的拷贝对象 - virtual spAction Clone() const override; - - // 获取该动作的倒转 - virtual spAction Reverse() const override; - - // 重置动作 - virtual void Reset() override; - - protected: - virtual void Init(Node* target) override; - - virtual void Update(Node* target, Duration const& dt) override; - - protected: - Duration delay_; - Duration delta_; - }; } diff --git a/core/base/Animation.cpp b/core/base/Animation.cpp index ac934cad..a006e473 100644 --- a/core/base/Animation.cpp +++ b/core/base/Animation.cpp @@ -19,73 +19,69 @@ // THE SOFTWARE. #include "Animation.h" +#include "Frames.h" #include "Image.h" #include "Sprite.h" -#include "logs.h" namespace easy2d { - //------------------------------------------------------- - // Animate - //------------------------------------------------------- - - Animate::Animate() + Animation::Animation() : frame_index_(0) - , animation_(nullptr) + , frames_(nullptr) { } - Animate::Animate(spAnimation const& animation) + Animation::Animation(spFrames const& animation) : frame_index_(0) - , animation_(nullptr) + , frames_(nullptr) { this->SetAnimation(animation); } - Animate::~Animate() + Animation::~Animation() { } - spAnimation Animate::GetAnimation() const + spFrames Animation::GetAnimation() const { - return animation_; + return frames_; } - void Animate::SetAnimation(spAnimation const& animation) + void Animation::SetAnimation(spFrames const& animation) { - if (animation && animation != animation_) + if (animation && animation != frames_) { - animation_ = animation; + frames_ = animation; frame_index_ = 0; } } - void Animate::Init(Node* target) + void Animation::Init(Node* target) { Action::Init(target); auto sprite_target = dynamic_cast(target); - if (sprite_target && animation_) + if (sprite_target && frames_) { - sprite_target->Load(animation_->GetFrames()[frame_index_]); + sprite_target->Load(frames_->GetFrames()[frame_index_]); ++frame_index_; } } - void Animate::Update(Node* target, Duration const& dt) + void Animation::Update(Node* target, Duration const& dt) { Action::Update(target, dt); - if (!animation_) + if (!frames_) { this->Stop(); return; } delta_ += dt; - while (delta_ >= animation_->GetInterval()) + while (delta_ >= frames_->GetInterval()) { - auto& frames = animation_->GetFrames(); + auto& frames = frames_->GetFrames(); auto sprite_target = dynamic_cast(target); if (sprite_target) @@ -93,7 +89,7 @@ namespace easy2d sprite_target->Load(frames[frame_index_]); } - delta_ -= animation_->GetInterval(); + delta_ -= frames_->GetInterval(); ++frame_index_; if (frame_index_ == frames.size()) @@ -104,123 +100,32 @@ namespace easy2d } } - void Animate::Reset() + void Animation::Reset() { Action::Reset(); frame_index_ = 0; } - spAction Animate::Clone() const + spAction Animation::Clone() const { - if (animation_) + if (frames_) { - return new (std::nothrow) Animate(animation_); + return new (std::nothrow) Animation(frames_); } return nullptr; } - spAction Animate::Reverse() const + spAction Animation::Reverse() const { - if (animation_) + if (frames_) { - auto animation = animation_->Reverse(); + auto animation = frames_->Reverse(); if (animation) { - return new (std::nothrow) Animate(animation); + return new (std::nothrow) Animation(animation); } } return nullptr; } - - //------------------------------------------------------- - // Animation - //------------------------------------------------------- - - Animation::Animation() - : interval_(1) - { - } - - Animation::Animation(const Images& frames) - : interval_(1) - { - this->Add(frames); - } - - Animation::Animation(Duration const& interval) - : interval_(interval) - { - } - - Animation::Animation(Duration const& interval, const Images& frames) - : interval_(interval) - { - this->Add(frames); - } - - Animation::~Animation() - { - } - - void Animation::SetInterval(Duration const& interval) - { - interval_ = interval; - } - - void Animation::Add(spImage const& frame) - { - if (!frame) - logs::Warningln("Animation::Add failed, frame is nullptr."); - - if (frame) - { - frames_.push_back(frame); - } - } - - void Animation::Add(const Images& frames) - { - for (const auto &image : frames) - { - this->Add(image); - } - } - - Duration const& Animation::GetInterval() const - { - return interval_; - } - - Animation::Images const& Animation::GetFrames() const - { - return frames_; - } - - spAnimation Animation::Clone() const - { - auto animation = new (std::nothrow) Animation(interval_); - if (animation) - { - for (const auto& frame : frames_) - { - animation->Add(frame); - } - } - return animation; - } - - spAnimation Animation::Reverse() const - { - auto animation = new (std::nothrow) Animation(interval_); - if (!frames_.empty()) - { - for (auto iter = frames_.crbegin(), crend = frames_.crend(); iter != crend; ++iter) - { - if (*iter) - animation->Add(*iter); - } - } - return animation; - } } \ No newline at end of file diff --git a/core/base/Animation.h b/core/base/Animation.h index 054326b4..7b19e297 100644 --- a/core/base/Animation.h +++ b/core/base/Animation.h @@ -25,80 +25,23 @@ namespace easy2d { // 帧动画 class Animation - : public ObjectBase + : public Action { - using Images = std::vector< spImage >; - public: Animation(); explicit Animation( - const Images& frames /* 关键帧数组 */ - ); - - explicit Animation( - Duration const& interval /* 帧间隔（秒） */ - ); - - explicit Animation( - Duration const& interval, /* 帧间隔（秒） */ - const Images& frames /* 关键帧数组 */ + spFrames const& animation ); virtual ~Animation(); - // 添加关键帧 - void Add( - spImage const& frame /* 关键帧 */ - ); - - // 添加多个关键帧 - void Add( - const Images& frames /* 关键帧数组 */ - ); - - // 获取帧间隔 - Duration const& GetInterval() const; - - // 获取关键帧 - Images const& GetFrames() const; - - // 设置每一帧的时间间隔 - void SetInterval( - Duration const& interval /* 帧间隔（秒） */ - ); - - // 获取帧动画的拷贝对象 - spAnimation Clone() const; - - // 获取帧动画的倒转 - spAnimation Reverse() const; - - protected: - Duration interval_; - Images frames_; - }; - - - // 精灵动作 - class Animate - : public Action - { - public: - Animate(); - - explicit Animate( - spAnimation const& animation - ); - - virtual ~Animate(); - // 获取动画 - spAnimation GetAnimation() const; + spFrames GetAnimation() const; // 设置动画 void SetAnimation( - spAnimation const& animation + spFrames const& animation ); // 获取该动作的拷贝对象 @@ -120,6 +63,6 @@ namespace easy2d protected: size_t frame_index_; Duration delta_; - spAnimation animation_; + spFrames frames_; }; } diff --git a/core/base/CallFunc.cpp b/core/base/Delay.cpp similarity index 69% rename from core/base/CallFunc.cpp rename to core/base/Delay.cpp index b3bb6255..9bfb66a5 100644 --- a/core/base/CallFunc.cpp +++ b/core/base/Delay.cpp @@ -18,32 +18,47 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -#include "CallFunc.h" +#include "Delay.h" namespace easy2d { - CallFunc::CallFunc(const Callback& func) : - callback_(func) + Delay::Delay(Duration const& duration) + : delta_() + , delay_(duration) { } - spAction CallFunc::Clone() const + void Delay::Reset() { - return new CallFunc(callback_); + Action::Reset(); + delta_ = Duration{}; } - spAction CallFunc::Reverse() const + void Delay::Init(Node* target) { - return new CallFunc(callback_); + Action::Init(target); } - void CallFunc::Init(Node*) + void Delay::Update(Node* target, Duration const& dt) { + Action::Update(target, dt); + + delta_ += dt; + + if (delta_ >= delay_) + { + this->Stop(); + } } - void CallFunc::Update(Node*, Duration const&) + spAction Delay::Clone() const { - callback_(); - this->Stop(); + return new (std::nothrow) Delay(delay_); } -} + + spAction Delay::Reverse() const + { + return new (std::nothrow) Delay(delay_); + } + +} \ No newline at end of file diff --git a/core/base/CallFunc.h b/core/base/Delay.h similarity index 80% rename from core/base/CallFunc.h rename to core/base/Delay.h index d2c4752c..76d492da 100644 --- a/core/base/CallFunc.h +++ b/core/base/Delay.h @@ -20,19 +20,16 @@ #pragma once #include "Action.hpp" -#include namespace easy2d { - // 回调动作 - class CallFunc + // 延时 + class Delay : public Action { - typedef std::function Callback; - - public: - explicit CallFunc( - const Callback &func /* 函数对象 */ + public: + explicit Delay( + Duration const& duration /* 延迟时长（秒） */ ); // 获取该动作的拷贝对象 @@ -41,14 +38,16 @@ namespace easy2d // 获取该动作的倒转 virtual spAction Reverse() const override; - protected: - // 初始化动作 - virtual void Init(Node*) override; + // 重置动作 + virtual void Reset() override; - // 更新动作 - virtual void Update(Node*, Duration const&) override; + protected: + virtual void Init(Node* target) override; - protected: - Callback callback_; + virtual void Update(Node* target, Duration const& dt) override; + + protected: + Duration delay_; + Duration delta_; }; } diff --git a/core/base/Frames.cpp b/core/base/Frames.cpp new file mode 100644 index 00000000..b140b9e8 --- /dev/null +++ b/core/base/Frames.cpp @@ -0,0 +1,114 @@ +// Copyright (c) 2016-2018 Easy2D - Nomango +// +// 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 "Frames.h" +#include "Image.h" +#include "logs.h" + +namespace easy2d +{ + Frames::Frames() + : interval_(1) + { + } + + Frames::Frames(Images const& frames) + : interval_(1) + { + this->Add(frames); + } + + Frames::Frames(Duration const& interval) + : interval_(interval) + { + } + + Frames::Frames(Duration const& interval, Images const& frames) + : interval_(interval) + { + this->Add(frames); + } + + Frames::~Frames() + { + } + + void Frames::SetInterval(Duration const& interval) + { + interval_ = interval; + } + + void Frames::Add(spImage const& frame) + { + if (!frame) + logs::Warningln("Frames::Add failed, frame is nullptr."); + + if (frame) + { + frames_.push_back(frame); + } + } + + void Frames::Add(Images const& frames) + { + for (const auto &image : frames) + { + this->Add(image); + } + } + + Duration const& Frames::GetInterval() const + { + return interval_; + } + + Frames::Images const& Frames::GetFrames() const + { + return frames_; + } + + spFrames Frames::Clone() const + { + auto animation = new (std::nothrow) Frames(interval_); + if (animation) + { + for (const auto& frame : frames_) + { + animation->Add(frame); + } + } + return animation; + } + + spFrames Frames::Reverse() const + { + auto animation = new (std::nothrow) Frames(interval_); + if (!frames_.empty()) + { + for (auto iter = frames_.crbegin(), crend = frames_.crend(); iter != crend; ++iter) + { + if (*iter) + animation->Add(*iter); + } + } + return animation; + } + +} diff --git a/core/base/Frames.h b/core/base/Frames.h new file mode 100644 index 00000000..12363e1e --- /dev/null +++ b/core/base/Frames.h @@ -0,0 +1,82 @@ +// Copyright (c) 2016-2018 Easy2D - Nomango +// +// 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. + +#pragma once +#include "base.hpp" +#include "time.h" + +namespace easy2d +{ + // 帧集合 + class Frames + : public ObjectBase + { + using Images = std::vector< spImage >; + + public: + Frames(); + + explicit Frames( + Images const& frames /* 关键帧数组 */ + ); + + explicit Frames( + Duration const& interval /* 帧间隔（秒） */ + ); + + explicit Frames( + Duration const& interval, /* 帧间隔（秒） */ + Images const& frames /* 关键帧数组 */ + ); + + virtual ~Frames(); + + // 添加关键帧 + void Add( + spImage const& frame /* 关键帧 */ + ); + + // 添加多个关键帧 + void Add( + Images const& frames /* 关键帧数组 */ + ); + + // 获取帧间隔 + Duration const& GetInterval() const; + + // 获取关键帧 + Images const& GetFrames() const; + + // 设置每一帧的时间间隔 + void SetInterval( + Duration const& interval /* 帧间隔（秒） */ + ); + + // 获取帧动画的拷贝对象 + spFrames Clone() const; + + // 获取帧动画的倒转 + spFrames Reverse() const; + + protected: + Duration interval_; + Images frames_; + }; +} diff --git a/core/base/base.hpp b/core/base/base.hpp index 0c47e511..6675029d 100644 --- a/core/base/base.hpp +++ b/core/base/base.hpp @@ -43,6 +43,7 @@ namespace easy2d E2D_DECLARE_SMART_PTR(Image); E2D_DECLARE_SMART_PTR(Music); E2D_DECLARE_SMART_PTR(Task); + E2D_DECLARE_SMART_PTR(Frames); E2D_DECLARE_SMART_PTR(Geometry); E2D_DECLARE_SMART_PTR(LineGeometry); @@ -60,6 +61,7 @@ namespace easy2d E2D_DECLARE_SMART_PTR(GeometryNode); E2D_DECLARE_SMART_PTR(Action); + E2D_DECLARE_SMART_PTR(Tween); E2D_DECLARE_SMART_PTR(MoveBy); E2D_DECLARE_SMART_PTR(MoveTo); E2D_DECLARE_SMART_PTR(JumpBy); @@ -75,8 +77,6 @@ namespace easy2d E2D_DECLARE_SMART_PTR(PathAction); E2D_DECLARE_SMART_PTR(Delay); E2D_DECLARE_SMART_PTR(Animation); - E2D_DECLARE_SMART_PTR(Animate); - E2D_DECLARE_SMART_PTR(CallFunc); E2D_DECLARE_SMART_PTR(Loop); E2D_DECLARE_SMART_PTR(Sequence); E2D_DECLARE_SMART_PTR(Spawn); diff --git a/core/easy2d.h b/core/easy2d.h index 540b83b3..7f2b3003 100644 --- a/core/easy2d.h +++ b/core/easy2d.h @@ -68,7 +68,7 @@ #include "base/Task.h" #include "base/Action.hpp" #include "base/ActionCombined.h" -#include "base/ActionInterval.h" +#include "base/ActionTween.h" #include "base/Animation.h" #include "base/CallFunc.h" #include "base/Transition.h" diff --git a/core/math/ease.hpp b/core/math/ease.hpp new file mode 100644 index 00000000..276e06b3 --- /dev/null +++ b/core/math/ease.hpp @@ -0,0 +1,82 @@ +// Copyright (c) 2016-2018 Easy2D - Nomango +// +// 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. + +#pragma once +#include "scalar.hpp" + +namespace easy2d +{ + namespace math + { + inline float Linear(float step) + { + return step; + } + + inline float EaseIn(float step, float rate) + { + return math::Pow(step, rate); + } + + inline float EaseOut(float step, float rate) + { + return math::Pow(step, 1.f / rate); + } + + inline float EaseInOut(float step, float rate) + { + if (step < .5f) + return .5f * math::Pow(2 * step, rate); + return 1.f - .5f * math::Pow(2.f - 2 * step, rate); + } + + inline float EaseExponentialIn(float step) + { + return math::Pow(2.f, 10 * (step - 1)); + } + + inline float EaseExponentialOut(float step) + { + return 1.f - math::Pow(2.f, -10 * step); + } + + inline float EaseExponentialInOut(float step) + { + if (step < .5f) + return .5f * math::Pow(2.f, 10 * (2 * step - 1)); + return 0.5f * (2 - math::Pow(2, -10 * (step * 2 - 1))); + } + + inline float EaseSineIn(float step) + { + return 1.f - math::Cos(step * 90); + } + + inline float EaseSineOut(float step) + { + return math::Sin(step * 90); + } + + inline float EaseSineInOut(float step) + { + return -0.5f * (math::Cos(step * 180) - 1); + } + } +} diff --git a/core/math/scalar.hpp b/core/math/scalar.hpp index 9ac788cc..3b88313f 100644 --- a/core/math/scalar.hpp +++ b/core/math/scalar.hpp @@ -34,8 +34,10 @@ namespace easy2d { namespace constants { - E2D_CONSTEXPR auto PIf = 3.14159265358979f; - E2D_CONSTEXPR auto PId = 3.14159265358979323846; + E2D_CONSTEXPR auto PI_F = 3.141592653589793f; + E2D_CONSTEXPR auto PI_F_2 = 1.570796326794896f; + E2D_CONSTEXPR auto PI_D = 3.14159265358979323846; + E2D_CONSTEXPR auto PI_D_2 = 1.57079632679489661923; } inline int Abs(int val) { return ::abs(val); } @@ -48,35 +50,39 @@ namespace easy2d inline double Sqrt(double val) { return ::sqrt(val); } + inline float Pow(float base, float exponent) { return ::powf(base, exponent); } + + inline double Pow(double base, double exponent) { return ::pow(base, exponent); } + inline int Sign(int val) { return val < 0 ? -1 : 1; } inline float Sign(float val) { return val < 0 ? -1.f : 1.f; } inline double Sign(double val) { return val < 0 ? -1.0 : 1.0; } - inline float Sin(float val) { return ::sinf(val * constants::PIf / 180.f); } + inline float Sin(float val) { return ::sinf(val * constants::PI_F / 180.f); } - inline double Sin(double val) { return ::sin(val * constants::PId / 180.0); } + inline double Sin(double val) { return ::sin(val * constants::PI_D / 180.0); } - inline float Cos(float val) { return ::cosf(val * constants::PIf / 180.f); } + inline float Cos(float val) { return ::cosf(val * constants::PI_F / 180.f); } - inline double Cos(double val) { return ::cos(val * constants::PId / 180.0); } + inline double Cos(double val) { return ::cos(val * constants::PI_D / 180.0); } - inline float Tan(float val) { return ::tanf(val * constants::PIf / 180.f); } + inline float Tan(float val) { return ::tanf(val * constants::PI_F / 180.f); } - inline double Tan(double val) { return ::tan(val * constants::PId / 180.0); } + inline double Tan(double val) { return ::tan(val * constants::PI_D / 180.0); } - inline float Asin(float val) { return ::asinf(val) * 180.f / constants::PIf; } + inline float Asin(float val) { return ::asinf(val) * 180.f / constants::PI_F; } - inline double Asin(double val) { return ::asin(val) * 180.f / constants::PIf; } + inline double Asin(double val) { return ::asin(val) * 180.f / constants::PI_F; } - inline float Acos(float val) { return ::acosf(val) * 180.f / constants::PIf; } + inline float Acos(float val) { return ::acosf(val) * 180.f / constants::PI_F; } - inline double Acos(double val) { return ::acos(val) * 180.f / constants::PIf; } + inline double Acos(double val) { return ::acos(val) * 180.f / constants::PI_F; } - inline float Atan(float val) { return ::atanf(val) * 180.f / constants::PIf; } + inline float Atan(float val) { return ::atanf(val) * 180.f / constants::PI_F; } - inline double Atan(double val) { return ::atan(val) * 180.f / constants::PIf; } + inline double Atan(double val) { return ::atan(val) * 180.f / constants::PI_F; } inline float Ceil(float val) { return ::ceil(val); } diff --git a/project/vs2013/Easy2D.vcxproj b/project/vs2013/Easy2D.vcxproj index 558262b4..44b1da85 100644 --- a/project/vs2013/Easy2D.vcxproj +++ b/project/vs2013/Easy2D.vcxproj @@ -21,18 +21,19 @@ - + - + + @@ -69,6 +70,7 @@ + @@ -84,14 +86,15 @@ - + - + + diff --git a/project/vs2013/Easy2D.vcxproj.filters b/project/vs2013/Easy2D.vcxproj.filters index ce4f1897..ef9f1e48 100644 --- a/project/vs2013/Easy2D.vcxproj.filters +++ b/project/vs2013/Easy2D.vcxproj.filters @@ -11,9 +11,6 @@ base - - base - base @@ -182,7 +179,16 @@ base - + + math + + + base + + + base + + base @@ -213,9 +219,6 @@ base - - base - base @@ -327,7 +330,13 @@ base - + + base + + + base + + base diff --git a/project/vs2015/Easy2D.vcxproj b/project/vs2015/Easy2D.vcxproj index 6eb2eb27..dd981319 100644 --- a/project/vs2015/Easy2D.vcxproj +++ b/project/vs2015/Easy2D.vcxproj @@ -21,18 +21,19 @@ - + - + + @@ -69,6 +70,7 @@ + @@ -84,14 +86,15 @@ - + - + + diff --git a/project/vs2015/Easy2D.vcxproj.filters b/project/vs2015/Easy2D.vcxproj.filters index ce4f1897..ef9f1e48 100644 --- a/project/vs2015/Easy2D.vcxproj.filters +++ b/project/vs2015/Easy2D.vcxproj.filters @@ -11,9 +11,6 @@ base - - base - base @@ -182,7 +179,16 @@ base - + + math + + + base + + + base + + base @@ -213,9 +219,6 @@ base - - base - base @@ -327,7 +330,13 @@ base - + + base + + + base + + base diff --git a/project/vs2017/Easy2D.vcxproj b/project/vs2017/Easy2D.vcxproj index 4a9c0982..3bbbf2be 100644 --- a/project/vs2017/Easy2D.vcxproj +++ b/project/vs2017/Easy2D.vcxproj @@ -21,18 +21,19 @@ - + - + + @@ -69,6 +70,7 @@ + @@ -84,14 +86,15 @@ - + - + + diff --git a/project/vs2017/Easy2D.vcxproj.filters b/project/vs2017/Easy2D.vcxproj.filters index ce4f1897..ef9f1e48 100644 --- a/project/vs2017/Easy2D.vcxproj.filters +++ b/project/vs2017/Easy2D.vcxproj.filters @@ -11,9 +11,6 @@ base - - base - base @@ -182,7 +179,16 @@ base - + + math + + + base + + + base + + base @@ -213,9 +219,6 @@ base - - base - base @@ -327,7 +330,13 @@ base - + + base + + + base + + base