Lenheart
/
Magic_Game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update: code style

This commit is contained in:
Haibo 2018-11-08 00:21:59 +08:00 committed by Nomango
parent 0f1ba104dd
commit b129a1bf18
60 changed files with 6300 additions and 6091 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
core/actions/Action.cpp
View File

@ -20,86 +20,90 @@
#include "..\e2daction.h"
easy2d::Action::Action()
namespace easy2d
{
Action::Action()
: running_(false)
, done_(false)
, initialized_(false)
, target_(nullptr)
{
}
{
}
easy2d::Action::~Action()
{
}
Action::~Action()
{
}
bool easy2d::Action::IsRunning()
{
bool Action::IsRunning()
{
return running_;
}
}
void easy2d::Action::Resume()
{
void Action::Resume()
{
running_ = true;
}
}
void easy2d::Action::Pause()
{
void Action::Pause()
{
running_ = false;
}
}
void easy2d::Action::Stop()
{
void Action::Stop()
{
done_ = true;
}
}
const std::wstring& easy2d::Action::GetName() const
{
const std::wstring& Action::GetName() const
{
return name_;
}
}
void easy2d::Action::SetName(const std::wstring& name)
{
void Action::SetName(const std::wstring& name)
{
name_ = name;
}
}
easy2d::Node * easy2d::Action::GetTarget()
{
Node * Action::GetTarget()
{
return target_;
}
}
void easy2d::Action::Reset()
{
void Action::Reset()
{
initialized_ = false;
done_ = false;
started_ = Time::Now();
}
}
bool easy2d::Action::IsDone() const
{
bool Action::IsDone() const
{
return done_;
}
}
void easy2d::Action::StartWithTarget(Node* target)
{
void Action::StartWithTarget(Node* target)
{
target_ = target;
running_ = true;
this->Reset();
}
}
void easy2d::Action::Init()
{
void Action::Init()
{
initialized_ = true;
started_ = Time::Now();
}
}
void easy2d::Action::Update()
{
void Action::Update()
{
if (!initialized_)
{
Init();
}
}
}
void easy2d::Action::ResetTime()
{
void Action::ResetTime()
{
}
}

67
core/actions/Animate.cpp
View File

@ -21,31 +21,33 @@
#include "..\e2daction.h"
#include "..\e2dobject.h"
easy2d::Animate::Animate()
namespace easy2d
{
Animate::Animate()
: frame_index_(0)
, animation_(nullptr)
{
}
{
}
easy2d::Animate::Animate(Animation * animation)
Animate::Animate(Animation * animation)
: frame_index_(0)
, animation_(nullptr)
{
{
this->SetAnimation(animation);
}
}
easy2d::Animate::~Animate()
{
Animate::~Animate()
{
SafeRelease(animation_);
}
}
easy2d::Animation * easy2d::Animate::GetAnimation() const
{
Animation * Animate::GetAnimation() const
{
return animation_;
}
}
void easy2d::Animate::SetAnimation(Animation * animation)
{
void Animate::SetAnimation(Animation * animation)
{
if (animation && animation != animation_)
{
if (animation_)
@ -56,10 +58,10 @@ void easy2d::Animate::SetAnimation(Animation * animation)
animation_->Retain();
frame_index_ = 0;
}
}
}
void easy2d::Animate::Init()
{
void Animate::Init()
{
Action::Init();
auto target = dynamic_cast<Sprite*>(target_);
@ -68,10 +70,10 @@ void easy2d::Animate::Init()
target->Load(animation_->GetFrames()[frame_index_]);
++frame_index_;
}
}
}
void easy2d::Animate::Update()
{
void Animate::Update()
{
Action::Update();
if (!animation_)
@ -99,30 +101,30 @@ void easy2d::Animate::Update()
break;
}
}
}
}
void easy2d::Animate::ResetTime()
{
void Animate::ResetTime()
{
Action::ResetTime();
}
}
void easy2d::Animate::Reset()
{
void Animate::Reset()
{
Action::Reset();
frame_index_ = 0;
}
}
easy2d::Animate * easy2d::Animate::Clone() const
{
Animate * Animate::Clone() const
{
if (animation_)
{
return new Animate(animation_);
}
return nullptr;
}
}
easy2d::Animate * easy2d::Animate::Reverse() const
{
Animate * Animate::Reverse() const
{
if (animation_)
{
auto animation = animation_->Reverse();
@ -132,4 +134,5 @@ easy2d::Animate * easy2d::Animate::Reverse() const
}
}
return nullptr;
}
}

73
core/actions/Animation.cpp
View File

@ -20,71 +20,73 @@
#include "..\e2daction.h"
easy2d::Animation::Animation()
namespace easy2d
{
Animation::Animation()
: interval_(1)
{
}
{
}
easy2d::Animation::Animation(const Images& frames)
Animation::Animation(const Images& frames)
: interval_(1)
{
{
this->Add(frames);
}
}
easy2d::Animation::Animation(float interval)
Animation::Animation(float interval)
: interval_(interval)
{
}
{
}
easy2d::Animation::Animation(float interval, const Images& frames)
Animation::Animation(float interval, const Images& frames)
: interval_(interval)
{
{
this->Add(frames);
}
}
easy2d::Animation::~Animation()
{
Animation::~Animation()
{
for (auto frame : frames_)
{
SafeRelease(frame);
}
}
}
void easy2d::Animation::SetInterval(float interval)
{
void Animation::SetInterval(float interval)
{
interval_ = std::max(interval, 0.f);
}
}
void easy2d::Animation::Add(Image * frame)
{
void Animation::Add(Image * frame)
{
E2D_WARNING_IF(frame == nullptr, "Animation::Add failed, frame Is nullptr.");
if (frame)
{
frames_.push_back(frame);
frame->Retain();
}
}
}
void easy2d::Animation::Add(const Images& frames)
{
void Animation::Add(const Images& frames)
{
for (const auto &image : frames)
{
this->Add(image);
}
}
}
float easy2d::Animation::GetInterval() const
{
float Animation::GetInterval() const
{
return interval_;
}
}
const easy2d::Animation::Images& easy2d::Animation::GetFrames() const
{
const Animation::Images& Animation::GetFrames() const
{
return frames_;
}
}
easy2d::Animation * easy2d::Animation::Clone() const
{
Animation * Animation::Clone() const
{
auto animation = new Animation(interval_);
if (animation)
{
@ -94,10 +96,10 @@ easy2d::Animation * easy2d::Animation::Clone() const
}
}
return animation;
}
}
easy2d::Animation * easy2d::Animation::Reverse() const
{
Animation * Animation::Reverse() const
{
auto& oldFrames = this->GetFrames();
Images frames(oldFrames.size());
@ -117,4 +119,5 @@ easy2d::Animation * easy2d::Animation::Reverse() const
}
return new Animation(this->GetInterval(), frames);
}
}

31
core/actions/CallFunc.cpp
View File

@ -20,27 +20,30 @@
#include "..\e2daction.h"
easy2d::CallFunc::CallFunc(const Callback& func) :
namespace easy2d
{
CallFunc::CallFunc(const Callback& func) :
callback_(func)
{
}
{
}
easy2d::CallFunc * easy2d::CallFunc::Clone() const
{
CallFunc * CallFunc::Clone() const
{
return new CallFunc(callback_);
}
}
easy2d::CallFunc * easy2d::CallFunc::Reverse() const
{
CallFunc * CallFunc::Reverse() const
{
return new CallFunc(callback_);
}
}
void easy2d::CallFunc::Init()
{
}
void CallFunc::Init()
{
}
void easy2d::CallFunc::Update()
{
void CallFunc::Update()
{
callback_();
this->Stop();
}
}

43
core/actions/Delay.cpp
View File

@ -20,35 +20,37 @@
#include "..\e2daction.h"
easy2d::Delay::Delay(float duration)
namespace easy2d
{
Delay::Delay(float duration)
: delta_(0)
, delay_(std::max(duration, 0.f))
{
}
{
}
easy2d::Delay * easy2d::Delay::Clone() const
{
Delay * Delay::Clone() const
{
return new Delay(delay_);
}
}
easy2d::Delay * easy2d::Delay::Reverse() const
{
Delay * Delay::Reverse() const
{
return new Delay(delay_);
}
}
void easy2d::Delay::Reset()
{
void Delay::Reset()
{
Action::Reset();
delta_ = 0;
}
}
void easy2d::Delay::Init()
{
void Delay::Init()
{
Action::Init();
}
}
void easy2d::Delay::Update()
{
void Delay::Update()
{
Action::Update();
delta_ = (Time::Now() - started_).Seconds();
@ -57,10 +59,11 @@ void easy2d::Delay::Update()
{
this->Stop();
}
}
}
void easy2d::Delay::ResetTime()
{
void Delay::ResetTime()
{
Action::ResetTime();
started_ = Time::Now() - Duration::Second * delta_;
}
}

7
core/actions/FadeIn.cpp
View File

@ -20,7 +20,10 @@
#include "..\e2daction.h"
easy2d::FadeIn::FadeIn(float duration)
: OpacityTo(duration, 1)
namespace easy2d
{
FadeIn::FadeIn(float duration)
: OpacityTo(duration, 1)
{
}
}

7
core/actions/FadeOut.cpp
View File

@ -20,7 +20,10 @@
#include "..\e2daction.h"
easy2d::FadeOut::FadeOut(float duration)
: OpacityTo(duration, 0)
namespace easy2d
{
FadeOut::FadeOut(float duration)
: OpacityTo(duration, 0)
{
}
}

31
core/actions/FiniteTimeAction.cpp
View File

@ -20,25 +20,27 @@
#include "..\e2daction.h"
easy2d::FiniteTimeAction::FiniteTimeAction(float duration)
namespace easy2d
{
FiniteTimeAction::FiniteTimeAction(float duration)
: delta_(0)
, duration_(std::max(duration, 0.f))
{
}
{
}
void easy2d::FiniteTimeAction::Reset()
{
void FiniteTimeAction::Reset()
{
Action::Reset();
delta_ = 0;
}
}
void easy2d::FiniteTimeAction::Init()
{
void FiniteTimeAction::Init()
{
Action::Init();
}
}
void easy2d::FiniteTimeAction::Update()
{
void FiniteTimeAction::Update()
{
Action::Update();
if (duration_ == 0)
@ -55,10 +57,11 @@ void easy2d::FiniteTimeAction::Update()
this->Stop();
}
}
}
}
void easy2d::FiniteTimeAction::ResetTime()
{
void FiniteTimeAction::ResetTime()
{
Action::ResetTime();
started_ = Time::Now() - Duration::Second * (delta_ * duration_);
}
}

31
core/actions/JumpBy.cpp
View File

@ -21,36 +21,38 @@
#include "..\e2daction.h"
#include "..\e2dobject.h"
easy2d::JumpBy::JumpBy(float duration, const Point & vec, float height, int jumps)
namespace easy2d
{
JumpBy::JumpBy(float duration, const Point & vec, float height, int jumps)
: FiniteTimeAction(duration)
, delta_pos_(vec)
, height_(height)
, jumps_(jumps)
{
}
{
}
easy2d::JumpBy * easy2d::JumpBy::Clone() const
{
JumpBy * JumpBy::Clone() const
{
return new JumpBy(duration_, delta_pos_, height_, jumps_);
}
}
easy2d::JumpBy * easy2d::JumpBy::Reverse() const
{
JumpBy * JumpBy::Reverse() const
{
return new JumpBy(duration_, -delta_pos_, height_, jumps_);
}
}
void easy2d::JumpBy::Init()
{
void JumpBy::Init()
{
FiniteTimeAction::Init();
if (target_)
{
prev_pos_ = start_pos_ = target_->GetPosition();
}
}
}
void easy2d::JumpBy::Update()
{
void JumpBy::Update()
{
FiniteTimeAction::Update();
if (target_)
@ -70,4 +72,5 @@ void easy2d::JumpBy::Update()
prev_pos_ = newPos;
}
}
}

19
core/actions/JumpTo.cpp
View File

@ -21,19 +21,22 @@
#include "..\e2daction.h"
#include "..\e2dobject.h"
easy2d::JumpTo::JumpTo(float duration, const Point & pos, float height, int jumps)
namespace easy2d
{
JumpTo::JumpTo(float duration, const Point & pos, float height, int jumps)
: JumpBy(duration, Point(), height, jumps)
, end_pos_(pos)
{
}
{
}
easy2d::JumpTo * easy2d::JumpTo::Clone() const
{
JumpTo * JumpTo::Clone() const
{
return new JumpTo(duration_, end_pos_, height_, jumps_);
}
}
void easy2d::JumpTo::Init()
{
void JumpTo::Init()
{
JumpBy::Init();
delta_pos_ = end_pos_ - start_pos_;
}
}

49
core/actions/Loop.cpp
View File

@ -20,11 +20,13 @@
#include "..\e2daction.h"
easy2d::Loop::Loop(Action * action, int times /* = -1 */)
namespace easy2d
{
Loop::Loop(Action * action, int times /* = -1 */)
: action_(action)
, times_(0)
, total_times_(times)
{
{
E2D_WARNING_IF(action == nullptr, "Loop NULL pointer exception!");
if (action)
@ -32,15 +34,15 @@ easy2d::Loop::Loop(Action * action, int times /* = -1 */)
action_ = action;
action_->Retain();
}
}
}
easy2d::Loop::~Loop()
{
Loop::~Loop()
{
SafeRelease(action_);
}
}
easy2d::Loop * easy2d::Loop::Clone() const
{
Loop * Loop::Clone() const
{
if (action_)
{
return new Loop(action_->Clone());
@ -49,10 +51,10 @@ easy2d::Loop * easy2d::Loop::Clone() const
{
return nullptr;
}
}
}
easy2d::Loop * easy2d::Loop::Reverse() const
{
Loop * Loop::Reverse() const
{
if (action_)
{
return new Loop(action_->Clone());
@ -61,10 +63,10 @@ easy2d::Loop * easy2d::Loop::Reverse() const
{
return nullptr;
}
}
}
void easy2d::Loop::Init()
{
void Loop::Init()
{
Action::Init();
if (action_)
@ -72,10 +74,10 @@ void easy2d::Loop::Init()
action_->target_ = target_;
action_->Init();
}
}
}
void easy2d::Loop::Update()
{
void Loop::Update()
{
Action::Update();
if (times_ == total_times_)
@ -100,17 +102,18 @@ void easy2d::Loop::Update()
{
this->Stop();
}
}
}
void easy2d::Loop::Reset()
{
void Loop::Reset()
{
Action::Reset();
if (action_) action_->Reset();
times_ = 0;
}
}
void easy2d::Loop::ResetTime()
{
void Loop::ResetTime()
{
if (action_) action_->ResetTime();
}
}

31
core/actions/MoveBy.cpp
View File

@ -22,24 +22,26 @@
#include "..\e2dobject.h"
easy2d::MoveBy::MoveBy(float duration, Point vector)
namespace easy2d
{
MoveBy::MoveBy(float duration, Point vector)
: FiniteTimeAction(duration)
{
{
delta_pos_ = vector;
}
}
void easy2d::MoveBy::Init()
{
void MoveBy::Init()
{
FiniteTimeAction::Init();
if (target_)
{
prev_pos_ = start_pos_ = target_->GetPosition();
}
}
}
void easy2d::MoveBy::Update()
{
void MoveBy::Update()
{
FiniteTimeAction::Update();
if (target_)
@ -53,14 +55,15 @@ void easy2d::MoveBy::Update()
prev_pos_ = newPos;
}
}
}
easy2d::MoveBy * easy2d::MoveBy::Clone() const
{
MoveBy * MoveBy::Clone() const
{
return new MoveBy(duration_, delta_pos_);
}
}
easy2d::MoveBy * easy2d::MoveBy::Reverse() const
{
MoveBy * MoveBy::Reverse() const
{
return new MoveBy(duration_, -delta_pos_);
}
}

19
core/actions/MoveTo.cpp
View File

@ -21,19 +21,22 @@
#include "..\e2daction.h"
#include "..\e2dobject.h"
easy2d::MoveTo::MoveTo(float duration, Point pos)
namespace easy2d
{
MoveTo::MoveTo(float duration, Point pos)
: MoveBy(duration, Point())
{
{
end_pos_ = pos;
}
}
easy2d::MoveTo * easy2d::MoveTo::Clone() const
{
MoveTo * MoveTo::Clone() const
{
return new MoveTo(duration_, end_pos_);
}
}
void easy2d::MoveTo::Init()
{
void MoveTo::Init()
{
MoveBy::Init();
delta_pos_ = end_pos_ - start_pos_;
}
}

31
core/actions/OpacityBy.cpp
View File

@ -22,38 +22,41 @@
#include "..\e2dobject.h"
easy2d::OpacityBy::OpacityBy(float duration, float opacity)
namespace easy2d
{
OpacityBy::OpacityBy(float duration, float opacity)
: FiniteTimeAction(duration)
{
{
delta_val_ = opacity;
}
}
void easy2d::OpacityBy::Init()
{
void OpacityBy::Init()
{
FiniteTimeAction::Init();
if (target_)
{
start_val_ = target_->GetOpacity();
}
}
}
void easy2d::OpacityBy::Update()
{
void OpacityBy::Update()
{
FiniteTimeAction::Update();
if (target_)
{
target_->SetOpacity(start_val_ + delta_val_ * delta_);
}
}
}
easy2d::OpacityBy * easy2d::OpacityBy::Clone() const
{
OpacityBy * OpacityBy::Clone() const
{
return new OpacityBy(duration_, delta_val_);
}
}
easy2d::OpacityBy * easy2d::OpacityBy::Reverse() const
{
OpacityBy * OpacityBy::Reverse() const
{
return new OpacityBy(duration_, -delta_val_);
}
}

19
core/actions/OpacityTo.cpp
View File

@ -22,19 +22,22 @@
#include "..\e2dobject.h"
easy2d::OpacityTo::OpacityTo(float duration, float opacity)
namespace easy2d
{
OpacityTo::OpacityTo(float duration, float opacity)
: OpacityBy(duration, 0)
{
{
end_val_ = opacity;
}
}
easy2d::OpacityTo * easy2d::OpacityTo::Clone() const
{
OpacityTo * OpacityTo::Clone() const
{
return new OpacityTo(duration_, end_val_);
}
}
void easy2d::OpacityTo::Init()
{
void OpacityTo::Init()
{
OpacityBy::Init();
delta_val_ = end_val_ - start_val_;
}
}

31
core/actions/RotateBy.cpp
View File

@ -22,38 +22,41 @@
#include "..\e2dobject.h"
easy2d::RotateBy::RotateBy(float duration, float rotation)
namespace easy2d
{
RotateBy::RotateBy(float duration, float rotation)
: FiniteTimeAction(duration)
{
{
delta_val_ = rotation;
}
}
void easy2d::RotateBy::Init()
{
void RotateBy::Init()
{
FiniteTimeAction::Init();
if (target_)
{
start_val_ = target_->GetRotation();
}
}
}
void easy2d::RotateBy::Update()
{
void RotateBy::Update()
{
FiniteTimeAction::Update();
if (target_)
{
target_->SetRotation(start_val_ + delta_val_ * delta_);
}
}
}
easy2d::RotateBy * easy2d::RotateBy::Clone() const
{
RotateBy * RotateBy::Clone() const
{
return new RotateBy(duration_, delta_val_);
}
}
easy2d::RotateBy * easy2d::RotateBy::Reverse() const
{
RotateBy * RotateBy::Reverse() const
{
return new RotateBy(duration_, -delta_val_);
}
}

19
core/actions/RotateTo.cpp
View File

@ -22,19 +22,22 @@
#include "..\e2dobject.h"
easy2d::RotateTo::RotateTo(float duration, float rotation)
namespace easy2d
{
RotateTo::RotateTo(float duration, float rotation)
: RotateBy(duration, 0)
{
{
end_val_ = rotation;
}
}
easy2d::RotateTo * easy2d::RotateTo::Clone() const
{
RotateTo * RotateTo::Clone() const
{
return new RotateTo(duration_, end_val_);
}
}
void easy2d::RotateTo::Init()
{
void RotateTo::Init()
{
RotateBy::Init();
delta_val_ = end_val_ - start_val_;
}
}

37
core/actions/ScaleBy.cpp
View File

@ -22,22 +22,24 @@
#include "..\e2dobject.h"
easy2d::ScaleBy::ScaleBy(float duration, float scale)
: FiniteTimeAction(duration)
namespace easy2d
{
ScaleBy::ScaleBy(float duration, float scale)
: FiniteTimeAction(duration)
{
delta_x_ = scale;
delta_y_ = scale;
}
}
easy2d::ScaleBy::ScaleBy(float duration, float scale_x, float scale_y)
ScaleBy::ScaleBy(float duration, float scale_x, float scale_y)
: FiniteTimeAction(duration)
{
{
delta_x_ = scale_x;
delta_y_ = scale_y;
}
}
void easy2d::ScaleBy::Init()
{
void ScaleBy::Init()
{
FiniteTimeAction::Init();
if (target_)
@ -45,24 +47,25 @@ void easy2d::ScaleBy::Init()
start_scale_x_ = target_->GetScaleX();
start_scale_y_ = target_->GetScaleY();
}
}
}
void easy2d::ScaleBy::Update()
{
void ScaleBy::Update()
{
FiniteTimeAction::Update();
if (target_)
{
target_->SetScale(start_scale_x_ + delta_x_ * delta_, start_scale_y_ + delta_y_ * delta_);
}
}
}
easy2d::ScaleBy * easy2d::ScaleBy::Clone() const
{
ScaleBy * ScaleBy::Clone() const
{
return new ScaleBy(duration_, delta_x_, delta_y_);
}
}
easy2d::ScaleBy * easy2d::ScaleBy::Reverse() const
{
ScaleBy * ScaleBy::Reverse() const
{
return new ScaleBy(duration_, -delta_x_, -delta_y_);
}
}

26
core/actions/ScaleTo.cpp
View File

@ -21,28 +21,32 @@
#include "..\e2daction.h"
#include "..\e2dobject.h"
easy2d::ScaleTo::ScaleTo(float duration, float scale)
: ScaleBy(duration, 0, 0)
namespace easy2d
{
ScaleTo::ScaleTo(float duration, float scale)
: ScaleBy(duration, 0, 0)
{
end_scale_x_ = scale;
end_scale_y_ = scale;
}
}
easy2d::ScaleTo::ScaleTo(float duration, float scale_x, float scale_y)
ScaleTo::ScaleTo(float duration, float scale_x, float scale_y)
: ScaleBy(duration, 0, 0)
{
{
end_scale_x_ = scale_x;
end_scale_y_ = scale_y;
}
}
easy2d::ScaleTo * easy2d::ScaleTo::Clone() const
{
ScaleTo * ScaleTo::Clone() const
{
return new ScaleTo(duration_, end_scale_x_, end_scale_y_);
}
}
void easy2d::ScaleTo::Init()
{
void ScaleTo::Init()
{
ScaleBy::Init();
delta_x_ = end_scale_x_ - start_scale_x_;
delta_y_ = end_scale_y_ - start_scale_y_;
}
}

70
core/actions/Sequence.cpp
View File

@ -20,27 +20,30 @@
#include "..\e2daction.h"
easy2d::Sequence::Sequence()
: action_index_(0)
{
}
easy2d::Sequence::Sequence(const Actions& actions)
: action_index_(0)
namespace easy2d
{
Sequence::Sequence()
: action_index_(0)
{
}
Sequence::Sequence(const Actions& actions)
: action_index_(0)
{
this->Add(actions);
}
}
easy2d::Sequence::~Sequence()
{
Sequence::~Sequence()
{
for (auto action : actions_)
{
SafeRelease(action);
}
}
}
void easy2d::Sequence::Init()
{
void Sequence::Init()
{
Action::Init();
// 将所有动作与目标绑定
if (target_)
@ -52,10 +55,10 @@ void easy2d::Sequence::Init()
}
// 初始化第一个动作
actions_[0]->Init();
}
}
void easy2d::Sequence::Update()
{
void Sequence::Update()
{
Action::Update();
auto &action = actions_[action_index_];
@ -73,45 +76,45 @@ void easy2d::Sequence::Update()
actions_[action_index_]->Init();
}
}
}
}
void easy2d::Sequence::Reset()
{
void Sequence::Reset()
{
Action::Reset();
for (const auto& action : actions_)
{
action->Reset();
}
action_index_ = 0;
}
}
void easy2d::Sequence::ResetTime()
{
void Sequence::ResetTime()
{
for (const auto& action : actions_)
{
action->ResetTime();
}
}
}
void easy2d::Sequence::Add(Action * action)
{
void Sequence::Add(Action * action)
{
if (action)
{
actions_.push_back(action);
action->Retain();
}
}
}
void easy2d::Sequence::Add(const Actions& actions)
{
void Sequence::Add(const Actions& actions)
{
for (const auto &action : actions)
{
this->Add(action);
}
}
}
easy2d::Sequence * easy2d::Sequence::Clone() const
{
Sequence * Sequence::Clone() const
{
auto sequence = new Sequence();
for (const auto& action : actions_)
{
@ -121,10 +124,10 @@ easy2d::Sequence * easy2d::Sequence::Clone() const
}
}
return sequence;
}
}
easy2d::Sequence * easy2d::Sequence::Reverse() const
{
Sequence * Sequence::Reverse() const
{
auto sequence = new Sequence();
if (sequence && !actions_.empty())
{
@ -136,4 +139,5 @@ easy2d::Sequence * easy2d::Sequence::Reverse() const
sequence->Add(newActions);
}
return sequence;
}
}

66
core/actions/Spawn.cpp
View File

@ -20,25 +20,28 @@
#include "..\e2daction.h"
easy2d::Spawn::Spawn()
{
}
easy2d::Spawn::Spawn(const Actions& actions)
namespace easy2d
{
Spawn::Spawn()
{
}
Spawn::Spawn(const Actions& actions)
{
this->Add(actions);
}
}
easy2d::Spawn::~Spawn()
{
Spawn::~Spawn()
{
for (auto action : actions_)
{
SafeRelease(action);
}
}
}
void easy2d::Spawn::Init()
{
void Spawn::Init()
{
Action::Init();
if (target_)
@ -49,10 +52,10 @@ void easy2d::Spawn::Init()
action->Init();
}
}
}
}
void easy2d::Spawn::Update()
{
void Spawn::Update()
{
Action::Update();
size_t done_num = 0;
@ -72,44 +75,44 @@ void easy2d::Spawn::Update()
{
this->Stop();
}
}
}
void easy2d::Spawn::Reset()
{
void Spawn::Reset()
{
Action::Reset();
for (const auto& action : actions_)
{
action->Reset();
}
}
}
void easy2d::Spawn::ResetTime()
{
void Spawn::ResetTime()
{
for (const auto& action : actions_)
{
action->ResetTime();
}
}
}
void easy2d::Spawn::Add(Action * action)
{
void Spawn::Add(Action * action)
{
if (action)
{
actions_.push_back(action);
action->Retain();
}
}
}
void easy2d::Spawn::Add(const Actions& actions)
{
void Spawn::Add(const Actions& actions)
{
for (const auto &action : actions)
{
this->Add(action);
}
}
}
easy2d::Spawn * easy2d::Spawn::Clone() const
{
Spawn * Spawn::Clone() const
{
auto spawn = new Spawn();
for (const auto& action : actions_)
{
@ -119,10 +122,10 @@ easy2d::Spawn * easy2d::Spawn::Clone() const
}
}
return spawn;
}
}
easy2d::Spawn * easy2d::Spawn::Reverse() const
{
Spawn * Spawn::Reverse() const
{
auto spawn = new Spawn();
if (spawn && !actions_.empty())
{
@ -134,4 +137,5 @@ easy2d::Spawn * easy2d::Spawn::Reverse() const
spawn->Add(newActions);
}
return spawn;
}
}

103
core/components/Button.cpp
View File

@ -37,7 +37,9 @@
} \
easy2d::Button::Button()
namespace easy2d
{
Button::Button()
: callback_(nullptr)
, status_(Status::Normal)
, enabled_(true)
@ -46,10 +48,10 @@ easy2d::Button::Button()
, mouseover_(nullptr)
, selected_(nullptr)
, disabled_(nullptr)
{
}
{
}
easy2d::Button::Button(Node * normal, const Callback& func)
Button::Button(Node * normal, const Callback& func)
: callback_(nullptr)
, status_(Status::Normal)
, enabled_(true)
@ -58,12 +60,12 @@ easy2d::Button::Button(Node * normal, const Callback& func)
, mouseover_(nullptr)
, selected_(nullptr)
, disabled_(nullptr)
{
{
this->SetNormal(normal);
this->SetCallbackOnClick(func);
}
}
easy2d::Button::Button(Node * normal, Node * selected, const Callback& func)
Button::Button(Node * normal, Node * selected, const Callback& func)
: callback_(nullptr)
, status_(Status::Normal)
, enabled_(true)
@ -72,13 +74,13 @@ easy2d::Button::Button(Node * normal, Node * selected, const Callback& func)
, mouseover_(nullptr)
, selected_(nullptr)
, disabled_(nullptr)
{
{
this->SetNormal(normal);
this->SetSelected(selected);
this->SetCallbackOnClick(func);
}
}
easy2d::Button::Button(Node * normal, Node * mouseover, Node * selected, const Callback& func)
Button::Button(Node * normal, Node * mouseover, Node * selected, const Callback& func)
: callback_(nullptr)
, status_(Status::Normal)
, enabled_(true)
@ -87,14 +89,14 @@ easy2d::Button::Button(Node * normal, Node * mouseover, Node * selected, const C
, mouseover_(nullptr)
, selected_(nullptr)
, disabled_(nullptr)
{
{
this->SetNormal(normal);
this->SetMouseOver(mouseover);
this->SetSelected(selected);
this->SetCallbackOnClick(func);
}
}
easy2d::Button::Button(Node * normal, Node * mouseover, Node * selected, Node * disabled, const Callback& func)
Button::Button(Node * normal, Node * mouseover, Node * selected, Node * disabled, const Callback& func)
: callback_(nullptr)
, status_(Status::Normal)
, enabled_(true)
@ -103,68 +105,68 @@ easy2d::Button::Button(Node * normal, Node * mouseover, Node * selected, Node *
, mouseover_(nullptr)
, selected_(nullptr)
, disabled_(nullptr)
{
{
this->SetNormal(normal);
this->SetMouseOver(mouseover);
this->SetSelected(selected);
this->SetDisabled(disabled);
this->SetCallbackOnClick(func);
}
}
bool easy2d::Button::IsEnable() const
{
bool Button::IsEnable() const
{
return enabled_;
}
}
void easy2d::Button::SetNormal(Node * normal)
{
void Button::SetNormal(Node * normal)
{
SET_BUTTON_NODE(normal_, normal);
if (normal)
{
this->SetSize(normal->GetWidth(), normal->GetHeight());
}
}
}
void easy2d::Button::SetMouseOver(Node * mouseover)
{
void Button::SetMouseOver(Node * mouseover)
{
SET_BUTTON_NODE(mouseover_, mouseover);
}
}
void easy2d::Button::SetSelected(Node * selected)
{
void Button::SetSelected(Node * selected)
{
SET_BUTTON_NODE(selected_, selected);
}
}
void easy2d::Button::SetDisabled(Node * disabled)
{
void Button::SetDisabled(Node * disabled)
{
SET_BUTTON_NODE(disabled_, disabled);
}
}
void easy2d::Button::SetEnabled(bool enabled)
{
void Button::SetEnabled(bool enabled)
{
if (enabled_ != enabled)
{
enabled_ = enabled;
UpdateVisible();
}
}
}
void easy2d::Button::SetCallbackOnClick(const Callback& func)
{
void Button::SetCallbackOnClick(const Callback& func)
{
callback_ = func;
}
}
void easy2d::Button::SetPivot(float pivot_x, float pivot_y)
{
void Button::SetPivot(float pivot_x, float pivot_y)
{
Node::SetPivot(pivot_x, pivot_y);
SAFE_SET(normal_, SetPivot, pivot_x, pivot_y);
SAFE_SET(mouseover_, SetPivot, pivot_x, pivot_y);
SAFE_SET(selected_, SetPivot, pivot_x, pivot_y);
SAFE_SET(disabled_, SetPivot, pivot_x, pivot_y);
}
}
bool easy2d::Button::Dispatch(const MouseEvent & e, bool handled)
{
bool Button::Dispatch(const MouseEvent & e, bool handled)
{
if (!handled && enabled_ && IsVisible() && normal_)
{
bool contains = normal_->ContainsPoint(e.GetPosition());
@ -210,10 +212,10 @@ bool easy2d::Button::Dispatch(const MouseEvent & e, bool handled)
}
return Node::Dispatch(e, handled);
}
}
void easy2d::Button::Visit()
{
void Button::Visit()
{
Node::Visit();
if (IsVisible() &&
@ -235,19 +237,19 @@ void easy2d::Button::Visit()
::SetCursor(hcursor);
}
}
}
}
void easy2d::Button::SetStatus(Status status)
{
void Button::SetStatus(Status status)
{
if (status_ != status)
{
status_ = status;
UpdateVisible();
}
}
}
void easy2d::Button::UpdateVisible()
{
void Button::UpdateVisible()
{
SAFE_SET(normal_, SetVisible, false);
SAFE_SET(mouseover_, SetVisible, false);
SAFE_SET(selected_, SetVisible, false);
@ -279,4 +281,5 @@ void easy2d::Button::UpdateVisible()
if (normal_) normal_->SetVisible(true);
}
}
}
}

52
core/components/Menu.cpp
View File

@ -20,32 +20,35 @@
#include "..\e2dcomponent.h"
easy2d::Menu::Menu()
: enabled_(true)
{
}
easy2d::Menu::Menu(const std::vector<Button*>& buttons)
: enabled_(true)
namespace easy2d
{
Menu::Menu()
: enabled_(true)
{
}
Menu::Menu(const std::vector<Button*>& buttons)
: enabled_(true)
{
for (const auto& button : buttons)
{
this->AddButton(button);
}
}
}
bool easy2d::Menu::IsEnable() const
{
bool Menu::IsEnable() const
{
return enabled_;
}
}
size_t easy2d::Menu::GetButtonCount() const
{
size_t Menu::GetButtonCount() const
{
return buttons_.size();
}
}
void easy2d::Menu::SetEnabled(bool enabled)
{
void Menu::SetEnabled(bool enabled)
{
if (enabled_ != enabled)
{
enabled_ = enabled;
@ -55,20 +58,20 @@ void easy2d::Menu::SetEnabled(bool enabled)
button->SetEnabled(enabled);
}
}
}
}
void easy2d::Menu::AddButton(Button * button)
{
void Menu::AddButton(Button * button)
{
if (button)
{
this->AddChild(button);
buttons_.push_back(button);
button->SetEnabled(enabled_);
}
}
}
bool easy2d::Menu::RemoveButton(Button * button)
{
bool Menu::RemoveButton(Button * button)
{
if (buttons_.empty())
{
return false;
@ -88,9 +91,10 @@ bool easy2d::Menu::RemoveButton(Button * button)
}
}
return false;
}
}
const std::vector<easy2d::Button*>& easy2d::Menu::GetAllButtons() const
{
const std::vector<Button*>& Menu::GetAllButtons() const
{
return buttons_;
}
}

10
core/e2dutil.h
View File

@ -61,7 +61,7 @@ namespace easy2d
Point operator - () const;
bool operator== (const Point& other) const;
explicit operator easy2d::Size() const;
explicit operator Size() const;
// 判断两点间距离
static float Distance(
@ -102,7 +102,7 @@ namespace easy2d
Size operator - () const;
bool operator== (const Size& other) const;
explicit operator easy2d::Point() const;
explicit operator Point() const;
};
@ -585,19 +585,19 @@ namespace easy2d
template<typename T>
static inline T Range(T min, T max)
{
return easy2d::Random::RandomInt(min, max);
return Random::RandomInt(min, max);
}
// 取得范围内的一个浮点数随机数
static inline float Range(float min, float max)
{
return easy2d::Random::RandomReal(min, max);
return Random::RandomReal(min, max);
}
// 取得范围内的一个浮点数随机数
static inline double Range(double min, double max)
{
return easy2d::Random::RandomReal(min, max);
return Random::RandomReal(min, max);
}
private:

25
core/events/KeyEvent.cpp
View File

@ -21,15 +21,17 @@
#include "..\e2devent.h"
easy2d::KeyEvent::KeyEvent(UINT message, WPARAM w_param, LPARAM l_param)
namespace easy2d
{
KeyEvent::KeyEvent(UINT message, WPARAM w_param, LPARAM l_param)
: message_(message)
, w_param_(w_param)
, l_param_(l_param)
{
}
{
}
easy2d::KeyCode easy2d::KeyEvent::GetCode() const
{
KeyCode KeyEvent::GetCode() const
{
switch (w_param_)
{
case 'A': return KeyCode::A;
@ -87,14 +89,15 @@ easy2d::KeyCode easy2d::KeyEvent::GetCode() const
case VK_ESCAPE: return KeyCode::Esc;
default: return KeyCode::Unknown;
}
}
}
int easy2d::KeyEvent::GetCount() const
{
int KeyEvent::GetCount() const
{
return static_cast<int>((DWORD)l_param_ & 0x0000FFFF);
}
}
easy2d::KeyEvent::Type easy2d::KeyEvent::GetType() const
{
KeyEvent::Type KeyEvent::GetType() const
{
return Type(message_);
}
}

67
core/events/MouseEvent.cpp
View File

@ -21,65 +21,68 @@
#include "..\e2devent.h"
#include "..\e2dmodule.h"
easy2d::MouseEvent::MouseEvent(UINT message, WPARAM w_param, LPARAM l_param)
namespace easy2d
{
MouseEvent::MouseEvent(UINT message, WPARAM w_param, LPARAM l_param)
: message_(message)
, w_param_(w_param)
, l_param_(l_param)
{
}
{
}
float easy2d::MouseEvent::GetX() const
{
float MouseEvent::GetX() const
{
float dpi = Graphics::GetDpi();
return ((float)(short)LOWORD(l_param_)) * 96.f / dpi;
}
}
float easy2d::MouseEvent::GetY() const
{
float MouseEvent::GetY() const
{
float dpi = Graphics::GetDpi();
return ((float)(short)HIWORD(l_param_)) * 96.f / dpi;
}
}
easy2d::Point easy2d::MouseEvent::GetPosition() const
{
Point MouseEvent::GetPosition() const
{
float dpi = Graphics::GetDpi();
return Point(
((float)(short)LOWORD(l_param_)) * 96.f / dpi,
((float)(short)HIWORD(l_param_)) * 96.f / dpi
);
}
}
bool easy2d::MouseEvent::IsShiftDown() const
{
bool MouseEvent::IsShiftDown() const
{
return GET_KEYSTATE_WPARAM(w_param_) == MK_SHIFT;
}
}
bool easy2d::MouseEvent::IsCtrlDown() const
{
bool MouseEvent::IsCtrlDown() const
{
return GET_KEYSTATE_WPARAM(w_param_) == MK_CONTROL;
}
}
float easy2d::MouseEvent::GetWheelDelta() const
{
float MouseEvent::GetWheelDelta() const
{
return static_cast<float>(GET_WHEEL_DELTA_WPARAM(w_param_));
}
}
bool easy2d::MouseEvent::IsLButtonDown() const
{
bool MouseEvent::IsLButtonDown() const
{
return GET_KEYSTATE_WPARAM(w_param_) == MK_LBUTTON;
}
}
bool easy2d::MouseEvent::IsRButtonDown() const
{
bool MouseEvent::IsRButtonDown() const
{
return GET_KEYSTATE_WPARAM(w_param_) == MK_RBUTTON;
}
}
bool easy2d::MouseEvent::IsMButtonDown() const
{
bool MouseEvent::IsMButtonDown() const
{
return GET_KEYSTATE_WPARAM(w_param_) == MK_MBUTTON;
}
}
easy2d::MouseEvent::Type easy2d::MouseEvent::GetType() const
{
MouseEvent::Type MouseEvent::GetType() const
{
return Type(message_);
}
}

31
core/modules/Audio.cpp
View File

@ -21,10 +21,12 @@
#include "..\e2dmodule.h"
easy2d::Audio::Audio()
namespace easy2d
{
Audio::Audio()
: x_audio2_(nullptr)
, mastering_voice_(nullptr)
{
{
ThrowIfFailed(
MFStartup(MF_VERSION)
);
@ -36,10 +38,10 @@ easy2d::Audio::Audio()
ThrowIfFailed(
x_audio2_->CreateMasteringVoice(&mastering_voice_)
);
}
}
easy2d::Audio::~Audio()
{
Audio::~Audio()
{
if (mastering_voice_)
{
mastering_voice_->DestroyVoice();
@ -49,19 +51,20 @@ easy2d::Audio::~Audio()
SafeRelease(x_audio2_);
MFShutdown();
}
}
HRESULT easy2d::Audio::CreateVoice(IXAudio2SourceVoice ** voice, WAVEFORMATEX * wfx)
{
HRESULT Audio::CreateVoice(IXAudio2SourceVoice ** voice, WAVEFORMATEX * wfx)
{
return x_audio2_->CreateSourceVoice(voice, wfx, 0, XAUDIO2_DEFAULT_FREQ_RATIO);
}
}
void easy2d::Audio::Open()
{
void Audio::Open()
{
x_audio2_->StartEngine();
}
}
void easy2d::Audio::Close()
{
void Audio::Close()
{
x_audio2_->StopEngine();
}
}

39
core/modules/Device.cpp
View File

@ -20,34 +20,40 @@
#include "..\e2dmodule.h"
static easy2d::Graphics * graphics_device = nullptr;
static easy2d::Input * input_device = nullptr;
static easy2d::Audio * audio_device = nullptr;
easy2d::Graphics * easy2d::Device::GetGraphics()
namespace easy2d
{
namespace
{
Graphics * graphics_device = nullptr;
Input * input_device = nullptr;
Audio * audio_device = nullptr;
}
Graphics * Device::GetGraphics()
{
return graphics_device;
}
}
easy2d::Input * easy2d::Device::GetInput()
{
Input * Device::GetInput()
{
return input_device;
}
}
easy2d::Audio * easy2d::Device::GetAudio()
{
Audio * Device::GetAudio()
{
return audio_device;
}
}
void easy2d::Device::Init(HWND hwnd)
{
void Device::Init(HWND hwnd)
{
graphics_device = new (std::nothrow) Graphics(hwnd);
input_device = new (std::nothrow) Input(hwnd);
audio_device = new (std::nothrow) Audio();
}
}
void easy2d::Device::Destroy()
{
void Device::Destroy()
{
if (audio_device)
{
delete audio_device;
@ -65,4 +71,5 @@ void easy2d::Device::Destroy()
delete graphics_device;
graphics_device = nullptr;
}
}
}

142
core/modules/Game.cpp
View File

@ -30,14 +30,19 @@
#define REGISTER_CLASS L"Easy2DApp"
static easy2d::Game * instance = nullptr;
easy2d::Game * easy2d::Game::GetInstance()
namespace easy2d
{
return instance;
}
namespace
{
Game * instance = nullptr;
}
easy2d::Game::Game()
Game * Game::GetInstance()
{
return instance;
}
Game::Game()
: hwnd_(nullptr)
, quit_(true)
, curr_scene_(nullptr)
@ -48,7 +53,7 @@ easy2d::Game::Game()
, height_(480)
, icon_(0)
, debug_mode_(false)
{
{
if (instance)
{
throw std::runtime_error("同时只能存在一个游戏实例");
@ -56,10 +61,10 @@ easy2d::Game::Game()
instance = this;
::CoInitialize(nullptr);
}
}
easy2d::Game::~Game()
{
Game::~Game()
{
SafeRelease(transition_);
SafeRelease(curr_scene_);
SafeRelease(next_scene_);
@ -76,10 +81,10 @@ easy2d::Game::~Game()
instance = nullptr;
::CoUninitialize();
}
}
void easy2d::Game::Run()
{
void Game::Run()
{
// 初始化
Init();
@ -134,15 +139,15 @@ void easy2d::Game::Run()
}
}
}
}
}
void easy2d::Game::Quit()
{
void Game::Quit()
{
quit_ = true;
}
}
void easy2d::Game::EnterScene(Scene * scene, Transition * transition)
{
void Game::EnterScene(Scene * scene, Transition * transition)
{
if (scene == nullptr)
{
E2D_WARNING("Next scene is null pointer!");
@ -170,20 +175,20 @@ void easy2d::Game::EnterScene(Scene * scene, Transition * transition)
transition_->Init(curr_scene_, next_scene_, this);
}
}
}
easy2d::Scene * easy2d::Game::GetCurrentScene()
{
Scene * Game::GetCurrentScene()
{
return curr_scene_;
}
}
bool easy2d::Game::IsTransitioning() const
{
bool Game::IsTransitioning() const
{
return transition_ != nullptr;
}
}
void easy2d::Game::UpdateScene(float dt)
{
void Game::UpdateScene(float dt)
{
auto update = [&](Scene * scene) -> void
{
if (scene)
@ -228,10 +233,10 @@ void easy2d::Game::UpdateScene(float dt)
curr_scene_ = next_scene_;
next_scene_ = nullptr;
}
}
}
void easy2d::Game::DrawScene()
{
void Game::DrawScene()
{
auto graphics = Device::GetGraphics();
graphics->BeginDraw();
@ -262,10 +267,10 @@ void easy2d::Game::DrawScene()
graphics->DrawDebugInfo();
}
graphics->EndDraw();
}
}
void easy2d::Game::Init()
{
void Game::Init()
{
HINSTANCE hinstance = GetModuleHandle(nullptr);
WNDCLASSEX wcex = { 0 };
wcex.cbSize = sizeof(WNDCLASSEX);
@ -368,10 +373,10 @@ void easy2d::Game::Init()
}
quit_ = false;
}
}
easy2d::Rect easy2d::Game::Locate(int width, int height)
{
Rect Game::Locate(int width, int height)
{
int max_width = ::GetSystemMetrics(SM_CXSCREEN);
int max_height = ::GetSystemMetrics(SM_CYSCREEN);
@ -394,38 +399,38 @@ easy2d::Rect easy2d::Game::Locate(int width, int height)
static_cast<float>(width),
static_cast<float>(height)
);
}
}
int easy2d::Game::GetWidth() const
{
int Game::GetWidth() const
{
return width_;
}
}
int easy2d::Game::GetHeight() const
{
int Game::GetHeight() const
{
return height_;
}
}
easy2d::Size easy2d::Game::GetSize() const
{
return easy2d::Size(
Size Game::GetSize() const
{
return Size(
static_cast<float>(width_),
static_cast<float>(height_)
);
}
}
HWND easy2d::Game::GetHWnd() const
{
HWND Game::GetHWnd() const
{
return hwnd_;
}
}
const std::wstring& easy2d::Game::GetTitle() const
{
const std::wstring& Game::GetTitle() const
{
return title_;
}
}
void easy2d::Game::SetSize(int width, int height)
{
void Game::SetSize(int width, int height)
{
if (width_ == width && height_ == height)
return;
@ -444,20 +449,20 @@ void easy2d::Game::SetSize(int width, int height)
TRUE
);
}
}
}
void easy2d::Game::SetTitle(const std::wstring& title)
{
void Game::SetTitle(const std::wstring& title)
{
title_ = title;
if (hwnd_)
{
::SetWindowText(hwnd_, title.c_str());
}
}
}
void easy2d::Game::SetIcon(int resource_id)
{
void Game::SetIcon(int resource_id)
{
icon_ = resource_id;
if (hwnd_)
@ -475,16 +480,16 @@ void easy2d::Game::SetIcon(int resource_id)
::SendMessage(hwnd_, WM_SETICON, ICON_BIG, (LPARAM)icon);
::SendMessage(hwnd_, WM_SETICON, ICON_SMALL, (LPARAM)icon);
}
}
}
void easy2d::Game::SetDebugMode(bool enabled)
{
void Game::SetDebugMode(bool enabled)
{
debug_mode_ = enabled;
}
}
LRESULT easy2d::Game::WndProc(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param)
{
LRESULT Game::WndProc(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param)
{
LRESULT result = 0;
bool was_handled = false;
Game * game = reinterpret_cast<Game*>(
@ -616,4 +621,5 @@ LRESULT easy2d::Game::WndProc(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_para
result = ::DefWindowProc(hwnd, msg, w_param, l_param);
}
return result;
}
}

105
core/modules/Graphics.cpp
View File

@ -24,7 +24,10 @@
namespace easy2d
{
// ÎÄ×ÖäÖČžĆ÷
//-------------------------------------------------------
// TextRenderer
//-------------------------------------------------------
class TextRenderer
: public IDWriteTextRenderer
{
@ -505,10 +508,13 @@ namespace easy2d
return S_OK;
}
}
easy2d::Graphics::Graphics(HWND hwnd)
//-------------------------------------------------------
// Graphics
//-------------------------------------------------------
Graphics::Graphics(HWND hwnd)
: factory_(nullptr)
, imaging_factory_(nullptr)
, write_factory_(nullptr)
@ -521,7 +527,7 @@ easy2d::Graphics::Graphics(HWND hwnd)
, solid_brush_(nullptr)
, text_renderer_(nullptr)
, clear_color_(D2D1::ColorF(D2D1::ColorF::Black))
{
{
ThrowIfFailed(
D2D1CreateFactory(
D2D1_FACTORY_TYPE_SINGLE_THREADED,
@ -585,10 +591,10 @@ easy2d::Graphics::Graphics(HWND hwnd)
solid_brush_
)
);
}
}
easy2d::Graphics::~Graphics()
{
Graphics::~Graphics()
{
SafeRelease(fps_text_format_);
SafeRelease(fps_text_layout_);
SafeRelease(text_renderer_);
@ -601,16 +607,16 @@ easy2d::Graphics::~Graphics()
SafeRelease(factory_);
SafeRelease(imaging_factory_);
SafeRelease(write_factory_);
}
}
void easy2d::Graphics::BeginDraw()
{
void Graphics::BeginDraw()
{
render_target_->BeginDraw();
render_target_->Clear(clear_color_);
}
}
void easy2d::Graphics::EndDraw()
{
void Graphics::EndDraw()
{
HRESULT hr = render_target_->EndDraw();
if (hr == D2DERR_RECREATE_TARGET)
@ -627,10 +633,10 @@ void easy2d::Graphics::EndDraw()
}
ThrowIfFailed(hr);
}
}
void easy2d::Graphics::DrawDebugInfo()
{
void Graphics::DrawDebugInfo()
{
static int render_times_ = 0;
static Time last_render_time_ = Time::Now();
int duration = (Time::Now() - last_render_time_).Milliseconds();
@ -699,40 +705,40 @@ void easy2d::Graphics::DrawDebugInfo()
0
);
}
}
}
ID2D1HwndRenderTarget * easy2d::Graphics::GetRenderTarget() const
{
ID2D1HwndRenderTarget * Graphics::GetRenderTarget() const
{
return render_target_;
}
}
ID2D1SolidColorBrush * easy2d::Graphics::GetSolidBrush() const
{
ID2D1SolidColorBrush * Graphics::GetSolidBrush() const
{
return solid_brush_;
}
}
IDWriteTextRenderer* easy2d::Graphics::GetTextRender() const
{
IDWriteTextRenderer* Graphics::GetTextRender() const
{
return text_renderer_;
}
}
ID2D1Factory * easy2d::Graphics::GetFactory() const
{
ID2D1Factory * Graphics::GetFactory() const
{
return factory_;
}
}
IWICImagingFactory * easy2d::Graphics::GetImagingFactory() const
{
IWICImagingFactory * Graphics::GetImagingFactory() const
{
return imaging_factory_;
}
}
IDWriteFactory * easy2d::Graphics::GetWriteFactory() const
{
IDWriteFactory * Graphics::GetWriteFactory() const
{
return write_factory_;
}
}
ID2D1StrokeStyle * easy2d::Graphics::GetMiterStrokeStyle()
{
ID2D1StrokeStyle * Graphics::GetMiterStrokeStyle()
{
if (!miter_stroke_style_)
{
ThrowIfFailed(
@ -752,10 +758,10 @@ ID2D1StrokeStyle * easy2d::Graphics::GetMiterStrokeStyle()
);
}
return miter_stroke_style_;
}
}
ID2D1StrokeStyle * easy2d::Graphics::GetBevelStrokeStyle()
{
ID2D1StrokeStyle * Graphics::GetBevelStrokeStyle()
{
if (!bevel_stroke_style_)
{
ThrowIfFailed(
@ -775,10 +781,10 @@ ID2D1StrokeStyle * easy2d::Graphics::GetBevelStrokeStyle()
);
}
return bevel_stroke_style_;
}
}
ID2D1StrokeStyle * easy2d::Graphics::GetRoundStrokeStyle()
{
ID2D1StrokeStyle * Graphics::GetRoundStrokeStyle()
{
if (!round_stroke_style_)
{
ThrowIfFailed(
@ -798,10 +804,10 @@ ID2D1StrokeStyle * easy2d::Graphics::GetRoundStrokeStyle()
);
}
return round_stroke_style_;
}
}
void easy2d::Graphics::SetTextRendererStyle(const Color & fill_color, bool has_outline, const Color & outline_color, float outline_width, Stroke outline_stroke)
{
void Graphics::SetTextRendererStyle(const Color & fill_color, bool has_outline, const Color & outline_color, float outline_width, Stroke outline_stroke)
{
static_cast<TextRenderer*>(text_renderer_)->SetTextStyle(
D2D1_COLOR_F(fill_color),
has_outline,
@ -809,10 +815,10 @@ void easy2d::Graphics::SetTextRendererStyle(const Color & fill_color, bool has_o
outline_width,
D2D1_LINE_JOIN(outline_stroke)
);
}
}
float easy2d::Graphics::GetDpi()
{
float Graphics::GetDpi()
{
static float dpi = -1;
if (dpi < 0)
{
@ -821,4 +827,5 @@ float easy2d::Graphics::GetDpi()
::ReleaseDC(0, hdc);
}
return dpi;
}
}

67
core/modules/Input.cpp
View File

@ -22,11 +22,13 @@
#include "..\e2dtool.h"
easy2d::Input::Input(HWND hwnd)
namespace easy2d
{
Input::Input(HWND hwnd)
: direct_input_(nullptr)
, keyboard_device_(nullptr)
, mouse_device_(nullptr)
{
{
ZeroMemory(key_buffer_, sizeof(key_buffer_));
ZeroMemory(&mouse_state_, sizeof(mouse_state_));
@ -70,10 +72,10 @@ easy2d::Input::Input(HWND hwnd)
mouse_device_->SetDataFormat(&c_dfDIMouse);
mouse_device_->Acquire();
mouse_device_->Poll();
}
}
easy2d::Input::~Input()
{
Input::~Input()
{
if (keyboard_device_)
keyboard_device_->Unacquire();
if (mouse_device_)
@ -82,10 +84,10 @@ easy2d::Input::~Input()
SafeRelease(mouse_device_);
SafeRelease(keyboard_device_);
SafeRelease(direct_input_);
}
}
void easy2d::Input::Flush()
{
void Input::Flush()
{
if (keyboard_device_)
{
HRESULT hr = keyboard_device_->Poll();
@ -121,52 +123,53 @@ void easy2d::Input::Flush()
);
}
}
}
}
bool easy2d::Input::IsDown(KeyCode key)
{
bool Input::IsDown(KeyCode key)
{
if (key_buffer_[static_cast<int>(key)] & 0x80)
return true;
return false;
}
}
bool easy2d::Input::IsDown(MouseCode code)
{
bool Input::IsDown(MouseCode code)
{
if (mouse_state_.rgbButtons[static_cast<int>(code)] & 0x80)
return true;
return false;
}
}
float easy2d::Input::GetMouseX()
{
float Input::GetMouseX()
{
return GetMousePos().x;
}
}
float easy2d::Input::GetMouseY()
{
float Input::GetMouseY()
{
return GetMousePos().y;
}
}
easy2d::Point easy2d::Input::GetMousePos()
{
Point Input::GetMousePos()
{
POINT mousePos;
::GetCursorPos(&mousePos);
::ScreenToClient(Game::GetInstance()->GetHWnd(), &mousePos);
float dpi = Graphics::GetDpi();
return Point(mousePos.x * 96.f / dpi, mousePos.y * 96.f / dpi);
}
}
float easy2d::Input::GetMouseDeltaX()
{
float Input::GetMouseDeltaX()
{
return (float)mouse_state_.lX;
}
}
float easy2d::Input::GetMouseDeltaY()
{
float Input::GetMouseDeltaY()
{
return (float)mouse_state_.lY;
}
}
float easy2d::Input::GetMouseDeltaZ()
{
float Input::GetMouseDeltaZ()
{
return (float)mouse_state_.lZ;
}
}

121
core/objects/Canvas.cpp
View File

@ -21,14 +21,16 @@
#include "..\e2dobject.h"
#include "..\e2dmodule.h"
easy2d::Canvas::Canvas(float width, float height)
namespace easy2d
{
Canvas::Canvas(float width, float height)
: render_target_(nullptr)
, fill_brush_(nullptr)
, line_brush_(nullptr)
, stroke_style_(nullptr)
, stroke_width_(1.0f)
, stroke_(Stroke::Miter)
{
{
render_target_ = Device::GetGraphics()->GetRenderTarget();
render_target_->AddRef();
@ -50,68 +52,68 @@ easy2d::Canvas::Canvas(float width, float height)
this->SetWidth(width);
this->SetHeight(height);
this->SetStrokeStyle(stroke_);
}
}
easy2d::Canvas::~Canvas()
{
Canvas::~Canvas()
{
SafeRelease(line_brush_);
SafeRelease(fill_brush_);
SafeRelease(render_target_);
}
}
void easy2d::Canvas::SetLineColor(const Color & color)
{
void Canvas::SetLineColor(const Color & color)
{
line_brush_->SetColor(D2D_COLOR_F(color));
}
}
void easy2d::Canvas::SetFillColor(const Color & color)
{
void Canvas::SetFillColor(const Color & color)
{
fill_brush_->SetColor(D2D_COLOR_F(color));
}
}
void easy2d::Canvas::SetStrokeWidth(float width)
{
void Canvas::SetStrokeWidth(float width)
{
stroke_width_ = std::max(width, 0.f);
}
}
void easy2d::Canvas::SetStrokeStyle(Stroke strokeStyle)
{
void Canvas::SetStrokeStyle(Stroke strokeStyle)
{
switch (strokeStyle)
{
case easy2d::Stroke::Miter:
case Stroke::Miter:
stroke_style_ = Device::GetGraphics()->GetMiterStrokeStyle();
break;
case easy2d::Stroke::Bevel:
case Stroke::Bevel:
stroke_style_ = Device::GetGraphics()->GetBevelStrokeStyle();
break;
case easy2d::Stroke::Round:
case Stroke::Round:
stroke_style_ = Device::GetGraphics()->GetRoundStrokeStyle();
break;
}
}
}
easy2d::Color easy2d::Canvas::GetLineColor() const
{
Color Canvas::GetLineColor() const
{
return line_brush_->GetColor();
}
}
easy2d::Color easy2d::Canvas::GetFillColor() const
{
Color Canvas::GetFillColor() const
{
return fill_brush_->GetColor();
}
}
float easy2d::Canvas::GetStrokeWidth() const
{
float Canvas::GetStrokeWidth() const
{
return stroke_width_;
}
}
easy2d::Stroke easy2d::Canvas::GetStrokeStyle() const
{
Stroke Canvas::GetStrokeStyle() const
{
return stroke_;
}
}
void easy2d::Canvas::DrawLine(const Point & begin, const Point & end)
{
void Canvas::DrawLine(const Point & begin, const Point & end)
{
render_target_->DrawLine(
D2D1::Point2F(begin.x, begin.y),
D2D1::Point2F(end.x, end.y),
@ -119,10 +121,10 @@ void easy2d::Canvas::DrawLine(const Point & begin, const Point & end)
stroke_width_,
stroke_style_
);
}
}
void easy2d::Canvas::DrawCircle(const Point & center, float radius)
{
void Canvas::DrawCircle(const Point & center, float radius)
{
render_target_->DrawEllipse(
D2D1::Ellipse(
D2D1::Point2F(
@ -136,10 +138,10 @@ void easy2d::Canvas::DrawCircle(const Point & center, float radius)
stroke_width_,
stroke_style_
);
}
}
void easy2d::Canvas::DrawEllipse(const Point & center, float radius_x, float radius_y)
{
void Canvas::DrawEllipse(const Point & center, float radius_x, float radius_y)
{
render_target_->DrawEllipse(
D2D1::Ellipse(
D2D1::Point2F(
@ -153,10 +155,10 @@ void easy2d::Canvas::DrawEllipse(const Point & center, float radius_x, float rad
stroke_width_,
stroke_style_
);
}
}
void easy2d::Canvas::DrawRect(const Rect & rect)
{
void Canvas::DrawRect(const Rect & rect)
{
render_target_->DrawRectangle(
D2D1::RectF(
rect.origin.x,
@ -168,10 +170,10 @@ void easy2d::Canvas::DrawRect(const Rect & rect)
stroke_width_,
stroke_style_
);
}
}
void easy2d::Canvas::DrawRoundedRect(const Rect & rect, float radius_x, float radius_y)
{
void Canvas::DrawRoundedRect(const Rect & rect, float radius_x, float radius_y)
{
render_target_->DrawRoundedRectangle(
D2D1::RoundedRect(
D2D1::RectF(
@ -187,10 +189,10 @@ void easy2d::Canvas::DrawRoundedRect(const Rect & rect, float radius_x, float ra
stroke_width_,
stroke_style_
);
}
}
void easy2d::Canvas::FillCircle(const Point & center, float radius)
{
void Canvas::FillCircle(const Point & center, float radius)
{
render_target_->FillEllipse(
D2D1::Ellipse(
D2D1::Point2F(
@ -202,10 +204,10 @@ void easy2d::Canvas::FillCircle(const Point & center, float radius)
),
fill_brush_
);
}
}
void easy2d::Canvas::FillEllipse(const Point & center, float radius_x, float radius_y)
{
void Canvas::FillEllipse(const Point & center, float radius_x, float radius_y)
{
render_target_->FillEllipse(
D2D1::Ellipse(
D2D1::Point2F(
@ -217,10 +219,10 @@ void easy2d::Canvas::FillEllipse(const Point & center, float radius_x, float rad
),
fill_brush_
);
}
}
void easy2d::Canvas::FillRect(const Rect & rect)
{
void Canvas::FillRect(const Rect & rect)
{
render_target_->FillRectangle(
D2D1::RectF(
rect.origin.x,
@ -230,10 +232,10 @@ void easy2d::Canvas::FillRect(const Rect & rect)
),
fill_brush_
);
}
}
void easy2d::Canvas::FillRoundedRect(const Rect & rect, float radius_x, float radius_y)
{
void Canvas::FillRoundedRect(const Rect & rect, float radius_x, float radius_y)
{
render_target_->FillRoundedRectangle(
D2D1::RoundedRect(
D2D1::RectF(
@ -247,4 +249,5 @@ void easy2d::Canvas::FillRoundedRect(const Rect & rect, float radius_x, float ra
),
fill_brush_
);
}
}

147
core/objects/Image.cpp
View File

@ -22,51 +22,53 @@
#include "..\e2dmodule.h"
#include "..\e2dtool.h"
std::map<size_t, ID2D1Bitmap*> easy2d::Image::bitmap_cache_;
namespace easy2d
{
std::map<size_t, ID2D1Bitmap*> Image::bitmap_cache_;
easy2d::Image::Image()
Image::Image()
: bitmap_(nullptr)
, crop_rect_()
{
}
{
}
easy2d::Image::Image(Resource& res)
Image::Image(Resource& res)
: bitmap_(nullptr)
, crop_rect_()
{
{
this->Load(res);
}
}
easy2d::Image::Image(Resource& res, const Rect& crop_rect)
Image::Image(Resource& res, const Rect& crop_rect)
: bitmap_(nullptr)
, crop_rect_()
{
{
this->Load(res);
this->Crop(crop_rect);
}
}
easy2d::Image::Image(const std::wstring & file_name)
Image::Image(const std::wstring & file_name)
: bitmap_(nullptr)
, crop_rect_()
{
{
this->Load(file_name);
}
}
easy2d::Image::Image(const std::wstring & file_name, const Rect & crop_rect)
Image::Image(const std::wstring & file_name, const Rect & crop_rect)
: bitmap_(nullptr)
, crop_rect_()
{
{
this->Load(file_name);
this->Crop(crop_rect);
}
}
easy2d::Image::~Image()
{
Image::~Image()
{
SafeRelease(bitmap_);
}
}
bool easy2d::Image::Load(Resource& res)
{
bool Image::Load(Resource& res)
{
if (!Image::CacheBitmap(res))
{
E2D_WARNING("Load Image from file failed!");
@ -75,10 +77,10 @@ bool easy2d::Image::Load(Resource& res)
this->SetBitmap(bitmap_cache_.at(res.GetHashCode()));
return true;
}
}
bool easy2d::Image::Load(const std::wstring & file_name)
{
bool Image::Load(const std::wstring & file_name)
{
E2D_WARNING_IF(file_name.empty(), "Image Load failed! Invalid file name.");
if (file_name.empty())
@ -92,10 +94,10 @@ bool easy2d::Image::Load(const std::wstring & file_name)
this->SetBitmap(bitmap_cache_.at(std::hash<std::wstring>{}(file_name)));
return true;
}
}
void easy2d::Image::Crop(const Rect& crop_rect)
{
void Image::Crop(const Rect& crop_rect)
{
if (bitmap_)
{
auto bitmap_size = bitmap_->GetSize();
@ -104,25 +106,25 @@ void easy2d::Image::Crop(const Rect& crop_rect)
crop_rect_.size.width = std::min(std::max(crop_rect.size.width, 0.f), bitmap_size.width - crop_rect.origin.x);
crop_rect_.size.height = std::min(std::max(crop_rect.size.height, 0.f), bitmap_size.height - crop_rect.origin.y);
}
}
}
float easy2d::Image::GetWidth() const
{
float Image::GetWidth() const
{
return crop_rect_.size.width;
}
}
float easy2d::Image::GetHeight() const
{
float Image::GetHeight() const
{
return crop_rect_.size.height;
}
}
easy2d::Size easy2d::Image::GetSize() const
{
Size Image::GetSize() const
{
return crop_rect_.size;
}
}
float easy2d::Image::GetSourceWidth() const
{
float Image::GetSourceWidth() const
{
if (bitmap_)
{
return bitmap_->GetSize().width;
@ -131,10 +133,10 @@ float easy2d::Image::GetSourceWidth() const
{
return 0;
}
}
}
float easy2d::Image::GetSourceHeight() const
{
float Image::GetSourceHeight() const
{
if (bitmap_)
{
return bitmap_->GetSize().height;
@ -143,45 +145,45 @@ float easy2d::Image::GetSourceHeight() const
{
return 0;
}
}
}
easy2d::Size easy2d::Image::GetSourceSize() const
{
Size Image::GetSourceSize() const
{
if (bitmap_)
{
auto bitmap_size = bitmap_->GetSize();
return Size{ bitmap_size.width, bitmap_size.height };
}
return Size{};
}
}
float easy2d::Image::GetCropX() const
{
float Image::GetCropX() const
{
return crop_rect_.origin.x;
}
}
float easy2d::Image::GetCropY() const
{
float Image::GetCropY() const
{
return crop_rect_.origin.y;
}
}
easy2d::Point easy2d::Image::GetCropPos() const
{
Point Image::GetCropPos() const
{
return crop_rect_.origin;
}
}
const easy2d::Rect & easy2d::Image::GetCropRect() const
{
const Rect & Image::GetCropRect() const
{
return crop_rect_;
}
}
ID2D1Bitmap * easy2d::Image::GetBitmap() const
{
ID2D1Bitmap * Image::GetBitmap() const
{
return bitmap_;
}
}
bool easy2d::Image::CacheBitmap(Resource& res)
{
bool Image::CacheBitmap(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (bitmap_cache_.find(hash_code) != bitmap_cache_.end())
{
@ -275,10 +277,10 @@ bool easy2d::Image::CacheBitmap(Resource& res)
SafeRelease(converter);
return SUCCEEDED(hr);
}
}
bool easy2d::Image::CacheBitmap(const std::wstring & file_name)
{
bool Image::CacheBitmap(const std::wstring & file_name)
{
size_t hash_code = std::hash<std::wstring>{}(file_name);
if (bitmap_cache_.find(hash_code) != bitmap_cache_.end())
return true;
@ -356,10 +358,10 @@ bool easy2d::Image::CacheBitmap(const std::wstring & file_name)
SafeRelease(converter);
return SUCCEEDED(hr);
}
}
void easy2d::Image::ClearCache()
{
void Image::ClearCache()
{
if (bitmap_cache_.empty())
return;
@ -368,10 +370,10 @@ void easy2d::Image::ClearCache()
bitmap.second->Release();
}
bitmap_cache_.clear();
}
}
void easy2d::Image::SetBitmap(ID2D1Bitmap * bitmap)
{
void Image::SetBitmap(ID2D1Bitmap * bitmap)
{
if (bitmap_ == bitmap)
return;
@ -389,4 +391,5 @@ void easy2d::Image::SetBitmap(ID2D1Bitmap * bitmap)
crop_rect_.size.width = bitmap_->GetSize().width;
crop_rect_.size.height = bitmap_->GetSize().height;
}
}
}

553
core/objects/Node.cpp
View File

@ -25,7 +25,9 @@
#include <iterator>
easy2d::Node::Node()
namespace easy2d
{
Node::Node()
: visible_(true)
, parent_(nullptr)
, parent_scene_(nullptr)
@ -44,11 +46,11 @@ easy2d::Node::Node()
, initial_matrix_(D2D1::Matrix3x2F::Identity())
, final_matrix_(D2D1::Matrix3x2F::Identity())
, border_color_(Color::Red, 0.6f)
{
}
{
}
easy2d::Node::~Node()
{
Node::~Node()
{
SafeRelease(border_);
for (auto action : actions_)
@ -65,10 +67,10 @@ easy2d::Node::~Node()
{
SafeRelease(child);
}
}
}
void easy2d::Node::Visit()
{
void Node::Visit()
{
if (!visible_)
return;
@ -128,10 +130,10 @@ void easy2d::Node::Visit()
{
render_target->PopAxisAlignedClip();
}
}
}
void easy2d::Node::UpdateChildren(float dt)
{
void Node::UpdateChildren(float dt)
{
if (children_.empty())
{
OnUpdate(dt);
@ -165,10 +167,10 @@ void easy2d::Node::UpdateChildren(float dt)
for (; i < children_.size(); ++i)
children_[i]->UpdateChildren(dt);
}
}
}
void easy2d::Node::DrawBorder()
{
void Node::DrawBorder()
{
if (visible_)
{
if (border_)
@ -188,10 +190,10 @@ void easy2d::Node::DrawBorder()
child->DrawBorder();
}
}
}
}
void easy2d::Node::UpdateTransform()
{
void Node::UpdateTransform()
{
if (!dirty_transform_)
return;
@ -245,10 +247,10 @@ void easy2d::Node::UpdateTransform()
{
child->dirty_transform_ = true;
}
}
}
bool easy2d::Node::Dispatch(const MouseEvent & e, bool handled)
{
bool Node::Dispatch(const MouseEvent & e, bool handled)
{
if (visible_)
{
for (auto riter = children_.crbegin(); riter != children_.crend(); ++riter)
@ -260,10 +262,10 @@ bool easy2d::Node::Dispatch(const MouseEvent & e, bool handled)
}
return handled;
}
}
bool easy2d::Node::Dispatch(const KeyEvent & e, bool handled)
{
bool Node::Dispatch(const KeyEvent & e, bool handled)
{
if (visible_)
{
for (auto riter = children_.crbegin(); riter != children_.crend(); ++riter)
@ -275,10 +277,10 @@ bool easy2d::Node::Dispatch(const KeyEvent & e, bool handled)
}
return handled;
}
}
void easy2d::Node::UpdateOpacity()
{
void Node::UpdateOpacity()
{
if (parent_)
{
display_opacity_ = real_opacity_ * parent_->display_opacity_;
@ -287,10 +289,10 @@ void easy2d::Node::UpdateOpacity()
{
child->UpdateOpacity();
}
}
}
void easy2d::Node::UpdateActions()
{
void Node::UpdateActions()
{
if (actions_.empty())
return;
@ -320,115 +322,115 @@ void easy2d::Node::UpdateActions()
++iter;
}
}
}
}
bool easy2d::Node::IsVisible() const
{
bool Node::IsVisible() const
{
return visible_;
}
}
const std::wstring& easy2d::Node::GetName() const
{
const std::wstring& Node::GetName() const
{
return name_;
}
}
size_t easy2d::Node::GetHashName() const
{
size_t Node::GetHashName() const
{
return hash_name_;
}
}
const easy2d::Point& easy2d::Node::GetPosition() const
{
const Point& Node::GetPosition() const
{
return transform_.position;
}
}
float easy2d::Node::GetWidth() const
{
float Node::GetWidth() const
{
return transform_.size.width * transform_.scale_x;
}
}
float easy2d::Node::GetHeight() const
{
float Node::GetHeight() const
{
return transform_.size.height * transform_.scale_y;
}
}
float easy2d::Node::GetRealWidth() const
{
float Node::GetRealWidth() const
{
return transform_.size.width;
}
}
float easy2d::Node::GetRealHeight() const
{
float Node::GetRealHeight() const
{
return transform_.size.height;
}
}
const easy2d::Size& easy2d::Node::GetRealSize() const
{
const Size& Node::GetRealSize() const
{
return transform_.size;
}
}
float easy2d::Node::GetPivotX() const
{
float Node::GetPivotX() const
{
return transform_.pivot_x;
}
}
float easy2d::Node::GetPivotY() const
{
float Node::GetPivotY() const
{
return transform_.pivot_y;
}
}
easy2d::Size easy2d::Node::GetSize() const
{
Size Node::GetSize() const
{
return Size{ GetWidth(), GetHeight() };
}
}
float easy2d::Node::GetScaleX() const
{
float Node::GetScaleX() const
{
return transform_.scale_x;
}
}
float easy2d::Node::GetScaleY() const
{
float Node::GetScaleY() const
{
return transform_.scale_y;
}
}
float easy2d::Node::GetSkewX() const
{
float Node::GetSkewX() const
{
return transform_.skew_x;
}
}
float easy2d::Node::GetSkewY() const
{
float Node::GetSkewY() const
{
return transform_.skew_y;
}
}
float easy2d::Node::GetRotation() const
{
float Node::GetRotation() const
{
return transform_.rotation;
}
}
const easy2d::Transform & easy2d::Node::GetTransform() const
{
const Transform & Node::GetTransform() const
{
return transform_;
}
}
float easy2d::Node::GetOpacity() const
{
float Node::GetOpacity() const
{
return real_opacity_;
}
}
float easy2d::Node::GetDisplayOpacity() const
{
float Node::GetDisplayOpacity() const
{
return display_opacity_;
}
}
int easy2d::Node::GetOrder() const
{
int Node::GetOrder() const
{
return order_;
}
}
void easy2d::Node::SetOrder(int order)
{
void Node::SetOrder(int order)
{
if (order_ == order)
return;
@ -437,170 +439,170 @@ void easy2d::Node::SetOrder(int order)
{
parent_->dirty_sort_ = true;
}
}
}
void easy2d::Node::SetPositionX(float x)
{
void Node::SetPositionX(float x)
{
this->SetPosition(x, transform_.position.y);
}
}
void easy2d::Node::SetPositionY(float y)
{
void Node::SetPositionY(float y)
{
this->SetPosition(transform_.position.x, y);
}
}
void easy2d::Node::SetPosition(const Point & p)
{
void Node::SetPosition(const Point & p)
{
this->SetPosition(p.x, p.y);
}
}
void easy2d::Node::SetPosition(float x, float y)
{
void Node::SetPosition(float x, float y)
{
if (transform_.position.x == x && transform_.position.y == y)
return;
transform_.position.x = x;
transform_.position.y = y;
dirty_transform_ = true;
}
}
void easy2d::Node::MoveBy(float x, float y)
{
void Node::MoveBy(float x, float y)
{
this->SetPosition(transform_.position.x + x, transform_.position.y + y);
}
}
void easy2d::Node::MoveBy(const Point & v)
{
void Node::MoveBy(const Point & v)
{
this->MoveBy(v.x, v.y);
}
}
void easy2d::Node::SetScaleX(float scale_x)
{
void Node::SetScaleX(float scale_x)
{
this->SetScale(scale_x, transform_.scale_y);
}
}
void easy2d::Node::SetScaleY(float scale_y)
{
void Node::SetScaleY(float scale_y)
{
this->SetScale(transform_.scale_x, scale_y);
}
}
void easy2d::Node::SetScale(float scale)
{
void Node::SetScale(float scale)
{
this->SetScale(scale, scale);
}
}
void easy2d::Node::SetScale(float scale_x, float scale_y)
{
void Node::SetScale(float scale_x, float scale_y)
{
if (transform_.scale_x == scale_x && transform_.scale_y == scale_y)
return;
transform_.scale_x = scale_x;
transform_.scale_y = scale_y;
dirty_transform_ = true;
}
}
void easy2d::Node::SetSkewX(float skew_x)
{
void Node::SetSkewX(float skew_x)
{
this->SetSkew(skew_x, transform_.skew_y);
}
}
void easy2d::Node::SetSkewY(float skew_y)
{
void Node::SetSkewY(float skew_y)
{
this->SetSkew(transform_.skew_x, skew_y);
}
}
void easy2d::Node::SetSkew(float skew_x, float skew_y)
{
void Node::SetSkew(float skew_x, float skew_y)
{
if (transform_.skew_x == skew_x && transform_.skew_y == skew_y)
return;
transform_.skew_x = skew_x;
transform_.skew_y = skew_y;
dirty_transform_ = true;
}
}
void easy2d::Node::SetRotation(float angle)
{
void Node::SetRotation(float angle)
{
if (transform_.rotation == angle)
return;
transform_.rotation = angle;
dirty_transform_ = true;
}
}
void easy2d::Node::SetOpacity(float opacity)
{
void Node::SetOpacity(float opacity)
{
if (real_opacity_ == opacity)
return;
display_opacity_ = real_opacity_ = std::min(std::max(opacity, 0.f), 1.f);
// 更新节点透明度
UpdateOpacity();
}
}
void easy2d::Node::SetPivotX(float pivot_x)
{
void Node::SetPivotX(float pivot_x)
{
this->SetPivot(pivot_x, transform_.pivot_y);
}
}
void easy2d::Node::SetPivotY(float pivot_y)
{
void Node::SetPivotY(float pivot_y)
{
this->SetPivot(transform_.pivot_x, pivot_y);
}
}
void easy2d::Node::SetPivot(float pivot_x, float pivot_y)
{
void Node::SetPivot(float pivot_x, float pivot_y)
{
if (transform_.pivot_x == pivot_x && transform_.pivot_y == pivot_y)
return;
transform_.pivot_x = pivot_x;
transform_.pivot_y = pivot_y;
dirty_transform_ = true;
}
}
void easy2d::Node::SetWidth(float width)
{
void Node::SetWidth(float width)
{
this->SetSize(width, transform_.size.height);
}
}
void easy2d::Node::SetHeight(float height)
{
void Node::SetHeight(float height)
{
this->SetSize(transform_.size.width, height);
}
}
void easy2d::Node::SetSize(float width, float height)
{
void Node::SetSize(float width, float height)
{
if (transform_.size.width == width && transform_.size.height == height)
return;
transform_.size.width = width;
transform_.size.height = height;
dirty_transform_ = true;
}
}
void easy2d::Node::SetSize(const Size& size)
{
void Node::SetSize(const Size& size)
{
this->SetSize(size.width, size.height);
}
}
void easy2d::Node::SetTransform(const Transform & transform)
{
void Node::SetTransform(const Transform & transform)
{
transform_ = transform;
dirty_transform_ = true;
}
}
void easy2d::Node::SetClipEnabled(bool enabled)
{
void Node::SetClipEnabled(bool enabled)
{
clip_enabled_ = enabled;
}
}
void easy2d::Node::SetBorderColor(const Color & color)
{
void Node::SetBorderColor(const Color & color)
{
border_color_ = color;
}
}
void easy2d::Node::AddChild(Node * child, int order)
{
void Node::AddChild(Node * child, int order)
{
E2D_WARNING_IF(child == nullptr, "Node::AddChild NULL pointer exception.");
if (child)
@ -634,28 +636,28 @@ void easy2d::Node::AddChild(Node * child, int order)
// 更新子节点排序
dirty_sort_ = true;
}
}
}
void easy2d::Node::AddChild(const Nodes& nodes, int order)
{
void Node::AddChild(const Nodes& nodes, int order)
{
for (const auto& node : nodes)
{
this->AddChild(node, order);
}
}
}
easy2d::Node * easy2d::Node::GetParent() const
{
Node * Node::GetParent() const
{
return parent_;
}
}
easy2d::Scene * easy2d::Node::GetParentScene() const
{
Scene * Node::GetParentScene() const
{
return parent_scene_;
}
}
easy2d::Node::Nodes easy2d::Node::GetChildren(const std::wstring& name) const
{
Node::Nodes Node::GetChildren(const std::wstring& name) const
{
Nodes children;
size_t hash_code = std::hash<std::wstring>{}(name);
@ -668,10 +670,10 @@ easy2d::Node::Nodes easy2d::Node::GetChildren(const std::wstring& name) const
}
}
return children;
}
}
easy2d::Node * easy2d::Node::GetChild(const std::wstring& name) const
{
Node * Node::GetChild(const std::wstring& name) const
{
size_t hash_code = std::hash<std::wstring>{}(name);
for (const auto& child : children_)
@ -683,28 +685,28 @@ easy2d::Node * easy2d::Node::GetChild(const std::wstring& name) const
}
}
return nullptr;
}
}
const std::vector<easy2d::Node*>& easy2d::Node::GetAllChildren() const
{
const std::vector<Node*>& Node::GetAllChildren() const
{
return children_;
}
}
int easy2d::Node::GetChildrenCount() const
{
int Node::GetChildrenCount() const
{
return static_cast<int>(children_.size());
}
}
void easy2d::Node::RemoveFromParent()
{
void Node::RemoveFromParent()
{
if (parent_)
{
parent_->RemoveChild(this);
}
}
}
bool easy2d::Node::RemoveChild(Node * child)
{
bool Node::RemoveChild(Node * child)
{
E2D_WARNING_IF(child == nullptr, "Node::RemoveChildren NULL pointer exception.");
if (children_.empty())
@ -730,10 +732,10 @@ bool easy2d::Node::RemoveChild(Node * child)
}
}
return false;
}
}
void easy2d::Node::RemoveChildren(const std::wstring& child_name)
{
void Node::RemoveChildren(const std::wstring& child_name)
{
if (children_.empty())
{
return;
@ -757,10 +759,10 @@ void easy2d::Node::RemoveChildren(const std::wstring& child_name)
++iter;
}
}
}
}
void easy2d::Node::RemoveAllChildren()
{
void Node::RemoveAllChildren()
{
// 所有节点的引用计数减一
for (const auto& child : children_)
{
@ -768,10 +770,10 @@ void easy2d::Node::RemoveAllChildren()
}
// 清空储存节点的容器
children_.clear();
}
}
void easy2d::Node::RunAction(Action * action)
{
void Node::RunAction(Action * action)
{
E2D_WARNING_IF(action == nullptr, "Action NULL pointer exception!");
if (action)
@ -791,10 +793,10 @@ void easy2d::Node::RunAction(Action * action)
throw std::runtime_error("该 Action 已有执行目标");
}
}
}
}
void easy2d::Node::ResumeAction(const std::wstring& name)
{
void Node::ResumeAction(const std::wstring& name)
{
if (actions_.empty())
return;
@ -805,10 +807,10 @@ void easy2d::Node::ResumeAction(const std::wstring& name)
action->Resume();
}
}
}
}
void easy2d::Node::PauseAction(const std::wstring& name)
{
void Node::PauseAction(const std::wstring& name)
{
if (actions_.empty())
return;
@ -819,10 +821,10 @@ void easy2d::Node::PauseAction(const std::wstring& name)
action->Pause();
}
}
}
}
void easy2d::Node::StopAction(const std::wstring& name)
{
void Node::StopAction(const std::wstring& name)
{
if (actions_.empty())
return;
@ -833,10 +835,10 @@ void easy2d::Node::StopAction(const std::wstring& name)
action->Stop();
}
}
}
}
bool easy2d::Node::ContainsPoint(const Point& point)
{
bool Node::ContainsPoint(const Point& point)
{
if (transform_.size.width == 0.f || transform_.size.height == 0.f)
return false;
@ -851,10 +853,10 @@ bool easy2d::Node::ContainsPoint(const Point& point)
)
);
return ret != 0;
}
}
bool easy2d::Node::Intersects(Node * node)
{
bool Node::Intersects(Node * node)
{
if (transform_.size.width == 0.f || transform_.size.height == 0.f || node->transform_.size.width == 0.f || node->transform_.size.height == 0.f)
return false;
@ -873,10 +875,10 @@ bool easy2d::Node::Intersects(Node * node)
);
return relation != D2D1_GEOMETRY_RELATION_UNKNOWN &&
relation != D2D1_GEOMETRY_RELATION_DISJOINT;
}
}
void easy2d::Node::ResumeAllActions()
{
void Node::ResumeAllActions()
{
if (actions_.empty())
return;
@ -884,10 +886,10 @@ void easy2d::Node::ResumeAllActions()
{
action->Resume();
}
}
}
void easy2d::Node::PauseAllActions()
{
void Node::PauseAllActions()
{
if (actions_.empty())
return;
@ -895,10 +897,10 @@ void easy2d::Node::PauseAllActions()
{
action->Pause();
}
}
}
void easy2d::Node::StopAllActions()
{
void Node::StopAllActions()
{
if (actions_.empty())
return;
@ -906,15 +908,15 @@ void easy2d::Node::StopAllActions()
{
action->Stop();
}
}
}
const easy2d::Node::Actions & easy2d::Node::GetAllActions() const
{
const Node::Actions & Node::GetAllActions() const
{
return actions_;
}
}
void easy2d::Node::AddTask(Task * task)
{
void Node::AddTask(Task * task)
{
if (task)
{
auto iter = std::find(tasks_.begin(), tasks_.end(), task);
@ -925,10 +927,10 @@ void easy2d::Node::AddTask(Task * task)
tasks_.push_back(task);
}
}
}
}
void easy2d::Node::StopTasks(const std::wstring& name)
{
void Node::StopTasks(const std::wstring& name)
{
for (const auto& task : tasks_)
{
if (task->GetName() == name)
@ -936,10 +938,10 @@ void easy2d::Node::StopTasks(const std::wstring& name)
task->Stop();
}
}
}
}
void easy2d::Node::StartTasks(const std::wstring& name)
{
void Node::StartTasks(const std::wstring& name)
{
for (const auto& task : tasks_)
{
if (task->GetName() == name)
@ -947,10 +949,10 @@ void easy2d::Node::StartTasks(const std::wstring& name)
task->Start();
}
}
}
}
void easy2d::Node::RemoveTasks(const std::wstring& name)
{
void Node::RemoveTasks(const std::wstring& name)
{
for (const auto& task : tasks_)
{
if (task->GetName() == name)
@ -958,39 +960,39 @@ void easy2d::Node::RemoveTasks(const std::wstring& name)
task->stopped_ = true;
}
}
}
}
void easy2d::Node::StopAllTasks()
{
void Node::StopAllTasks()
{
for (const auto& task : tasks_)
{
task->Stop();
}
}
}
void easy2d::Node::StartAllTasks()
{
void Node::StartAllTasks()
{
for (const auto& task : tasks_)
{
task->Start();
}
}
}
void easy2d::Node::RemoveAllTasks()
{
void Node::RemoveAllTasks()
{
for (const auto& task : tasks_)
{
task->stopped_ = true;
}
}
}
const easy2d::Node::Tasks & easy2d::Node::GetAllTasks() const
{
const Node::Tasks & Node::GetAllTasks() const
{
return tasks_;
}
}
void easy2d::Node::UpdateTasks()
{
void Node::UpdateTasks()
{
if (tasks_.empty())
return;
@ -1020,10 +1022,10 @@ void easy2d::Node::UpdateTasks()
++iter;
}
}
}
}
void easy2d::Node::UpdateTime()
{
void Node::UpdateTime()
{
for (const auto& action : actions_)
{
action->ResetTime();
@ -1038,15 +1040,15 @@ void easy2d::Node::UpdateTime()
{
child->UpdateTime();
}
}
}
void easy2d::Node::SetVisible(bool value)
{
void Node::SetVisible(bool value)
{
visible_ = value;
}
}
void easy2d::Node::SetName(const std::wstring& name)
{
void Node::SetName(const std::wstring& name)
{
if (name_ != name)
{
// 保存节点名
@ -1054,13 +1056,14 @@ void easy2d::Node::SetName(const std::wstring& name)
// 保存节点 Hash 名
hash_name_ = std::hash<std::wstring>{}(name);
}
}
}
void easy2d::Node::SetParentScene(Scene * scene)
{
void Node::SetParentScene(Scene * scene)
{
parent_scene_ = scene;
for (const auto& child : children_)
{
child->SetParentScene(scene);
}
}
}

61
core/objects/Scene.cpp
View File

@ -21,30 +21,32 @@
#include "..\e2dmodule.h"
#include "..\e2dobject.h"
easy2d::Scene::Scene()
namespace easy2d
{
Scene::Scene()
: root_(nullptr)
, transform_(D2D1::Matrix3x2F::Identity())
{
}
{
}
easy2d::Scene::Scene(Node * root)
Scene::Scene(Node * root)
: root_(nullptr)
, transform_(D2D1::Matrix3x2F::Identity())
{
{
this->SetRoot(root);
}
}
easy2d::Scene::~Scene()
{
Scene::~Scene()
{
if (root_)
{
root_->SetParentScene(nullptr);
root_->Release();
}
}
}
void easy2d::Scene::SetRoot(Node * root)
{
void Scene::SetRoot(Node * root)
{
if (root_ == root)
return;
@ -61,23 +63,23 @@ void easy2d::Scene::SetRoot(Node * root)
}
root_ = root;
}
}
easy2d::Node * easy2d::Scene::GetRoot() const
{
Node * Scene::GetRoot() const
{
return root_;
}
}
void easy2d::Scene::Draw()
{
void Scene::Draw()
{
if (root_)
{
root_->Visit();
}
}
}
void easy2d::Scene::Dispatch(const MouseEvent & e)
{
void Scene::Dispatch(const MouseEvent & e)
{
auto handler = dynamic_cast<MouseEventHandler*>(this);
if (handler)
{
@ -88,10 +90,10 @@ void easy2d::Scene::Dispatch(const MouseEvent & e)
{
root_->Dispatch(e, false);
}
}
}
void easy2d::Scene::Dispatch(const KeyEvent & e)
{
void Scene::Dispatch(const KeyEvent & e)
{
auto handler = dynamic_cast<KeyEventHandler*>(this);
if (handler)
{
@ -102,19 +104,20 @@ void easy2d::Scene::Dispatch(const KeyEvent & e)
{
root_->Dispatch(e, false);
}
}
}
void easy2d::Scene::SetTransform(const D2D1::Matrix3x2F& matrix)
{
void Scene::SetTransform(const D2D1::Matrix3x2F& matrix)
{
transform_ = matrix;
if (root_)
{
root_->dirty_transform_ = true;
}
}
}
const D2D1::Matrix3x2F & easy2d::Scene::GetTransform() const
{
const D2D1::Matrix3x2F & Scene::GetTransform() const
{
return transform_;
}
}

79
core/objects/Sprite.cpp
View File

@ -21,50 +21,52 @@
#include "..\e2dobject.h"
#include "..\e2dmodule.h"
easy2d::Sprite::Sprite()
: image_(nullptr)
namespace easy2d
{
}
Sprite::Sprite()
: image_(nullptr)
{
}
easy2d::Sprite::Sprite(Image * image)
Sprite::Sprite(Image * image)
: image_(nullptr)
{
{
Load(image);
}
}
easy2d::Sprite::Sprite(Resource& res)
Sprite::Sprite(Resource& res)
: image_(nullptr)
{
{
Load(res);
}
}
easy2d::Sprite::Sprite(Resource& res, const Rect& crop_rect)
Sprite::Sprite(Resource& res, const Rect& crop_rect)
: image_(nullptr)
{
{
Load(res);
Crop(crop_rect);
}
}
easy2d::Sprite::Sprite(const std::wstring & file_name)
Sprite::Sprite(const std::wstring & file_name)
: image_(nullptr)
{
{
Load(file_name);
}
}
easy2d::Sprite::Sprite(const std::wstring & file_name, const Rect & crop_rect)
Sprite::Sprite(const std::wstring & file_name, const Rect & crop_rect)
: image_(nullptr)
{
{
Load(file_name);
Crop(crop_rect);
}
}
easy2d::Sprite::~Sprite()
{
Sprite::~Sprite()
{
SafeRelease(image_);
}
}
bool easy2d::Sprite::Load(Image * image)
{
bool Sprite::Load(Image * image)
{
if (image)
{
if (image_)
@ -79,10 +81,10 @@ bool easy2d::Sprite::Load(Image * image)
return true;
}
return false;
}
}
bool easy2d::Sprite::Load(Resource& res)
{
bool Sprite::Load(Resource& res)
{
if (!image_)
{
image_ = new Image();
@ -95,10 +97,10 @@ bool easy2d::Sprite::Load(Resource& res)
return true;
}
return false;
}
}
bool easy2d::Sprite::Load(const std::wstring & file_name)
{
bool Sprite::Load(const std::wstring & file_name)
{
if (!image_)
{
image_ = new Image();
@ -111,24 +113,24 @@ bool easy2d::Sprite::Load(const std::wstring & file_name)
return true;
}
return false;
}
}
void easy2d::Sprite::Crop(const Rect& crop_rect)
{
void Sprite::Crop(const Rect& crop_rect)
{
image_->Crop(crop_rect);
Node::SetSize(
std::min(std::max(crop_rect.size.width, 0.f), image_->GetSourceWidth() - image_->GetCropX()),
std::min(std::max(crop_rect.size.height, 0.f), image_->GetSourceHeight() - image_->GetCropY())
);
}
}
easy2d::Image * easy2d::Sprite::GetImage() const
{
Image * Sprite::GetImage() const
{
return image_;
}
}
void easy2d::Sprite::OnDraw() const
{
void Sprite::OnDraw() const
{
if (image_ && image_->GetBitmap())
{
auto crop_pos = image_->GetCropPos();
@ -145,4 +147,5 @@ void easy2d::Sprite::OnDraw() const
)
);
}
}
}

55
core/objects/Task.cpp
View File

@ -21,7 +21,9 @@
#include "..\e2dobject.h"
easy2d::Task::Task(const Callback & func, const std::wstring & name)
namespace easy2d
{
Task::Task(const Callback & func, const std::wstring & name)
: running_(true)
, stopped_(false)
, run_times_(0)
@ -29,10 +31,10 @@ easy2d::Task::Task(const Callback & func, const std::wstring & name)
, delay_()
, callback_(func)
, name_(name)
{
}
{
}
easy2d::Task::Task(const Callback & func, float delay, int times, const std::wstring & name)
Task::Task(const Callback & func, float delay, int times, const std::wstring & name)
: running_(true)
, stopped_(false)
, run_times_(0)
@ -40,22 +42,22 @@ easy2d::Task::Task(const Callback & func, float delay, int times, const std::wst
, total_times_(times)
, callback_(func)
, name_(name)
{
}
{
}
void easy2d::Task::Start()
{
void Task::Start()
{
running_ = true;
last_time_ = Time::Now();
}
}
void easy2d::Task::Stop()
{
void Task::Stop()
{
running_ = false;
}
}
void easy2d::Task::Update()
{
void Task::Update()
{
if (total_times_ == 0)
{
stopped_ = true;
@ -75,15 +77,15 @@ void easy2d::Task::Update()
stopped_ = true;
return;
}
}
}
void easy2d::Task::ResetTime()
{
void Task::ResetTime()
{
last_time_ = Time::Now();
}
}
bool easy2d::Task::IsReady() const
{
bool Task::IsReady() const
{
if (running_)
{
if (delay_.Milliseconds() == 0)
@ -96,14 +98,15 @@ bool easy2d::Task::IsReady() const
}
}
return false;
}
}
bool easy2d::Task::IsRunning() const
{
bool Task::IsRunning() const
{
return running_;
}
}
const std::wstring& easy2d::Task::GetName() const
{
const std::wstring& Task::GetName() const
{
return name_;
}
}

264
core/objects/Text.cpp
View File

@ -21,11 +21,14 @@
#include "..\e2dobject.h"
#include "..\e2dmodule.h"
//-------------------------------------------------------
// Style
//-------------------------------------------------------
easy2d::Text::Style::Style()
namespace easy2d
{
//-------------------------------------------------------
// Style
//-------------------------------------------------------
Text::Style::Style()
: color(Color::White)
, alignment(Align::Left)
, wrap(false)
@ -37,9 +40,9 @@ easy2d::Text::Style::Style()
, outline_color(Color(Color::Black, 0.5))
, outline_width(1.f)
, outline_stroke(Stroke::Round)
{}
{}
easy2d::Text::Style::Style(
Text::Style::Style(
Color color,
Align alignment,
bool wrap,
@ -51,7 +54,7 @@ easy2d::Text::Style::Style(
Color outline_color,
float outline_width,
Stroke outline_stroke
)
)
: color(color)
, alignment(alignment)
, wrap(wrap)
@ -63,90 +66,90 @@ easy2d::Text::Style::Style(
, outline_color(outline_color)
, outline_width(outline_width)
, outline_stroke(outline_stroke)
{}
{}
//-------------------------------------------------------
// Text
//-------------------------------------------------------
//-------------------------------------------------------
// Text
//-------------------------------------------------------
easy2d::Text::Text()
Text::Text()
: font_()
, style_()
, text_layout_(nullptr)
, text_format_(nullptr)
{
}
{
}
easy2d::Text::Text(const std::wstring & text, const Font & font, const Style & style)
Text::Text(const std::wstring & text, const Font & font, const Style & style)
: font_(font)
, style_(style)
, text_layout_(nullptr)
, text_format_(nullptr)
, text_(text)
{
{
Reset();
}
}
easy2d::Text::~Text()
{
Text::~Text()
{
SafeRelease(text_format_);
SafeRelease(text_layout_);
}
}
const std::wstring& easy2d::Text::GetText() const
{
const std::wstring& Text::GetText() const
{
return text_;
}
}
const easy2d::Font& easy2d::Text::GetFont() const
{
const Font& Text::GetFont() const
{
return font_;
}
}
const easy2d::Text::Style& easy2d::Text::GetStyle() const
{
const Text::Style& Text::GetStyle() const
{
return style_;
}
}
const std::wstring& easy2d::Text::GetFontFamily() const
{
const std::wstring& Text::GetFontFamily() const
{
return font_.family;
}
}
float easy2d::Text::GetFontSize() const
{
float Text::GetFontSize() const
{
return font_.size;
}
}
UINT easy2d::Text::GetFontWeight() const
{
UINT Text::GetFontWeight() const
{
return font_.weight;
}
}
const easy2d::Color& easy2d::Text::GetColor() const
{
const Color& Text::GetColor() const
{
return style_.color;
}
}
const easy2d::Color& easy2d::Text::GetOutlineColor() const
{
const Color& Text::GetOutlineColor() const
{
return style_.outline_color;
}
}
float easy2d::Text::GetOutlineWidth() const
{
float Text::GetOutlineWidth() const
{
return style_.outline_width;
}
}
easy2d::Stroke easy2d::Text::GetOutlineStroke() const
{
Stroke Text::GetOutlineStroke() const
{
return style_.outline_stroke;
}
}
int easy2d::Text::GetLineCount() const
{
int Text::GetLineCount() const
{
if (text_layout_)
{
DWRITE_TEXT_METRICS metrics;
@ -157,86 +160,86 @@ int easy2d::Text::GetLineCount() const
{
return 0;
}
}
}
bool easy2d::Text::IsItalic() const
{
bool Text::IsItalic() const
{
return font_.italic;
}
}
bool easy2d::Text::strikethrough() const
{
bool Text::strikethrough() const
{
return style_.strikethrough;
}
}
bool easy2d::Text::underline() const
{
bool Text::underline() const
{
return style_.underline;
}
}
bool easy2d::Text::outline() const
{
bool Text::outline() const
{
return style_.outline;
}
}
void easy2d::Text::SetText(const std::wstring& text)
{
void Text::SetText(const std::wstring& text)
{
text_ = text;
Reset();
}
}
void easy2d::Text::SetStyle(const Style& style)
{
void Text::SetStyle(const Style& style)
{
style_ = style;
Reset();
}
}
void easy2d::Text::SetFont(const Font & font)
{
void Text::SetFont(const Font & font)
{
font_ = font;
Reset();
}
}
void easy2d::Text::SetFontFamily(const std::wstring& family)
{
void Text::SetFontFamily(const std::wstring& family)
{
font_.family = family;
Reset();
}
}
void easy2d::Text::SetFontSize(float size)
{
void Text::SetFontSize(float size)
{
font_.size = size;
Reset();
}
}
void easy2d::Text::SetFontWeight(UINT weight)
{
void Text::SetFontWeight(UINT weight)
{
font_.weight = weight;
Reset();
}
}
void easy2d::Text::SetColor(Color color)
{
void Text::SetColor(Color color)
{
style_.color = color;
}
}
void easy2d::Text::SetItalic(bool value)
{
void Text::SetItalic(bool value)
{
font_.italic = value;
Reset();
}
}
void easy2d::Text::SetWrapEnabled(bool wrap)
{
void Text::SetWrapEnabled(bool wrap)
{
if (style_.wrap != wrap)
{
style_.wrap = wrap;
Reset();
}
}
}
void easy2d::Text::SetWrapWidth(float wrap_width)
{
void Text::SetWrapWidth(float wrap_width)
{
if (style_.wrap_width != wrap_width)
{
style_.wrap_width = std::max(wrap_width, 0.f);
@ -246,28 +249,28 @@ void easy2d::Text::SetWrapWidth(float wrap_width)
Reset();
}
}
}
}
void easy2d::Text::SetLineSpacing(float line_spacing)
{
void Text::SetLineSpacing(float line_spacing)
{
if (style_.line_spacing != line_spacing)
{
style_.line_spacing = line_spacing;
Reset();
}
}
}
void easy2d::Text::SetAlignment(Align align)
{
void Text::SetAlignment(Align align)
{
if (style_.alignment != align)
{
style_.alignment = align;
Reset();
}
}
}
void easy2d::Text::SetUnderline(bool underline)
{
void Text::SetUnderline(bool underline)
{
if (style_.underline != underline)
{
style_.underline = underline;
@ -275,10 +278,10 @@ void easy2d::Text::SetUnderline(bool underline)
CreateFormat();
CreateLayout();
}
}
}
void easy2d::Text::SetStrikethrough(bool strikethrough)
{
void Text::SetStrikethrough(bool strikethrough)
{
if (style_.strikethrough != strikethrough)
{
style_.strikethrough = strikethrough;
@ -286,30 +289,30 @@ void easy2d::Text::SetStrikethrough(bool strikethrough)
CreateFormat();
CreateLayout();
}
}
}
void easy2d::Text::SetOutline(bool outline)
{
void Text::SetOutline(bool outline)
{
style_.outline = outline;
}
}
void easy2d::Text::SetOutlineColor(Color outline_color)
{
void Text::SetOutlineColor(Color outline_color)
{
style_.outline_color = outline_color;
}
}
void easy2d::Text::SetOutlineWidth(float outline_width)
{
void Text::SetOutlineWidth(float outline_width)
{
style_.outline_width = outline_width;
}
}
void easy2d::Text::SetOutlineStroke(Stroke outline_stroke)
{
void Text::SetOutlineStroke(Stroke outline_stroke)
{
style_.outline_stroke = outline_stroke;
}
}
void easy2d::Text::OnDraw() const
{
void Text::OnDraw() const
{
if (text_layout_)
{
auto graphics = Device::GetGraphics();
@ -328,18 +331,18 @@ void easy2d::Text::OnDraw() const
);
text_layout_->Draw(nullptr, text_renderer, 0, 0);
}
}
}
void easy2d::Text::Reset()
{
void Text::Reset()
{
// 创建文字格式化
CreateFormat();
// 创建文字布局
CreateLayout();
}
}
void easy2d::Text::CreateFormat()
{
void Text::CreateFormat()
{
SafeRelease(text_format_);
ThrowIfFailed(
@ -381,10 +384,10 @@ void easy2d::Text::CreateFormat()
{
text_format_->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
}
}
}
void easy2d::Text::CreateLayout()
{
void Text::CreateLayout()
{
SafeRelease(text_layout_);
// 文本为空字符串时，重置属性
@ -466,4 +469,5 @@ void easy2d::Text::CreateLayout()
{
text_layout_->SetStrikethrough(true, Range);
}
}
}

73
core/tools/Data.cpp
View File

@ -21,15 +21,17 @@
#include "..\e2dtool.h"
easy2d::Data::Data(const std::wstring & key, const std::wstring & field)
namespace easy2d
{
Data::Data(const std::wstring & key, const std::wstring & field)
: key_(key)
, field_(field)
, data_path_(Path::GetDataPath())
{
}
{
}
bool easy2d::Data::Exists() const
{
bool Data::Exists() const
{
wchar_t temp[256] = { 0 };
::GetPrivateProfileStringW(
field_.c_str(),
@ -40,10 +42,10 @@ bool easy2d::Data::Exists() const
data_path_.c_str()
);
return temp[0] == L'\0';
}
}
bool easy2d::Data::SaveInt(int value)
{
bool Data::SaveInt(int value)
{
BOOL ret = ::WritePrivateProfileStringW(
field_.c_str(),
key_.c_str(),
@ -51,10 +53,10 @@ bool easy2d::Data::SaveInt(int value)
data_path_.c_str()
);
return ret == TRUE;
}
}
bool easy2d::Data::SaveFloat(float value)
{
bool Data::SaveFloat(float value)
{
BOOL ret = ::WritePrivateProfileStringW(
field_.c_str(),
key_.c_str(),
@ -62,10 +64,10 @@ bool easy2d::Data::SaveFloat(float value)
data_path_.c_str()
);
return ret == TRUE;
}
}
bool easy2d::Data::SaveDouble(double value)
{
bool Data::SaveDouble(double value)
{
BOOL ret = ::WritePrivateProfileStringW(
field_.c_str(),
key_.c_str(),
@ -73,10 +75,10 @@ bool easy2d::Data::SaveDouble(double value)
data_path_.c_str()
);
return ret == TRUE;
}
}
bool easy2d::Data::SaveBool(bool value)
{
bool Data::SaveBool(bool value)
{
BOOL ret = ::WritePrivateProfileStringW(
field_.c_str(),
key_.c_str(),
@ -84,10 +86,10 @@ bool easy2d::Data::SaveBool(bool value)
data_path_.c_str()
);
return ret == TRUE;
}
}
bool easy2d::Data::SaveString(const std::wstring& value)
{
bool Data::SaveString(const std::wstring& value)
{
BOOL ret = ::WritePrivateProfileStringW(
field_.c_str(),
key_.c_str(),
@ -95,44 +97,44 @@ bool easy2d::Data::SaveString(const std::wstring& value)
data_path_.c_str()
);
return ret == TRUE;
}
}
int easy2d::Data::GetInt() const
{
int Data::GetInt() const
{
return ::GetPrivateProfileIntW(
field_.c_str(),
key_.c_str(),
0,
data_path_.c_str()
);
}
}
float easy2d::Data::GetFloat() const
{
float Data::GetFloat() const
{
wchar_t temp[32] = { 0 };
::GetPrivateProfileStringW(field_.c_str(), key_.c_str(), L"0.0", temp, 31, data_path_.c_str());
return std::stof(temp);
}
}
double easy2d::Data::GetDouble() const
{
double Data::GetDouble() const
{
wchar_t temp[32] = { 0 };
::GetPrivateProfileStringW(field_.c_str(), key_.c_str(), L"0.0", temp, 31, data_path_.c_str());
return std::stod(temp);
}
}
bool easy2d::Data::GetBool() const
{
bool Data::GetBool() const
{
int nValue = ::GetPrivateProfileIntW(
field_.c_str(),
key_.c_str(),
0,
data_path_.c_str());
return nValue == TRUE;
}
}
std::wstring easy2d::Data::GetString()
{
std::wstring Data::GetString()
{
wchar_t temp[256] = { 0 };
::GetPrivateProfileStringW(
field_.c_str(),
@ -143,4 +145,5 @@ std::wstring easy2d::Data::GetString()
data_path_.c_str()
);
return temp;
}
}

75
core/tools/File.cpp
View File

@ -23,25 +23,27 @@
#include <cwctype>
#include <shobjidl.h>
std::list<std::wstring> easy2d::File::search_paths_;
namespace easy2d
{
std::list<std::wstring> File::search_paths_;
easy2d::File::File()
File::File()
: file_path_()
{
}
{
}
easy2d::File::File(const std::wstring & file_name)
File::File(const std::wstring & file_name)
: file_path_(file_name)
{
{
this->Open(file_name);
}
}
easy2d::File::~File()
{
}
File::~File()
{
}
bool easy2d::File::Open(const std::wstring & file_name)
{
bool File::Open(const std::wstring & file_name)
{
if (file_name.empty())
return false;
@ -67,22 +69,22 @@ bool easy2d::File::Open(const std::wstring & file_name)
}
}
return false;
}
}
bool easy2d::File::Exists() const
{
bool File::Exists() const
{
if (::PathFileExists(file_path_.c_str()))
return true;
return false;
}
}
const std::wstring& easy2d::File::GetPath() const
{
const std::wstring& File::GetPath() const
{
return file_path_;
}
}
std::wstring easy2d::File::GetExtension() const
{
std::wstring File::GetExtension() const
{
std::wstring file_ext;
// 找到文件名中的最后一个 '.' 的位置
size_t pos = file_path_.find_last_of(L'.');
@ -95,17 +97,17 @@ std::wstring easy2d::File::GetExtension() const
std::transform(file_ext.begin(), file_ext.end(), file_ext.begin(), std::towlower);
}
return file_ext;
}
}
bool easy2d::File::Delete()
{
bool File::Delete()
{
if (::DeleteFile(file_path_.c_str()))
return true;
return false;
}
}
easy2d::File easy2d::File::Extract(Resource& res, const std::wstring& dest_file_name)
{
File File::Extract(Resource& res, const std::wstring& dest_file_name)
{
File file;
HANDLE file_handle = ::CreateFile(
dest_file_name.c_str(),
@ -136,10 +138,10 @@ easy2d::File easy2d::File::Extract(Resource& res, const std::wstring& dest_file_
}
return file;
}
}
void easy2d::File::AddSearchPath(const std::wstring & path)
{
void File::AddSearchPath(const std::wstring & path)
{
std::wstring tmp = path;
size_t pos = 0;
while ((pos = tmp.find(L"/", pos)) != std::wstring::npos)
@ -157,10 +159,10 @@ void easy2d::File::AddSearchPath(const std::wstring & path)
{
search_paths_.push_front(path);
}
}
}
easy2d::File easy2d::File::ShowOpenDialog(const std::wstring & title, const std::wstring & filter)
{
File File::ShowOpenDialog(const std::wstring & title, const std::wstring & filter)
{
std::wstring file_path;
HRESULT hr = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
@ -219,10 +221,10 @@ easy2d::File easy2d::File::ShowOpenDialog(const std::wstring & title, const std:
::CoUninitialize();
}
return File(file_path);
}
}
easy2d::File easy2d::File::ShowSaveDialog(const std::wstring & title, const std::wstring& def_file, const std::wstring & def_ext)
{
File File::ShowSaveDialog(const std::wstring & title, const std::wstring& def_file, const std::wstring & def_ext)
{
std::wstring file_path;
HRESULT hr = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
@ -289,4 +291,5 @@ easy2d::File easy2d::File::ShowSaveDialog(const std::wstring & title, const std:
::CoUninitialize();
}
return File(file_path);
}
}

105
core/tools/Music.cpp
View File

@ -22,8 +22,10 @@
#include "..\e2dmodule.h"
namespace
namespace easy2d
{
namespace
{
void OutputDebugStringExW(LPCWSTR pszOutput, ...)
{
va_list args = NULL;
@ -48,12 +50,12 @@ namespace
{
OutputDebugStringExW(L"[easy2d] Music error: %s (%#X)\r\n", output, hr);
}
}
}
//-------------------------------------------------------
// Transcoder
//-------------------------------------------------------
namespace easy2d
{
// ÒôƵ½âÂëÆ÷
class Transcoder
{
WAVEFORMATEX* wave_format_;
@ -304,45 +306,47 @@ namespace easy2d
}
};
}
//-------------------------------------------------------
// Music
//-------------------------------------------------------
easy2d::Music::Music()
Music::Music()
: opened_(false)
, playing_(false)
, wave_data_(nullptr)
, size_(0)
, voice_(nullptr)
{
}
{
}
easy2d::Music::Music(const std::wstring& file_path)
Music::Music(const std::wstring& file_path)
: opened_(false)
, playing_(false)
, wave_data_(nullptr)
, size_(0)
, voice_(nullptr)
{
{
Load(file_path);
}
}
easy2d::Music::Music(Resource& res)
Music::Music(Resource& res)
: opened_(false)
, playing_(false)
, wave_data_(nullptr)
, size_(0)
, voice_(nullptr)
{
{
Load(res);
}
}
easy2d::Music::~Music()
{
Music::~Music()
{
Close();
}
}
bool easy2d::Music::Load(const std::wstring & file_path)
{
bool Music::Load(const std::wstring & file_path)
{
if (opened_)
{
Close();
@ -379,10 +383,10 @@ bool easy2d::Music::Load(const std::wstring & file_path)
opened_ = true;
return true;
}
}
bool easy2d::Music::Load(Resource& res)
{
bool Music::Load(Resource& res)
{
if (opened_)
{
Close();
@ -408,10 +412,10 @@ bool easy2d::Music::Load(Resource& res)
opened_ = true;
return true;
}
}
bool easy2d::Music::Play(int loop_count)
{
bool Music::Play(int loop_count)
{
if (!opened_)
{
E2D_WARNING("Music must be opened first!");
@ -459,10 +463,10 @@ bool easy2d::Music::Play(int loop_count)
playing_ = SUCCEEDED(hr);
return playing_;
}
}
void easy2d::Music::Pause()
{
void Music::Pause()
{
if (voice_)
{
if (SUCCEEDED(voice_->Stop()))
@ -470,10 +474,10 @@ void easy2d::Music::Pause()
playing_ = false;
}
}
}
}
void easy2d::Music::Resume()
{
void Music::Resume()
{
if (voice_)
{
if (SUCCEEDED(voice_->Start()))
@ -481,10 +485,10 @@ void easy2d::Music::Resume()
playing_ = true;
}
}
}
}
void easy2d::Music::Stop()
{
void Music::Stop()
{
if (voice_)
{
if (SUCCEEDED(voice_->Stop()))
@ -494,10 +498,10 @@ void easy2d::Music::Stop()
playing_ = false;
}
}
}
}
void easy2d::Music::Close()
{
void Music::Close()
{
if (voice_)
{
voice_->Stop();
@ -514,10 +518,10 @@ void easy2d::Music::Close()
opened_ = false;
playing_ = false;
}
}
bool easy2d::Music::IsPlaying() const
{
bool Music::IsPlaying() const
{
if (opened_ && voice_)
{
XAUDIO2_VOICE_STATE state;
@ -526,10 +530,10 @@ bool easy2d::Music::IsPlaying() const
return true;
}
return false;
}
}
float easy2d::Music::GetVolume() const
{
float Music::GetVolume() const
{
if (voice_)
{
float volume = 0.f;
@ -537,19 +541,20 @@ float easy2d::Music::GetVolume() const
return volume;
}
return 0.f;
}
}
bool easy2d::Music::SetVolume(float volume)
{
bool Music::SetVolume(float volume)
{
if (voice_)
{
volume = std::min(std::max(volume, -224.f), 224.f);
return SUCCEEDED(voice_->SetVolume(volume));
}
return false;
}
}
IXAudio2SourceVoice * easy2d::Music::GetSourceVoice() const
{
IXAudio2SourceVoice * Music::GetSourceVoice() const
{
return voice_;
}
}

29
core/tools/Path.cpp
View File

@ -23,8 +23,10 @@
#include <shlobj.h>
namespace
namespace easy2d
{
namespace
{
// ´´½¨Ö¸¶¨Îļþ¼Ð
bool CreateFolder(const std::wstring & dir_path)
{
@ -50,11 +52,11 @@ namespace
}
return true;
}
}
}
const std::wstring& easy2d::Path::GetDataPath()
{
const std::wstring& Path::GetDataPath()
{
static std::wstring data_path;
if (data_path.empty())
{
@ -79,10 +81,10 @@ const std::wstring& easy2d::Path::GetDataPath()
data_path.append(L"Data.ini");
}
return data_path;
}
}
const std::wstring& easy2d::Path::GetTemporaryPath()
{
const std::wstring& Path::GetTemporaryPath()
{
static std::wstring temp_path;
if (temp_path.empty())
{
@ -106,10 +108,10 @@ const std::wstring& easy2d::Path::GetTemporaryPath()
}
}
return temp_path;
}
}
const std::wstring& easy2d::Path::GetLocalAppDataPath()
{
const std::wstring& Path::GetLocalAppDataPath()
{
static std::wstring local_app_data_path;
if (local_app_data_path.empty())
{
@ -120,10 +122,10 @@ const std::wstring& easy2d::Path::GetLocalAppDataPath()
}
return local_app_data_path;
}
}
const std::wstring& easy2d::Path::GetExeFilePath()
{
const std::wstring& Path::GetExeFilePath()
{
static std::wstring exe_file_path;
if (exe_file_path.empty())
{
@ -134,4 +136,5 @@ const std::wstring& easy2d::Path::GetExeFilePath()
}
}
return exe_file_path;
}
}

123
core/tools/Player.cpp
View File

@ -1,19 +1,21 @@
#include "..\e2dtool.h"
std::map<size_t, easy2d::Music*> easy2d::Player::musics_;
namespace easy2d
{
std::map<size_t, Music*> Player::musics_;
easy2d::Player::Player()
Player::Player()
: volume_(1.f)
{
}
{
}
easy2d::Player::~Player()
{
}
Player::~Player()
{
}
bool easy2d::Player::Load(const std::wstring & file_path)
{
bool Player::Load(const std::wstring & file_path)
{
if (file_path.empty())
return false;
@ -35,10 +37,10 @@ bool easy2d::Player::Load(const std::wstring & file_path)
}
}
return false;
}
}
bool easy2d::Player::Play(const std::wstring & file_path, int loop_count)
{
bool Player::Play(const std::wstring & file_path, int loop_count)
{
if (file_path.empty())
return false;
@ -51,40 +53,40 @@ bool easy2d::Player::Play(const std::wstring & file_path, int loop_count)
}
}
return false;
}
}
void easy2d::Player::Pause(const std::wstring & file_path)
{
void Player::Pause(const std::wstring & file_path)
{
if (file_path.empty())
return;
size_t hash_code = std::hash<std::wstring>{}(file_path);
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Pause();
}
}
void easy2d::Player::Resume(const std::wstring & file_path)
{
void Player::Resume(const std::wstring & file_path)
{
if (file_path.empty())
return;
size_t hash_code = std::hash<std::wstring>{}(file_path);
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Resume();
}
}
void easy2d::Player::Stop(const std::wstring & file_path)
{
void Player::Stop(const std::wstring & file_path)
{
if (file_path.empty())
return;
size_t hash_code = std::hash<std::wstring>{}(file_path);
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Stop();
}
}
bool easy2d::Player::IsPlaying(const std::wstring & file_path)
{
bool Player::IsPlaying(const std::wstring & file_path)
{
if (file_path.empty())
return false;
@ -92,10 +94,10 @@ bool easy2d::Player::IsPlaying(const std::wstring & file_path)
if (musics_.end() != musics_.find(hash_code))
return musics_[hash_code]->IsPlaying();
return false;
}
}
bool easy2d::Player::Load(Resource& res)
{
bool Player::Load(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (musics_.end() != musics_.find(hash_code))
return true;
@ -116,10 +118,10 @@ bool easy2d::Player::Load(Resource& res)
}
}
return false;
}
}
bool easy2d::Player::Play(Resource& res, int loop_count)
{
bool Player::Play(Resource& res, int loop_count)
{
if (Load(res))
{
size_t hash_code = res.GetHashCode();
@ -130,77 +132,77 @@ bool easy2d::Player::Play(Resource& res, int loop_count)
}
}
return false;
}
}
void easy2d::Player::Pause(Resource& res)
{
void Player::Pause(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Pause();
}
}
void easy2d::Player::Resume(Resource& res)
{
void Player::Resume(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Resume();
}
}
void easy2d::Player::Stop(Resource& res)
{
void Player::Stop(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (musics_.end() != musics_.find(hash_code))
musics_[hash_code]->Stop();
}
}
bool easy2d::Player::IsPlaying(Resource& res)
{
bool Player::IsPlaying(Resource& res)
{
size_t hash_code = res.GetHashCode();
if (musics_.end() != musics_.find(hash_code))
return musics_[hash_code]->IsPlaying();
return false;
}
}
float easy2d::Player::GetVolume() const
{
float Player::GetVolume() const
{
return volume_;
}
}
void easy2d::Player::SetVolume(float volume)
{
void Player::SetVolume(float volume)
{
volume_ = std::min(std::max(volume, -224.f), 224.f);
for (const auto& pair : musics_)
{
pair.second->SetVolume(volume_);
}
}
}
void easy2d::Player::PauseAll()
{
void Player::PauseAll()
{
for (const auto& pair : musics_)
{
pair.second->Pause();
}
}
}
void easy2d::Player::ResumeAll()
{
void Player::ResumeAll()
{
for (const auto& pair : musics_)
{
pair.second->Resume();
}
}
}
void easy2d::Player::StopAll()
{
void Player::StopAll()
{
for (const auto& pair : musics_)
{
pair.second->Stop();
}
}
}
void easy2d::Player::ClearCache()
{
void Player::ClearCache()
{
if (musics_.empty())
return;
@ -209,4 +211,5 @@ void easy2d::Player::ClearCache()
pair.second->Release();
}
musics_.clear();
}
}

19
core/transitions/BoxTransition.cpp
View File

@ -21,20 +21,22 @@
#include "..\e2dtransition.h"
#include "..\e2dobject.h"
easy2d::BoxTransition::BoxTransition(float duration)
namespace easy2d
{
BoxTransition::BoxTransition(float duration)
: Transition(duration)
{
}
{
}
void easy2d::BoxTransition::Init(Scene * prev, Scene * next, Game * game)
{
void BoxTransition::Init(Scene * prev, Scene * next, Game * game)
{
Transition::Init(prev, next, game);
in_layer_param_.opacity = 0;
}
}
void easy2d::BoxTransition::Update()
{
void BoxTransition::Update()
{
Transition::Update();
if (process_ < .5f)
@ -57,4 +59,5 @@ void easy2d::BoxTransition::Update()
window_size_.height * process_
);
}
}
}

19
core/transitions/EmergeTransition.cpp
View File

@ -21,23 +21,26 @@
#include "..\e2dtransition.h"
#include "..\e2dobject.h"
easy2d::EmergeTransition::EmergeTransition(float duration)
namespace easy2d
{
EmergeTransition::EmergeTransition(float duration)
: Transition(duration)
{
}
{
}
void easy2d::EmergeTransition::Init(Scene * prev, Scene * next, Game * game)
{
void EmergeTransition::Init(Scene * prev, Scene * next, Game * game)
{
Transition::Init(prev, next, game);
out_layer_param_.opacity = 1;
in_layer_param_.opacity = 0;
}
}
void easy2d::EmergeTransition::Update()
{
void EmergeTransition::Update()
{
Transition::Update();
out_layer_param_.opacity = 1 - process_;
in_layer_param_.opacity = process_;
}
}

19
core/transitions/FadeTransition.cpp
View File

@ -21,21 +21,23 @@
#include "..\e2dtransition.h"
#include "..\e2dobject.h"
easy2d::FadeTransition::FadeTransition(float duration)
namespace easy2d
{
FadeTransition::FadeTransition(float duration)
: Transition(duration)
{
}
{
}
void easy2d::FadeTransition::Init(Scene * prev, Scene * next, Game * game)
{
void FadeTransition::Init(Scene * prev, Scene * next, Game * game)
{
Transition::Init(prev, next, game);
out_layer_param_.opacity = 1;
in_layer_param_.opacity = 0;
}
}
void easy2d::FadeTransition::Update()
{
void FadeTransition::Update()
{
Transition::Update();
if (process_ < 0.5)
@ -48,4 +50,5 @@ void easy2d::FadeTransition::Update()
out_layer_param_.opacity = 0;
in_layer_param_.opacity = (process_ - 0.5f) * 2;
}
}
}

25
core/transitions/MoveTransition.cpp
View File

@ -21,14 +21,16 @@
#include "..\e2dtransition.h"
#include "..\e2dobject.h"
easy2d::MoveTransition::MoveTransition(float duration, Direction direction)
namespace easy2d
{
MoveTransition::MoveTransition(float duration, Direction direction)
: Transition(duration)
, direction_(direction)
{
}
{
}
void easy2d::MoveTransition::Init(Scene * prev, Scene * next, Game * game)
{
void MoveTransition::Init(Scene * prev, Scene * next, Game * game)
{
Transition::Init(prev, next, game);
switch (direction_)
@ -65,10 +67,10 @@ void easy2d::MoveTransition::Init(Scene * prev, Scene * next, Game * game)
)
);
}
}
}
void easy2d::MoveTransition::Update()
{
void MoveTransition::Update()
{
Transition::Update();
if (out_scene_)
@ -92,10 +94,10 @@ void easy2d::MoveTransition::Update()
)
);
}
}
}
void easy2d::MoveTransition::Reset()
{
void MoveTransition::Reset()
{
if (out_scene_)
{
out_scene_->SetTransform(D2D1::Matrix3x2F::Identity());
@ -105,4 +107,5 @@ void easy2d::MoveTransition::Reset()
{
in_scene_->SetTransform(D2D1::Matrix3x2F::Identity());
}
}
}

25
core/transitions/RotationTransition.cpp
View File

@ -21,14 +21,16 @@
#include "..\e2dtransition.h"
#include "..\e2dobject.h"
easy2d::RotationTransition::RotationTransition(float duration, float rotation)
namespace easy2d
{
RotationTransition::RotationTransition(float duration, float rotation)
: Transition(duration)
, rotation_(rotation)
{
}
{
}
void easy2d::RotationTransition::Init(Scene * prev, Scene * next, Game * game)
{
void RotationTransition::Init(Scene * prev, Scene * next, Game * game)
{
Transition::Init(prev, next, game);
if (out_scene_)
@ -42,10 +44,10 @@ void easy2d::RotationTransition::Init(Scene * prev, Scene * next, Game * game)
}
in_layer_param_.opacity = 0;
}
}
void easy2d::RotationTransition::Update()
{
void RotationTransition::Update()
{
Transition::Update();
auto center_pos = D2D1::Point2F(
@ -88,10 +90,10 @@ void easy2d::RotationTransition::Update()
);
}
}
}
}
void easy2d::RotationTransition::Reset()
{
void RotationTransition::Reset()
{
if (out_scene_)
{
out_scene_->SetTransform(D2D1::Matrix3x2F::Identity());
@ -101,4 +103,5 @@ void easy2d::RotationTransition::Reset()
{
in_scene_->SetTransform(D2D1::Matrix3x2F::Identity());
}
}
}

43
core/transitions/Transition.cpp
View File

@ -22,7 +22,9 @@
#include "..\e2dobject.h"
#include "..\e2dmodule.h"
easy2d::Transition::Transition(float duration)
namespace easy2d
{
Transition::Transition(float duration)
: done_(false)
, started_()
, process_(0)
@ -33,25 +35,25 @@ easy2d::Transition::Transition(float duration)
, in_layer_(nullptr)
, out_layer_param_()
, in_layer_param_()
{
{
duration_ = std::max(duration, 0.f);
}
}
easy2d::Transition::~Transition()
{
Transition::~Transition()
{
SafeRelease(out_layer_);
SafeRelease(in_layer_);
SafeRelease(out_scene_);
SafeRelease(in_scene_);
}
}
bool easy2d::Transition::IsDone()
{
bool Transition::IsDone()
{
return done_;
}
}
void easy2d::Transition::Init(Scene * prev, Scene * next, Game * game)
{
void Transition::Init(Scene * prev, Scene * next, Game * game)
{
started_ = Time::Now();
out_scene_ = prev;
in_scene_ = next;
@ -92,10 +94,10 @@ void easy2d::Transition::Init(Scene * prev, Scene * next, Game * game)
graphics->GetSolidBrush(),
D2D1_LAYER_OPTIONS_NONE
);
}
}
void easy2d::Transition::Update()
{
void Transition::Update()
{
if (duration_ == 0)
{
process_ = 1;
@ -110,10 +112,10 @@ void easy2d::Transition::Update()
{
this->Stop();
}
}
}
void easy2d::Transition::Draw()
{
void Transition::Draw()
{
auto render_target = Device::GetGraphics()->GetRenderTarget();
if (out_scene_)
@ -155,10 +157,11 @@ void easy2d::Transition::Draw()
render_target->PopLayer();
render_target->PopAxisAlignedClip();
}
}
}
void easy2d::Transition::Stop()
{
void Transition::Stop()
{
done_ = true;
Reset();
}
}

70
core/utils/Color.cpp
View File

@ -20,63 +20,69 @@
#include "..\e2dutil.h"
static const UINT kRedShift = 16;
static const UINT kGreenShift = 8;
static const UINT kBlueShift = 0;
namespace easy2d
{
namespace
{
const UINT RED_SHIFT = 16;
const UINT GREEN_SHIFT = 8;
const UINT BLUE_SHIFT = 0;
static const UINT kRedMask = 0xff << kRedShift;
static const UINT kGreenMask = 0xff << kGreenShift;
static const UINT kBlueMask = 0xff << kBlueShift;
const UINT RED_MASK = 0xff << RED_SHIFT;
const UINT GREEN_MASK = 0xff << GREEN_SHIFT;
const UINT BLUE_MASK = 0xff << BLUE_SHIFT;
}
easy2d::Color::Color()
Color::Color()
: r(0)
, g(0)
, b(0)
, a(1.f)
{
}
{
}
easy2d::Color::Color(float r, float g, float b)
Color::Color(float r, float g, float b)
: r(r)
, g(g)
, b(b)
, a(1.f)
{
}
{
}
easy2d::Color::Color(float r, float g, float b, float alpha)
Color::Color(float r, float g, float b, float alpha)
: r(r)
, g(g)
, b(b)
, a(alpha)
{
}
{
}
easy2d::Color::Color(UINT rgb)
: r(((rgb & kRedMask) >> kRedShift) / 255.f)
, g(((rgb & kGreenMask) >> kGreenShift) / 255.f)
, b(((rgb & kBlueMask) >> kBlueShift) / 255.f)
Color::Color(UINT rgb)
: r(((rgb & RED_MASK) >> RED_SHIFT) / 255.f)
, g(((rgb & GREEN_MASK) >> GREEN_SHIFT) / 255.f)
, b(((rgb & BLUE_MASK) >> BLUE_SHIFT) / 255.f)
, a(1.f)
{
}
{
}
easy2d::Color::Color(UINT rgb, float alpha)
: r(((rgb & kRedMask) >> kRedShift) / 255.f)
, g(((rgb & kGreenMask) >> kGreenShift) / 255.f)
, b(((rgb & kBlueMask) >> kBlueShift) / 255.f)
Color::Color(UINT rgb, float alpha)
: r(((rgb & RED_MASK) >> RED_SHIFT) / 255.f)
, g(((rgb & GREEN_MASK) >> GREEN_SHIFT) / 255.f)
, b(((rgb & BLUE_MASK) >> BLUE_SHIFT) / 255.f)
, a(alpha)
{
}
{
}
easy2d::Color::Color(const D2D1_COLOR_F& color)
Color::Color(const D2D1_COLOR_F& color)
: r(color.r)
, g(color.g)
, b(color.b)
, a(color.a)
{
}
{
}
easy2d::Color::operator D2D1_COLOR_F() const
{
Color::operator D2D1_COLOR_F() const
{
return D2D1::ColorF(r, g, b, a);
}
}

245
core/utils/Duration.cpp
View File

@ -22,59 +22,70 @@
#include <regex>
const easy2d::Duration easy2d::Duration::Millisecond = easy2d::Duration(1);
const easy2d::Duration easy2d::Duration::Second = 1000 * easy2d::Duration::Millisecond;
const easy2d::Duration easy2d::Duration::Minute = 60 * easy2d::Duration::Second;
const easy2d::Duration easy2d::Duration::Hour = 60 * easy2d::Duration::Minute;
namespace easy2d
{
const Duration Duration::Millisecond = Duration(1);
const Duration Duration::Second = 1000 * Duration::Millisecond;
const Duration Duration::Minute = 60 * Duration::Second;
const Duration Duration::Hour = 60 * Duration::Minute;
easy2d::Duration::Duration()
namespace
{
const auto duration_regex = std::wregex(L"[-+]?([0-9]*(\\.[0-9]*)?[a-z]+)+");
typedef std::map<std::wstring, Duration> UnitMap;
const auto unit_map = UnitMap{
{L"ms", Duration::Millisecond},
{L"s", Duration::Second},
{L"m", Duration::Minute},
{L"h", Duration::Hour}
};
}
Duration::Duration()
: milliseconds_(0)
{
}
{
}
easy2d::Duration::Duration(int milliseconds)
Duration::Duration(int milliseconds)
: milliseconds_(milliseconds)
{
}
{
}
int easy2d::Duration::Milliseconds() const
{
int Duration::Milliseconds() const
{
return milliseconds_;
}
}
float easy2d::Duration::Seconds() const
{
float Duration::Seconds() const
{
int64_t sec = milliseconds_ / Second.milliseconds_;
int64_t ms = milliseconds_ % Second.milliseconds_;
return static_cast<float>(sec) + static_cast<float>(ms) / 1000.f;
}
}
float easy2d::Duration::Minutes() const
{
float Duration::Minutes() const
{
int64_t min = milliseconds_ / Minute.milliseconds_;
int64_t ms = milliseconds_ % Minute.milliseconds_;
return static_cast<float>(min) + static_cast<float>(ms) / (60 * 1000.f);
}
}
float easy2d::Duration::Hours() const
{
float Duration::Hours() const
{
int64_t hour = milliseconds_ / Hour.milliseconds_;
int64_t ms = milliseconds_ % Hour.milliseconds_;
return static_cast<float>(hour) + static_cast<float>(ms) / (60 * 60 * 1000.f);
}
easy2d::Duration easy2d::Duration::Parse(const std::wstring & str)
{
typedef std::map<std::wstring, Duration> UnitMap;
static const auto regex = std::wregex(L"[-+]?([0-9]*(\\.[0-9]*)?[a-z]+)+");
static const auto unit_map = UnitMap{{L"ms", Millisecond}, {L"s", Second}, {L"m", Minute}, {L"h", Hour}};
}
Duration Duration::Parse(const std::wstring & str)
{
size_t len = str.length();
size_t pos = 0;
bool negative = false;
Duration d;
if (!std::regex_match(str, regex))
if (!std::regex_match(str, duration_regex))
{
E2D_WARNING("Duration::Parse: invalid duration");
return d;
@ -140,157 +151,159 @@ easy2d::Duration easy2d::Duration::Parse(const std::wstring & str)
d.milliseconds_ = -d.milliseconds_;
}
return d;
}
}
bool easy2d::Duration::operator==(const Duration & other) const
{
bool Duration::operator==(const Duration & other) const
{
return milliseconds_ == other.milliseconds_;
}
}
bool easy2d::Duration::operator!=(const Duration & other) const
{
bool Duration::operator!=(const Duration & other) const
{
return milliseconds_ != other.milliseconds_;
}
}
bool easy2d::Duration::operator>(const Duration & other) const
{
bool Duration::operator>(const Duration & other) const
{
return milliseconds_ > other.milliseconds_;
}
}
bool easy2d::Duration::operator>=(const Duration & other) const
{
bool Duration::operator>=(const Duration & other) const
{
return milliseconds_ >= other.milliseconds_;
}
}
bool easy2d::Duration::operator<(const Duration & other) const
{
bool Duration::operator<(const Duration & other) const
{
return milliseconds_ < other.milliseconds_;
}
}
bool easy2d::Duration::operator<=(const Duration & other) const
{
bool Duration::operator<=(const Duration & other) const
{
return milliseconds_ <= other.milliseconds_;
}
}
easy2d::Duration easy2d::Duration::operator+(const Duration & other) const
{
Duration Duration::operator+(const Duration & other) const
{
return Duration(milliseconds_ + other.milliseconds_);
}
}
easy2d::Duration easy2d::Duration::operator-(const Duration & other) const
{
Duration Duration::operator-(const Duration & other) const
{
return Duration(milliseconds_ - other.milliseconds_);
}
}
easy2d::Duration easy2d::Duration::operator-() const
{
Duration Duration::operator-() const
{
return Duration(-milliseconds_);
}
}
easy2d::Duration easy2d::Duration::operator*(int value) const
{
Duration Duration::operator*(int value) const
{
return Duration(milliseconds_ * value);
}
}
easy2d::Duration easy2d::Duration::operator/(int value) const
{
Duration Duration::operator/(int value) const
{
return Duration(milliseconds_ / value);
}
}
easy2d::Duration easy2d::Duration::operator*(float value) const
{
Duration Duration::operator*(float value) const
{
return Duration(static_cast<int>(milliseconds_ * value));
}
}
easy2d::Duration easy2d::Duration::operator/(float value) const
{
Duration Duration::operator/(float value) const
{
return Duration(static_cast<int>(milliseconds_ / value));
}
}
easy2d::Duration easy2d::Duration::operator*(double value) const
{
Duration Duration::operator*(double value) const
{
return Duration(static_cast<int>(milliseconds_ * value));
}
}
easy2d::Duration easy2d::Duration::operator/(double value) const
{
Duration Duration::operator/(double value) const
{
return Duration(static_cast<int>(milliseconds_ / value));
}
}
easy2d::Duration & easy2d::Duration::operator+=(const Duration &other)
{
Duration & Duration::operator+=(const Duration &other)
{
milliseconds_ += other.milliseconds_;
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator-=(const Duration &other)
{
Duration & Duration::operator-=(const Duration &other)
{
milliseconds_ -= other.milliseconds_;
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator*=(int value)
{
Duration & Duration::operator*=(int value)
{
milliseconds_ *= value;
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator/=(int value)
{
Duration & Duration::operator/=(int value)
{
milliseconds_ /= value;
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator*=(float value)
{
Duration & Duration::operator*=(float value)
{
milliseconds_ = static_cast<int>(milliseconds_ * value);
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator/=(float value)
{
Duration & Duration::operator/=(float value)
{
milliseconds_ = static_cast<int>(milliseconds_ / value);
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator*=(double value)
{
Duration & Duration::operator*=(double value)
{
milliseconds_ = static_cast<int>(milliseconds_ * value);
return (*this);
}
}
easy2d::Duration & easy2d::Duration::operator/=(double value)
{
Duration & Duration::operator/=(double value)
{
milliseconds_ = static_cast<int>(milliseconds_ / value);
return (*this);
}
}
easy2d::Duration easy2d::operator*(int value, const Duration & dur)
{
Duration operator*(int value, const Duration & dur)
{
return dur * value;
}
}
easy2d::Duration easy2d::operator/(int value, const Duration & dur)
{
Duration operator/(int value, const Duration & dur)
{
return dur / value;
}
}
easy2d::Duration easy2d::operator*(float value, const Duration & dur)
{
Duration operator*(float value, const Duration & dur)
{
return dur * value;
}
}
easy2d::Duration easy2d::operator/(float value, const Duration & dur)
{
Duration operator/(float value, const Duration & dur)
{
return dur / value;
}
}
easy2d::Duration easy2d::operator*(double value, const Duration & dur)
{
Duration operator*(double value, const Duration & dur)
{
return dur * value;
}
}
easy2d::Duration easy2d::operator/(double value, const Duration & dur)
{
Duration operator/(double value, const Duration & dur)
{
return dur / value;
}
}

7
core/utils/Font.cpp
View File

@ -21,10 +21,13 @@
#include "..\e2dutil.h"
easy2d::Font::Font(const std::wstring & family, float size, UINT weight, bool italic)
namespace easy2d
{
Font::Font(const std::wstring & family, float size, UINT weight, bool italic)
: family(family)
, size(size)
, weight(weight)
, italic(italic)
{
{
}
}

65
core/utils/Point.cpp
View File

@ -22,63 +22,66 @@
#include <cmath>
easy2d::Point::Point()
namespace easy2d
{
Point::Point()
{
x = 0;
y = 0;
}
}
easy2d::Point::Point(float x, float y)
{
Point::Point(float x, float y)
{
this->x = x;
this->y = y;
}
}
easy2d::Point::Point(const Point & other)
{
Point::Point(const Point & other)
{
x = other.x;
y = other.y;
}
}
easy2d::Point easy2d::Point::operator+(const Point & p) const
{
Point Point::operator+(const Point & p) const
{
return Point(x + p.x, y + p.y);
}
}
easy2d::Point easy2d::Point::operator-(const Point & p) const
{
Point Point::operator-(const Point & p) const
{
return Point(x - p.x, y - p.y);
}
}
easy2d::Point easy2d::Point::operator*(float value) const
{
Point Point::operator*(float value) const
{
return Point(x * value, y * value);
}
}
easy2d::Point easy2d::Point::operator/(float value) const
{
Point Point::operator/(float value) const
{
return Point(x / value, y / value);
}
}
easy2d::Point::operator easy2d::Size() const
{
Point::operator Size() const
{
return Size(x, y);
}
}
float easy2d::Point::Distance(const Point &p1, const Point &p2)
{
float Point::Distance(const Point &p1, const Point &p2)
{
return sqrt(
(p1.x - p2.x) * (p1.x - p2.x) +
(p1.y - p2.y) * (p1.y - p2.y)
);
}
}
easy2d::Point easy2d::Point::operator-() const
{
Point Point::operator-() const
{
return Point(-x, -y);
}
}
bool easy2d::Point::operator==(const Point & point) const
{
bool Point::operator==(const Point & point) const
{
return (x == point.x) && (y == point.y);
}
}

5
core/utils/Random.cpp
View File

@ -20,9 +20,12 @@
#include "..\e2dutil.h"
std::default_random_engine &easy2d::Random::GetEngine()
namespace easy2d
{
std::default_random_engine &Random::GetEngine()
{
static std::random_device device;
static std::default_random_engine engine(device());
return engine;
}
}

49
core/utils/Rect.cpp
View File

@ -20,56 +20,59 @@
#include "..\e2dutil.h"
easy2d::Rect::Rect(void)
namespace easy2d
{
Rect::Rect(void)
: origin()
, size()
{
}
{
}
easy2d::Rect::Rect(float x, float y, float width, float height)
Rect::Rect(float x, float y, float width, float height)
: origin(x, y)
, size(width, height)
{
}
{
}
easy2d::Rect::Rect(const Point& pos, const Size& size)
Rect::Rect(const Point& pos, const Size& size)
: origin(pos.x, pos.y)
, size(size.width, size.height)
{
}
{
}
easy2d::Rect::Rect(const Rect& other)
Rect::Rect(const Rect& other)
: origin(other.origin.x, other.origin.y)
, size(other.size.width, other.size.height)
{
}
{
}
easy2d::Rect& easy2d::Rect::operator= (const Rect& other)
{
Rect& Rect::operator= (const Rect& other)
{
origin = other.origin;
size = other.size;
return *this;
}
}
bool easy2d::Rect::operator==(const Rect & rect) const
{
bool Rect::operator==(const Rect & rect) const
{
return (origin == rect.origin) && (size == rect.size);
}
}
bool easy2d::Rect::ContainsPoint(const Point& point) const
{
bool Rect::ContainsPoint(const Point& point) const
{
if (point.x >= origin.x && point.x <= (origin.y + size.height)
&& point.y >= origin.y && point.y <= (origin.y + size.height))
{
return true;
}
return false;
}
}
bool easy2d::Rect::Intersects(const Rect& rect) const
{
bool Rect::Intersects(const Rect& rect) const
{
return !((origin.x + size.width) < rect.origin.x ||
(rect.origin.x + rect.size.width) < origin.x ||
(origin.y + size.height) < rect.origin.y ||
(rect.origin.y + rect.size.height) < origin.y);
}
}

29
core/utils/Ref.cpp
View File

@ -20,23 +20,25 @@
#include "..\e2dobject.h"
easy2d::Ref::Ref()
namespace easy2d
{
Ref::Ref()
{
// 当对象被创建时，意味着它已经被引用了一次
ref_count_ = 1;
}
}
easy2d::Ref::~Ref()
{
}
Ref::~Ref()
{
}
LONG easy2d::Ref::Retain()
{
LONG Ref::Retain()
{
return ::InterlockedIncrement(&ref_count_);
}
}
LONG easy2d::Ref::Release()
{
LONG Ref::Release()
{
LONG new_count = ::InterlockedDecrement(&ref_count_);
if (new_count <= 0)
@ -46,9 +48,10 @@ LONG easy2d::Ref::Release()
}
return new_count;
}
}
LONG easy2d::Ref::GetRefCount() const
{
LONG Ref::GetRefCount() const
{
return ref_count_;
}
}

43
core/utils/Resource.cpp
View File

@ -21,42 +21,44 @@
#include "..\e2dtool.h"
easy2d::Resource::Resource(LPCWSTR name, LPCWSTR type)
namespace easy2d
{
Resource::Resource(LPCWSTR name, LPCWSTR type)
: name_(name)
, type_(type)
, data_(nullptr)
, data_size_(0)
, loaded_(false)
{
}
{
}
LPCWSTR easy2d::Resource::GetName() const
{
LPCWSTR Resource::GetName() const
{
return name_;
}
}
LPCWSTR easy2d::Resource::GetType() const
{
LPCWSTR Resource::GetType() const
{
return type_;
}
}
LPVOID easy2d::Resource::GetData() const
{
LPVOID Resource::GetData() const
{
return data_;
}
}
DWORD easy2d::Resource::GetDataSize() const
{
DWORD Resource::GetDataSize() const
{
return data_size_;
}
}
size_t easy2d::Resource::GetHashCode() const
{
size_t Resource::GetHashCode() const
{
return std::hash<LPCWSTR>{}(name_);
}
}
bool easy2d::Resource::Load()
{
bool Resource::Load()
{
if (!loaded_)
{
HRSRC res_info;
@ -94,4 +96,5 @@ bool easy2d::Resource::Load()
loaded_ = true;
}
return true;
}
}

59
core/utils/Size.cpp
View File

@ -20,55 +20,58 @@
#include "..\e2dutil.h"
easy2d::Size::Size()
namespace easy2d
{
Size::Size()
{
width = 0;
height = 0;
}
}
easy2d::Size::Size(float width, float height)
{
Size::Size(float width, float height)
{
this->width = width;
this->height = height;
}
}
easy2d::Size::Size(const Size & other)
{
Size::Size(const Size & other)
{
width = other.width;
height = other.height;
}
}
easy2d::Size easy2d::Size::operator+(const Size & other) const
{
Size Size::operator+(const Size & other) const
{
return Size(width + other.width, height + other.height);
}
}
easy2d::Size easy2d::Size::operator-(const Size & other) const
{
Size Size::operator-(const Size & other) const
{
return Size(width - other.width, height - other.height);
}
}
easy2d::Size easy2d::Size::operator*(float value) const
{
Size Size::operator*(float value) const
{
return Size(width * value, height * value);
}
}
easy2d::Size easy2d::Size::operator/(float value) const
{
Size Size::operator/(float value) const
{
return Size(width / value, height / value);
}
}
easy2d::Size::operator easy2d::Point() const
{
Size::operator Point() const
{
return Point(width, height);
}
}
easy2d::Size easy2d::Size::operator-() const
{
Size Size::operator-() const
{
return Size(-width, -height);
}
}
bool easy2d::Size::operator==(const Size & other) const
{
bool Size::operator==(const Size & other) const
{
return (width == other.width) && (height == other.height);
}
}

89
core/utils/Time.cpp
View File

@ -20,86 +20,89 @@
#include "..\e2dutil.h"
using namespace std::chrono;
easy2d::Time::Time()
namespace easy2d
{
}
using namespace std::chrono;
easy2d::Time::Time(std::chrono::steady_clock::time_point time)
Time::Time()
{
}
Time::Time(std::chrono::steady_clock::time_point time)
: time_(time)
{
}
{
}
easy2d::Time::Time(const Time & other)
Time::Time(const Time & other)
: time_(other.time_)
{
}
{
}
easy2d::Time::Time(Time && other)
Time::Time(Time && other)
: time_(std::move(other.time_))
{
}
{
}
time_t easy2d::Time::GetTimeStamp() const
{
time_t Time::GetTimeStamp() const
{
auto& duration = time_point_cast<milliseconds>(time_).time_since_epoch();
return static_cast<time_t>(duration.count());
}
}
bool easy2d::Time::IsZero() const
{
bool Time::IsZero() const
{
return time_.time_since_epoch().count() == 0LL;
}
}
easy2d::Time easy2d::Time::operator+(const Duration & other) const
{
Time Time::operator+(const Duration & other) const
{
return Time(time_ + milliseconds(other.Milliseconds()));
}
}
easy2d::Time easy2d::Time::operator-(const Duration & other) const
{
Time Time::operator-(const Duration & other) const
{
return Time(time_ - milliseconds(other.Milliseconds()));
}
}
easy2d::Time & easy2d::Time::operator+=(const Duration & other)
{
Time & Time::operator+=(const Duration & other)
{
time_ += milliseconds(other.Milliseconds());
return (*this);
}
}
easy2d::Time & easy2d::Time::operator-=(const Duration &other)
{
Time & Time::operator-=(const Duration &other)
{
time_ -= milliseconds(other.Milliseconds());
return (*this);
}
}
easy2d::Duration easy2d::Time::operator-(const Time & other) const
{
Duration Time::operator-(const Time & other) const
{
auto ms = duration_cast<milliseconds>(time_ - other.time_).count();
return Duration(static_cast<int>(ms));
}
}
easy2d::Time& easy2d::Time::operator=(const Time & other) E2D_NOEXCEPT
{
Time& Time::operator=(const Time & other) E2D_NOEXCEPT
{
if (this == &other)
return *this;
time_ = other.time_;
return *this;
}
}
easy2d::Time& easy2d::Time::operator=(Time && other) E2D_NOEXCEPT
{
Time& Time::operator=(Time && other) E2D_NOEXCEPT
{
if (this == &other)
return *this;
time_ = std::move(other.time_);
return *this;
}
}
easy2d::Time easy2d::Time::Now()
{
Time Time::Now()
{
return Time(steady_clock::now());
}
}

19
core/utils/Transform.cpp
View File

@ -21,7 +21,9 @@
#include "..\e2dutil.h"
easy2d::Transform::Transform()
namespace easy2d
{
Transform::Transform()
: position()
, size()
, scale_x(1.f)
@ -31,11 +33,11 @@ easy2d::Transform::Transform()
, skew_y(0)
, pivot_x(0)
, pivot_y(0)
{
}
{
}
easy2d::Transform::operator D2D1::Matrix3x2F() const
{
Transform::operator D2D1::Matrix3x2F() const
{
auto pivot = D2D1::Point2F(size.width * pivot_x, size.height * pivot_y);
auto matrix = D2D1::Matrix3x2F::Scale(
scale_x,
@ -53,10 +55,10 @@ easy2d::Transform::operator D2D1::Matrix3x2F() const
position.y - pivot.y
);
return matrix;
}
}
bool easy2d::Transform::operator==(const Transform & other) const
{
bool Transform::operator==(const Transform & other) const
{
return position == other.position &&
size == other.size &&
scale_x == other.scale_x &&
@ -66,4 +68,5 @@ bool easy2d::Transform::operator==(const Transform & other) const
rotation == other.rotation &&
pivot_x == other.pivot_x &&
pivot_y == other.pivot_y;
}
}