推

source/EngineFrame/Base/Node.h

@@ -16,13 +16,19 @@ public:
     using IntrusiveListValue<RefPtr<Node>>::GetNext;
     using IntrusiveListValue<RefPtr<Node>>::GetPrev;
 
-private:
+protected:
+    /**渲染矩阵 */
+    mutable glm::mat4 render_matrix_;
     /**变换属性 */
     Y_Transform transform_;
     /**变换矩阵 */
     mutable Matrix3x2 transform_matrix_;
     mutable Matrix3x2 transform_matrix_inverse_;
     mutable Matrix3x2 transform_matrix_to_parent_;
+
+private:
+
+
     /**更新时的回调函数 */
     std::map<std::string, UpdateCallback> cb_update_;
     /**锚点 */
@@ -33,6 +39,8 @@ private:
     VecSize size_;
     /**透明度 */
     float opacity_;
+    /**显示透明度 */
+    float displayed_opacity_;
 
     /**是否可见 */
     bool visible_;
@@ -40,6 +48,10 @@ private:
     bool update_pausing_;
     /**是否显示边界 */
     bool show_border_;
+    /**是否在渲染区域中 */
+    mutable bool visible_in_rt_;
+    /**联级透明度 */
+    bool cascade_opacity_;
     /**名称 */
     std::string name_;
 
@@ -58,14 +70,22 @@ public:
     virtual void Render();
     virtual void Clear();
 
-    void UpdateSelf(float dt);
+    virtual void OnPreRender();
+    virtual void OnRender();
+    virtual void OnUpdate(float deltaTime);
 
+    void UpdateSelf(float dt);
+    void PrepareToRender();
 
 public:
     /// \~chinese
     /// @brief 获取显示状态
     bool IsVisible() const;
 
+    /// \~chinese
+    /// @brief 是否启用级联透明度
+    bool IsCascadeOpacityEnabled() const;
+
     /// \~chinese
     /// @brief 获取 Z 轴顺序
     int GetZOrder() const;
@@ -160,12 +180,18 @@ public:
 
     /// \~chinese
     /// @brief 设置角色是否可见
-    void SetVisible(bool val);
+    virtual void SetVisible(bool val);
+
+    virtual void OnSetPosition();
 
     /// \~chinese
     /// @brief 设置名称
     void SetName(std::string name);
 
+    /// \~chinese
+    /// @brief 获取名称
+    std::string GetName() const;
+
     /// \~chinese
     /// @brief 设置坐标
     void SetPosition(const glm::vec2 &pos);
@@ -246,6 +272,10 @@ public:
     /// @brief 设置透明度，默认为 1.0, 范围 [0, 1]
     void SetOpacity(float opacity);
 
+    /// \~chinese
+    /// @brief 启用或禁用级联透明度
+    void SetCascadeOpacityEnabled(bool enabled);
+
     /// \~chinese
     /// @brief 设置二维仿射变换
     void SetTransform(const Y_Transform &transform);
@@ -328,6 +358,10 @@ public:
     /// @details 对于节点树 A->B(dirty)->C->D，当对 D 执行 UpdateTransformUpwards 时会对 B、C、D 从上到下依次更新
     void UpdateTransformUpwards() const;
 
+    /// \~chinese
+    /// @brief 更新自己和所有子角色的透明度
+    void UpdateOpacity();
+
     /// \~chinese
     /// @brief 获取二维变换矩阵
     const Matrix3x2 &GetTransformMatrix() const;
@@ -340,10 +374,18 @@ public:
     /// @brief 获取变换到父角色的二维变换矩阵
     const Matrix3x2 &GetTransformMatrixToParent() const;
 
+    /// \~chinese
+    /// @brief 生成用于OpenGL渲染的矩阵
+    virtual void GenerateRenderMatrix() const;
+
     /// \~chinese
     /// @brief 将所有子角色按Z轴顺序排序
     void Reorder();
 
+    /// \~chinese
+    /// @brief 检查是否在渲染上下文的视区内
+    virtual bool CheckVisibility() const;
+
     enum DirtyFlag : uint8_t
     {
         Clean = 0,
@@ -353,3 +395,310 @@ public:
         DirtyVisibility = 1 << 3
     };
 };
+
+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 bool Node::IsCascadeOpacityEnabled() const
+{
+    return cascade_opacity_;
+}
+
+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::OnSetPosition()
+{
+}
+
+inline void Node::SetName(std::string name)
+{
+    name_ = name;
+}
+
+inline std::string Node::GetName() const
+{
+    return name_;
+}
+
+inline void Node::SetPosition(const glm::vec2 &pos)
+{
+    if (transform_.position == pos)
+        return;
+
+    transform_.position = pos;
+    dirty_flag_.Set(DirtyFlag::DirtyTransform);
+    OnSetPosition();
+}
+
+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::SetCascadeOpacityEnabled(bool enabled)
+{
+    if (cascade_opacity_ == enabled)
+        return;
+
+    cascade_opacity_ = enabled;
+    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();
+    }
+}