推

source/EngineFrame/Base/Node.cpp

@@ -5,11 +5,18 @@ void Node::Init()
 }
 void Node::HandleEvents(SDL_Event *e)
 {
+    RefPtr<Node> child = children_.GetFirst();
+    while (child)
+    {
+        child->HandleEvents(e);
+        child = child->GetNext();
+    }
 }
 inline void Node::Update(float deltaTime)
 {
     if (children_.IsEmpty())
     {
+        UpdateSelf(deltaTime);
         return;
     }
 
@@ -34,26 +41,118 @@ inline void Node::Update(float deltaTime)
 }
 inline void Node::PreRender()
 {
+    if (!visible_)
+        return;
+    UpdateTransform();
+    UpdateOpacity();
+
+    if (children_.IsEmpty())
+    {
+        if (CheckVisibility())
+        {
+            OnPreRender();
+        }
+    }
+    else
+    {
+        RefPtr<Node> child = children_.GetFirst();
+        while (child)
+        {
+            if (child->GetZOrder() >= 0)
+                break;
+
+            child->PreRender();
+            child = child->GetNext();
+        }
+
+        if (CheckVisibility())
+        {
+            OnPreRender();
+        }
+
+        while (child)
+        {
+            child->PreRender();
+            child = child->GetNext();
+        }
+    }
 }
 inline void Node::Render()
 {
+    if (!visible_)
+        return;
+    if (children_.IsEmpty())
+    {
+        if (visible_in_rt_)
+        {
+            PrepareToRender();
+            OnRender();
+        }
+    }
+    else
+    {
+        RefPtr<Node> child = children_.GetFirst();
+        while (child)
+        {
+            if (child->GetZOrder() >= 0)
+                break;
+
+            child->Render();
+            child = child->GetNext();
+        }
+
+        if (visible_in_rt_)
+        {
+            PrepareToRender();
+            OnRender();
+        }
+
+        while (child)
+        {
+            child->Render();
+            child = child->GetNext();
+        }
+    }
 }
 void Node::Clear()
 {
 }
 
+void Node::OnPreRender()
+{
+}
+
+void Node::OnRender()
+{
+}
+
+void Node::OnUpdate(float deltaTime)
+{
+}
+
 void Node::UpdateSelf(float deltaTime)
 {
-    // 如果有回调函数，则调用回调函数
-    if (cb_update_.size() > 0)
+    if (!update_pausing_)
     {
-        for (auto &cb : cb_update_)
+        OnUpdate(deltaTime);
+
+        // 如果有回调函数，则调用回调函数
+        if (cb_update_.size() > 0)
         {
-            cb.second(deltaTime);
+            for (auto &cb : cb_update_)
+            {
+                cb.second(deltaTime);
+            }
         }
     }
 }
 
+void Node::PrepareToRender()
+{
+    Game::GetInstance().GetRenderer()->SetMatrix(render_matrix_);
+    Game::GetInstance().GetRenderer()->SetOpacity(displayed_opacity_);
+}
+
 void Node::RemoveFromParent()
 {
     if (parent_)
@@ -109,7 +208,7 @@ 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")
+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"), displayed_opacity_(1.f), cascade_opacity_(true)
 {
     Game::GetInstance().m_nodeCount++;
 }
@@ -146,6 +245,8 @@ void Node::UpdateTransform() const
         transform_matrix_ *= parent_->transform_matrix_;
     }
 
+    GenerateRenderMatrix();
+
     for (const auto &child : children_)
         child->dirty_flag_.Set(DirtyFlag::DirtyTransform);
 }
@@ -165,6 +266,26 @@ void Node::UpdateTransformUpwards() const
     UpdateTransform();
 }
 
+void Node::UpdateOpacity()
+{
+    if (!dirty_flag_.Has(DirtyFlag::DirtyOpacity))
+        return;
+
+    dirty_flag_.Unset(DirtyFlag::DirtyOpacity);
+
+    if (parent_ && parent_->IsCascadeOpacityEnabled())
+    {
+        displayed_opacity_ = opacity_ * parent_->displayed_opacity_;
+    }
+    else
+    {
+        displayed_opacity_ = opacity_;
+    }
+
+    for (const auto &child : children_)
+        child->dirty_flag_.Set(DirtyFlag::DirtyOpacity);
+}
+
 const Matrix3x2 &Node::GetTransformMatrix() const
 {
     UpdateTransformUpwards();
@@ -188,6 +309,20 @@ const Matrix3x2 &Node::GetTransformMatrixToParent() const
     return transform_matrix_to_parent_;
 }
 
+void Node::GenerateRenderMatrix() const
+{
+    // 构造OpenGl渲染矩阵
+    render_matrix_ = glm::mat4(1.0f);
+    // 填充旋转+缩放分量（2D 变换核心，对应 4x4 矩阵左上 2x2 区域）
+    render_matrix_[0][0] = transform_matrix_[0]; // _11 → x轴缩放+旋转
+    render_matrix_[0][1] = transform_matrix_[1]; // _12 → 影响y轴方向的旋转分量
+    render_matrix_[1][0] = transform_matrix_[2]; // _21 → 影响x轴方向的旋转分量
+    render_matrix_[1][1] = transform_matrix_[3]; // _22 → y轴缩放+旋转
+    // 填充平移分量（对应 4x4 矩阵最后一行前两列，z轴平移为0）
+    render_matrix_[3][0] = transform_matrix_[4]; // _31 → x方向平移（世界坐标）
+    render_matrix_[3][1] = transform_matrix_[5]; // _32 → y方向平移（世界坐标）
+}
+
 void Node::Reorder()
 {
     if (parent_)
@@ -220,287 +355,24 @@ void Node::Reorder()
     }
 }
 
-inline void Node::RemoveAllChildren()
+bool Node::CheckVisibility() const
 {
-    RefPtr<Node> next;
-    for (RefPtr<Node> child = children_.GetFirst(); child; child = next)
+    if (dirty_flag_.Has(DirtyFlag::DirtyVisibility))
     {
-        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();
+        dirty_flag_.Unset(DirtyFlag::DirtyVisibility);
+
+        if (size_.width == 0.f && size_.height == 0.f)
+        {
+            visible_in_rt_ = false;
+        }
+        else
+        {
+            // TODO
+            //  visible_in_rt_ = ctx.CheckVisibility(GetBounds(), transform_matrix_ /* GetTransformMatrix() */);
+            visible_in_rt_ = true;
+        }
     }
+    return visible_in_rt_;
 }
 
 void Node::AddChild(RefPtr<Node> child)
@@ -532,7 +404,7 @@ const Node::NodeList &Node::GetAllChildren() const
     return children_;
 }
 
-inline void Node::RemoveChild(RefPtr<Node> child)
+void Node::RemoveChild(RefPtr<Node> child)
 {
     if (children_.IsEmpty())
         return;