Actor.h

// Copyright (c) 2016-2018 Kiwano - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
#include <kiwano/math/Math.h>
#include <kiwano/core/Time.h>
#include <kiwano/base/ObjectBase.h>
#include <kiwano/base/component/ComponentManager.h>
#include <kiwano/event/EventDispatcher.h>
#include <kiwano/utils/TaskScheduler.h>
#include <kiwano/2d/animation/Animator.h>
 
namespace kiwano
{
class Stage;
class Director;
class RenderContext;
 
typedef IntrusiveList<RefPtr<Actor>> ActorList;
 
class KGE_API Actor
    : public ObjectBase
    , public Animator
    , public TaskScheduler
    , public EventDispatcher
    , public ComponentManager
    , protected IntrusiveListValue<RefPtr<Actor>>
{
    friend class Director;
    friend class Transition;
    friend IntrusiveList<RefPtr<Actor>>;
 
public:
    using IntrusiveListValue<RefPtr<Actor>>::GetNext;
    using IntrusiveListValue<RefPtr<Actor>>::GetPrev;
 
    typedef Function<void(Duration)> UpdateCallback;
 
    Actor();
 
    virtual ~Actor();
 
    virtual void OnUpdate(Duration dt);
 
    virtual void OnRender(RenderContext& ctx);
 
    bool IsVisible() const;
 
    bool IsCascadeOpacityEnabled() const;
 
    size_t GetHashName() const;
 
    int GetZOrder() const;
 
    Point GetPosition() const;
 
    float GetPositionX() const;
 
    float GetPositionY() const;
 
    virtual Size GetSize() const;
 
    float GetWidth() const;
 
    float GetHeight() const;
 
    float GetScaledWidth() const;
 
    float GetScaledHeight() const;
 
    Size GetScaledSize() const;
 
    Point GetAnchor() const;
 
    float GetAnchorX() const;
 
    float GetAnchorY() const;
 
    float GetOpacity() const;
 
    float GetDisplayedOpacity() const;
 
    float GetRotation() const;
 
    Point GetScale() const;
 
    float GetScaleX() const;
 
    float GetScaleY() const;
 
    Point GetSkew() const;
 
    float GetSkewX() const;
 
    float GetSkewY() const;
 
    Transform GetTransform() const;
 
    Actor* GetParent() const;
 
    Stage* GetStage() const;
 
    virtual Rect GetBounds() const;
 
    virtual Rect GetBoundingBox() const;
 
    const Matrix3x2& GetTransformMatrix() const;
 
    const Matrix3x2& GetTransformInverseMatrix() const;
 
    const Matrix3x2& GetTransformMatrixToParent() const;
 
    void SetVisible(bool val);
 
    void SetName(StringView name);
 
    void SetPosition(const Point& point);
 
    void SetPosition(float x, float y);
 
    void SetPositionX(float x);
 
    void SetPositionY(float y);
 
    void MoveTo(const Point& p);
 
    void MoveTo(float x, float y);
 
    void MoveBy(const Vec2& trans);
 
    void MoveBy(float trans_x, float trans_y);
 
    void SetScale(const Vec2& scale);
 
    void SetScale(float scalex, float scaley);
 
    void SetSkew(const Vec2& skew);
 
    void SetSkew(float skewx, float skewy);
 
    void SetRotation(float rotation);
 
    void SetAnchor(const Vec2& anchor);
 
    void SetAnchor(float anchorx, float anchory);
 
    void SetSize(const Size& size);
 
    void SetSize(float width, float height);
 
    void SetWidth(float width);
 
    void SetHeight(float height);
 
    void SetOpacity(float opacity);
 
    void SetCascadeOpacityEnabled(bool enabled);
 
    void SetTransform(const Transform& transform);
 
    void SetZOrder(int zorder);
 
    void AddChild(RefPtr<Actor> child);
 
    void AddChild(RefPtr<Actor> child, int zorder);
 
    void AddChildren(const Vector<RefPtr<Actor>>& children);
 
    RefPtr<Actor> GetChild(StringView name) const;
 
    Vector<RefPtr<Actor>> GetChildren(StringView name) const;
 
    ActorList& GetAllChildren();
 
    const ActorList& GetAllChildren() const;
 
    void RemoveChild(RefPtr<Actor> child);
 
    void RemoveChildren(StringView child_name);
 
    void RemoveAllChildren();
 
    void RemoveFromParent();
 
    void PauseUpdating();
 
    void ResumeUpdating();
 
    bool IsUpdatePausing() const;
 
    void SetCallbackOnUpdate(const UpdateCallback& cb);
 
    UpdateCallback GetCallbackOnUpdate() const;
 
    virtual bool ContainsPoint(const Point& point) const;
 
    Point ConvertToLocal(const Point& point) const;
 
    Point ConvertToWorld(const Point& point) const;
 
    void ShowBorder(bool show);
 
    void DoSerialize(Serializer* serializer) const override;
 
    void DoDeserialize(Deserializer* deserializer) override;
 
    static void SetDefaultAnchor(float anchor_x, float anchor_y);
 
protected:
    virtual void Update(Duration dt);
 
    void UpdateSelf(Duration dt);
 
    virtual void Render(RenderContext& ctx);
 
    virtual void RenderBorder(RenderContext& ctx);
 
    virtual bool CheckVisibility(RenderContext& ctx) const;
 
    virtual void PrepareToRender(RenderContext& ctx);
 
    void UpdateTransform() const;
 
    void UpdateTransformUpwards() const;
 
    void UpdateOpacity();
 
    void Reorder();
 
    void SetStage(Stage* stage);
 
    enum DirtyFlag : uint8_t
    {
        Clean                 = 0,
        DirtyTransform        = 1,
        DirtyTransformInverse = 1 << 1,
        DirtyOpacity          = 1 << 2,
        DirtyVisibility       = 1 << 3
    };
 
    Flag<uint8_t>& GetDirtyFlag() const;
 
private:
    bool         visible_;
    bool         update_pausing_;
    bool         cascade_opacity_;
    bool         show_border_;
    mutable bool visible_in_rt_;
 
    mutable Flag<uint8_t> dirty_flag_;
 
    int            z_order_;
    float          opacity_;
    float          displayed_opacity_;
    Actor*         parent_;
    Stage*         stage_;
    size_t         hash_name_;
    Point          anchor_;
    Size           size_;
    ActorList      children_;
    UpdateCallback cb_update_;
    Transform      transform_;
 
    mutable Matrix3x2 transform_matrix_;
    mutable Matrix3x2 transform_matrix_inverse_;
    mutable Matrix3x2 transform_matrix_to_parent_;
};
 
inline void Actor::OnUpdate(Duration dt)
{
    KGE_NOT_USED(dt);
}
 
inline void Actor::OnRender(RenderContext& ctx)
{
    KGE_NOT_USED(ctx);
}
 
inline Flag<uint8_t>& Actor::GetDirtyFlag() const
{
    return dirty_flag_;
}
 
inline bool Actor::IsVisible() const
{
    return visible_;
}
 
inline bool Actor::IsCascadeOpacityEnabled() const
{
    return cascade_opacity_;
}
 
inline size_t Actor::GetHashName() const
{
    return hash_name_;
}
 
inline int Actor::GetZOrder() const
{
    return z_order_;
}
 
inline Point Actor::GetPosition() const
{
    return transform_.position;
}
 
inline float Actor::GetPositionX() const
{
    return GetPosition().x;
}
 
inline float Actor::GetPositionY() const
{
    return GetPosition().y;
}
 
inline Point Actor::GetScale() const
{
    return transform_.scale;
}
 
inline float Actor::GetScaleX() const
{
    return GetScale().x;
}
 
inline float Actor::GetScaleY() const
{
    return GetScale().y;
}
 
inline Point Actor::GetSkew() const
{
    return transform_.skew;
}
 
inline float Actor::GetSkewX() const
{
    return GetSkew().x;
}
 
inline float Actor::GetSkewY() const
{
    return GetSkew().y;
}
 
inline float Actor::GetRotation() const
{
    return transform_.rotation;
}
 
inline float Actor::GetWidth() const
{
    return GetSize().x;
}
 
inline float Actor::GetHeight() const
{
    return GetSize().y;
}
 
inline Size Actor::GetSize() const
{
    return size_;
}
 
inline float Actor::GetScaledWidth() const
{
    return GetWidth() * GetScaleX();
}
 
inline float Actor::GetScaledHeight() const
{
    return GetHeight() * GetScaleY();
}
 
inline Size Actor::GetScaledSize() const
{
    return Size{ GetScaledWidth(), GetScaledHeight() };
}
 
inline Point Actor::GetAnchor() const
{
    return anchor_;
}
 
inline float Actor::GetAnchorX() const
{
    return GetAnchor().x;
}
 
inline float Actor::GetAnchorY() const
{
    return GetAnchor().y;
}
 
inline float Actor::GetOpacity() const
{
    return opacity_;
}
 
inline float Actor::GetDisplayedOpacity() const
{
    return displayed_opacity_;
}
 
inline Transform Actor::GetTransform() const
{
    return transform_;
}
 
inline Actor* Actor::GetParent() const
{
    return parent_;
}
 
inline Stage* Actor::GetStage() const
{
    return stage_;
}
 
inline void Actor::PauseUpdating()
{
    update_pausing_ = true;
}
 
inline void Actor::ResumeUpdating()
{
    update_pausing_ = false;
}
 
inline bool Actor::IsUpdatePausing() const
{
    return update_pausing_;
}
 
inline void Actor::SetCallbackOnUpdate(const UpdateCallback& cb)
{
    cb_update_ = cb;
}
 
inline Actor::UpdateCallback Actor::GetCallbackOnUpdate() const
{
    return cb_update_;
}
 
inline void Actor::ShowBorder(bool show)
{
    show_border_ = show;
}
 
inline void Actor::SetPosition(float x, float y)
{
    this->SetPosition(Point(x, y));
}
 
inline void Actor::SetPositionX(float x)
{
    this->SetPosition(Point(x, transform_.position.y));
}
 
inline void Actor::SetPositionY(float y)
{
    this->SetPosition(Point(transform_.position.x, y));
}
 
inline void Actor::MoveTo(const Point& p)
{
    this->SetPosition(p);
}
 
inline void Actor::MoveTo(float x, float y)
{
    this->SetPosition(Point(x, y));
}
 
inline void Actor::MoveBy(const Vec2& trans)
{
    this->SetPosition(transform_.position.x + trans.x, transform_.position.y + trans.y);
}
 
inline void Actor::MoveBy(float trans_x, float trans_y)
{
    this->MoveBy(Vec2(trans_x, trans_y));
}
 
inline void Actor::SetScale(float scalex, float scaley)
{
    this->SetScale(Vec2(scalex, scaley));
}
 
inline void Actor::SetAnchor(float anchorx, float anchory)
{
    this->SetAnchor(Vec2(anchorx, anchory));
}
 
inline void Actor::SetSize(float width, float height)
{
    this->SetSize(Size(width, height));
}
 
inline void Actor::SetWidth(float width)
{
    this->SetSize(Size(width, size_.y));
}
 
inline void Actor::SetHeight(float height)
{
    this->SetSize(Size(size_.x, height));
}
 
inline void Actor::SetSkew(float skewx, float skewy)
{
    this->SetSkew(Vec2(skewx, skewy));
}
 
}  // namespace kiwano