549 lines
10 KiB
C++
549 lines
10 KiB
C++
#include "Node.h"
|
|
#include "EngineCore/Game.h"
|
|
void Node::Init()
|
|
{
|
|
}
|
|
void Node::HandleEvents(SDL_Event *e)
|
|
{
|
|
}
|
|
inline void Node::Update(float deltaTime)
|
|
{
|
|
if (children_.IsEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
RefPtr<Node> child = children_.GetFirst();
|
|
while (child)
|
|
{
|
|
if (child->GetZOrder() >= 0)
|
|
break;
|
|
|
|
child->Update(deltaTime);
|
|
child = child->GetNext();
|
|
}
|
|
|
|
UpdateSelf(deltaTime);
|
|
|
|
|
|
while (child)
|
|
{
|
|
child->Update(deltaTime);
|
|
child = child->GetNext();
|
|
}
|
|
}
|
|
inline void Node::PreRender()
|
|
{
|
|
}
|
|
inline void Node::Render()
|
|
{
|
|
}
|
|
void Node::Clear()
|
|
{
|
|
}
|
|
|
|
void Node::UpdateSelf(float deltaTime)
|
|
{
|
|
// 如果有回调函数，则调用回调函数
|
|
if (cb_update_.size() > 0)
|
|
{
|
|
for (auto &cb : cb_update_)
|
|
{
|
|
cb.second(deltaTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Node::RemoveFromParent()
|
|
{
|
|
if (parent_)
|
|
{
|
|
parent_->RemoveChild(this);
|
|
}
|
|
}
|
|
inline void Node::PauseUpdating()
|
|
{
|
|
update_pausing_ = true;
|
|
}
|
|
inline void Node::ResumeUpdating()
|
|
{
|
|
update_pausing_ = false;
|
|
}
|
|
inline bool Node::IsUpdatePausing() const
|
|
{
|
|
return update_pausing_;
|
|
}
|
|
|
|
void Node::SetCallbackOnUpdate(std::string Key, const UpdateCallback &cb)
|
|
{
|
|
cb_update_[Key] = cb;
|
|
}
|
|
|
|
void Node::RemoveCallbackOnUpdate(std::string Key)
|
|
{
|
|
cb_update_.erase(Key);
|
|
}
|
|
|
|
bool Node::ContainsPoint(const glm::vec2 &point) const
|
|
{
|
|
// if (size_.x == 0.f || size_.y == 0.f)
|
|
return false;
|
|
// glm::vec2 local = ConvertToLocal(point);
|
|
// return local.x >= 0 && local.y >= 0 && local.x <= size_.x && local.y <= size_.y;
|
|
}
|
|
|
|
glm::vec2 Node::ConvertToLocal(const glm::vec2 &point) const
|
|
{
|
|
glm::vec2 local = GetTransformInverseMatrix().Transform(point);
|
|
return local;
|
|
}
|
|
|
|
glm::vec2 Node::ConvertToWorld(const glm::vec2 &point) const
|
|
{
|
|
glm::vec2 world = GetTransformMatrix().Transform(point);
|
|
return world;
|
|
}
|
|
|
|
void Node::ShowBorder(bool show)
|
|
{
|
|
show_border_ = show;
|
|
}
|
|
|
|
Node::Node() : visible_(true), update_pausing_(false), show_border_(false), parent_(nullptr), anchor_(0.0f, 0.0f), z_order_(0), opacity_(1.f), name_("Node")
|
|
{
|
|
Game::GetInstance().m_nodeCount++;
|
|
}
|
|
|
|
Node::~Node()
|
|
{
|
|
Game::GetInstance().m_nodeCount--;
|
|
RemoveAllChildren();
|
|
}
|
|
|
|
void Node::UpdateTransform() const
|
|
{
|
|
if (!dirty_flag_.Has(DirtyFlag::DirtyTransform))
|
|
return;
|
|
dirty_flag_.Unset(DirtyFlag::DirtyTransform);
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransformInverse);
|
|
dirty_flag_.Set(DirtyFlag::DirtyVisibility);
|
|
|
|
if (transform_.IsFast())
|
|
{
|
|
transform_matrix_to_parent_ = Matrix3x2::Translation(transform_.position);
|
|
}
|
|
else
|
|
{
|
|
transform_matrix_to_parent_ = transform_.ToMatrix();
|
|
}
|
|
|
|
glm::vec2 anchor_offset(-size_.width * anchor_.x, -size_.height * anchor_.y);
|
|
transform_matrix_to_parent_.Translate(anchor_offset);
|
|
|
|
transform_matrix_ = transform_matrix_to_parent_;
|
|
if (parent_)
|
|
{
|
|
transform_matrix_ *= parent_->transform_matrix_;
|
|
}
|
|
|
|
for (const auto &child : children_)
|
|
child->dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
void Node::UpdateTransformUpwards() const
|
|
{
|
|
if (parent_)
|
|
{
|
|
parent_->UpdateTransformUpwards();
|
|
|
|
if (parent_->dirty_flag_.Has(DirtyFlag::DirtyTransform))
|
|
{
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
}
|
|
|
|
UpdateTransform();
|
|
}
|
|
|
|
const Matrix3x2 &Node::GetTransformMatrix() const
|
|
{
|
|
UpdateTransformUpwards();
|
|
return transform_matrix_;
|
|
}
|
|
|
|
const Matrix3x2 &Node::GetTransformInverseMatrix() const
|
|
{
|
|
UpdateTransformUpwards();
|
|
if (dirty_flag_.Has(DirtyFlag::DirtyTransformInverse))
|
|
{
|
|
dirty_flag_.Unset(DirtyFlag::DirtyTransformInverse);
|
|
transform_matrix_inverse_ = transform_matrix_.Invert();
|
|
}
|
|
return transform_matrix_inverse_;
|
|
}
|
|
|
|
const Matrix3x2 &Node::GetTransformMatrixToParent() const
|
|
{
|
|
UpdateTransformUpwards();
|
|
return transform_matrix_to_parent_;
|
|
}
|
|
|
|
void Node::Reorder()
|
|
{
|
|
if (parent_)
|
|
{
|
|
RefPtr<Node> me = this;
|
|
|
|
parent_->children_.Remove(me);
|
|
|
|
RefPtr<Node> sibling = parent_->children_.GetLast();
|
|
|
|
if (sibling && sibling->GetZOrder() > z_order_)
|
|
{
|
|
sibling = sibling->GetPrev();
|
|
while (sibling)
|
|
{
|
|
if (sibling->GetZOrder() <= z_order_)
|
|
break;
|
|
sibling = sibling->GetPrev();
|
|
}
|
|
}
|
|
|
|
if (sibling)
|
|
{
|
|
parent_->children_.InsertAfter(me, sibling);
|
|
}
|
|
else
|
|
{
|
|
parent_->children_.PushFront(me);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void Node::RemoveAllChildren()
|
|
{
|
|
RefPtr<Node> next;
|
|
for (RefPtr<Node> child = children_.GetFirst(); child; child = next)
|
|
{
|
|
next = child->GetNext();
|
|
RemoveChild(child);
|
|
}
|
|
}
|
|
|
|
inline bool Node::IsVisible() const
|
|
{
|
|
return visible_;
|
|
}
|
|
|
|
inline int Node::GetZOrder() const
|
|
{
|
|
return z_order_;
|
|
}
|
|
|
|
inline glm::vec2 Node::GetPosition() const
|
|
{
|
|
return transform_.position;
|
|
}
|
|
|
|
inline float Node::GetPositionX() const
|
|
{
|
|
return GetPosition().x;
|
|
}
|
|
|
|
inline float Node::GetPositionY() const
|
|
{
|
|
return GetPosition().y;
|
|
}
|
|
|
|
inline VecSize Node::GetSize() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
inline float Node::GetWidth() const
|
|
{
|
|
return GetSize().width;
|
|
}
|
|
|
|
inline float Node::GetHeight() const
|
|
{
|
|
return GetSize().height;
|
|
}
|
|
|
|
inline float Node::GetScaledWidth() const
|
|
{
|
|
return GetWidth() * GetScaleX();
|
|
}
|
|
|
|
inline float Node::GetScaledHeight() const
|
|
{
|
|
return GetHeight() * GetScaleY();
|
|
}
|
|
|
|
inline VecSize Node::GetScaledSize() const
|
|
{
|
|
return VecSize{GetScaledWidth(), GetScaledHeight()};
|
|
}
|
|
|
|
inline glm::vec2 Node::GetAnchor() const
|
|
{
|
|
return anchor_;
|
|
}
|
|
|
|
inline float Node::GetAnchorX() const
|
|
{
|
|
return GetAnchor().x;
|
|
}
|
|
|
|
inline float Node::GetAnchorY() const
|
|
{
|
|
return GetAnchor().y;
|
|
}
|
|
|
|
inline float Node::GetOpacity() const
|
|
{
|
|
return opacity_;
|
|
}
|
|
|
|
inline float Node::GetRotation() const
|
|
{
|
|
return transform_.rotation;
|
|
}
|
|
|
|
inline glm::vec2 Node::GetScale() const
|
|
{
|
|
return transform_.scale;
|
|
}
|
|
|
|
inline float Node::GetScaleX() const
|
|
{
|
|
return GetScale().x;
|
|
}
|
|
|
|
inline float Node::GetScaleY() const
|
|
{
|
|
return GetScale().y;
|
|
}
|
|
|
|
inline glm::vec2 Node::GetSkew() const
|
|
{
|
|
return transform_.skew;
|
|
}
|
|
|
|
inline float Node::GetSkewX() const
|
|
{
|
|
return GetSkew().x;
|
|
}
|
|
|
|
inline float Node::GetSkewY() const
|
|
{
|
|
return GetSkew().y;
|
|
}
|
|
|
|
inline Y_Transform Node::GetTransform() const
|
|
{
|
|
return transform_;
|
|
}
|
|
|
|
inline Node *Node::GetParent() const
|
|
{
|
|
return parent_;
|
|
}
|
|
|
|
inline void Node::SetVisible(bool val)
|
|
{
|
|
visible_ = val;
|
|
}
|
|
|
|
inline void Node::SetName(std::string name)
|
|
{
|
|
name_ = name;
|
|
}
|
|
|
|
inline void Node::SetPosition(const glm::vec2 &pos)
|
|
{
|
|
if (transform_.position == pos)
|
|
return;
|
|
|
|
transform_.position = pos;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetPosition(float x, float y)
|
|
{
|
|
this->SetPosition(glm::vec2(x, y));
|
|
}
|
|
|
|
inline void Node::SetPositionX(float x)
|
|
{
|
|
this->SetPosition(glm::vec2(x, GetPosition().y));
|
|
}
|
|
|
|
inline void Node::SetPositionY(float y)
|
|
{
|
|
this->SetPosition(glm::vec2(GetPosition().x, y));
|
|
}
|
|
|
|
inline void Node::MoveTo(const glm::vec2 &p)
|
|
{
|
|
this->SetPosition(p);
|
|
}
|
|
|
|
inline void Node::MoveTo(float x, float y)
|
|
{
|
|
this->SetPosition(glm::vec2(x, y));
|
|
}
|
|
|
|
inline void Node::MoveBy(const glm::vec2 &trans)
|
|
{
|
|
this->SetPosition(transform_.position.x + trans.x, transform_.position.y + trans.y);
|
|
}
|
|
|
|
inline void Node::MoveBy(float trans_x, float trans_y)
|
|
{
|
|
this->MoveBy(glm::vec2(trans_x, trans_y));
|
|
}
|
|
|
|
inline void Node::SetScale(const glm::vec2 &scale)
|
|
{
|
|
if (transform_.scale == scale)
|
|
return;
|
|
|
|
transform_.scale = scale;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetScale(float scalex, float scaley)
|
|
{
|
|
this->SetScale(glm::vec2(scalex, scaley));
|
|
}
|
|
|
|
inline void Node::SetSkew(const glm::vec2 &skew)
|
|
{
|
|
if (transform_.skew == skew)
|
|
return;
|
|
|
|
transform_.skew = skew;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetSkew(float skewx, float skewy)
|
|
{
|
|
this->SetSkew(glm::vec2(skewx, skewy));
|
|
}
|
|
|
|
inline void Node::SetRotation(float rotation)
|
|
{
|
|
if (transform_.rotation == rotation)
|
|
return;
|
|
|
|
transform_.rotation = rotation;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetAnchor(const glm::vec2 &anchor)
|
|
{
|
|
if (anchor_ == anchor)
|
|
return;
|
|
|
|
anchor_ = anchor;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetAnchor(float anchorx, float anchory)
|
|
{
|
|
this->SetAnchor(glm::vec2(anchorx, anchory));
|
|
}
|
|
|
|
inline void Node::SetSize(const VecSize &size)
|
|
{
|
|
if (size_ == size)
|
|
return;
|
|
|
|
size_ = size;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetSize(float width, float height)
|
|
{
|
|
this->SetSize(VecSize{width, height});
|
|
}
|
|
|
|
inline void Node::SetWidth(float width)
|
|
{
|
|
this->SetSize(width, GetHeight());
|
|
}
|
|
|
|
inline void Node::SetHeight(float height)
|
|
{
|
|
this->SetSize(GetWidth(), height);
|
|
}
|
|
|
|
inline void Node::SetOpacity(float opacity)
|
|
{
|
|
if (opacity_ == opacity)
|
|
return;
|
|
|
|
opacity_ = std::min(std::max(opacity, 0.f), 1.f);
|
|
dirty_flag_.Set(DirtyFlag::DirtyOpacity);
|
|
}
|
|
|
|
inline void Node::SetTransform(const Y_Transform &transform)
|
|
{
|
|
transform_ = transform;
|
|
dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
}
|
|
|
|
inline void Node::SetZOrder(int zorder)
|
|
{
|
|
if (z_order_ != zorder)
|
|
{
|
|
z_order_ = zorder;
|
|
Reorder();
|
|
}
|
|
}
|
|
|
|
void Node::AddChild(RefPtr<Node> child)
|
|
{
|
|
if (child)
|
|
{
|
|
assert(!child->parent_ && "Actor::AddChild failed, the actor to be added already has a parent");
|
|
|
|
children_.PushBack(child);
|
|
child->parent_ = this;
|
|
|
|
child->dirty_flag_.Set(DirtyFlag::DirtyTransform);
|
|
child->dirty_flag_.Set(DirtyFlag::DirtyOpacity);
|
|
child->Reorder();
|
|
}
|
|
else
|
|
{
|
|
SDL_LogError(0, "Actor::AddChild failed, NULL pointer exception");
|
|
}
|
|
}
|
|
|
|
Node::NodeList &Node::GetAllChildren()
|
|
{
|
|
return children_;
|
|
}
|
|
|
|
const Node::NodeList &Node::GetAllChildren() const
|
|
{
|
|
return children_;
|
|
}
|
|
|
|
inline void Node::RemoveChild(RefPtr<Node> child)
|
|
{
|
|
if (children_.IsEmpty())
|
|
return;
|
|
|
|
if (child)
|
|
{
|
|
child->parent_ = nullptr;
|
|
children_.Remove(child);
|
|
}
|
|
else
|
|
{
|
|
SDL_LogError(0, "Actor::RemoveChild failed, NULL pointer exception");
|
|
}
|
|
} |