ShapeActor.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/2d/Actor.h>
#include <kiwano/render/Brush.h>
#include <kiwano/render/Shape.h>
#include <kiwano/render/ShapeMaker.h>
#include <kiwano/render/StrokeStyle.h>
 
namespace kiwano
{
 
class KGE_API ShapeActor : public Actor
{
public:
    ShapeActor();
 
    ShapeActor(RefPtr<Shape> shape);
 
    ShapeActor(RefPtr<Shape> shape, const Color& fill_color, const Color& stroke_color);
 
    ShapeActor(RefPtr<Shape> shape, RefPtr<Brush> fill_brush, RefPtr<Brush> stroke_brush);
 
    virtual ~ShapeActor();
 
    RefPtr<Brush> GetFillBrush() const;
 
    RefPtr<Brush> GetStrokeBrush() const;
 
    RefPtr<StrokeStyle> GetStrokeStyle() const;
 
    RefPtr<Shape> GetShape() const;
 
    Rect GetBounds() const override;
 
    Rect GetBoundingBox() const override;
 
    bool ContainsPoint(const Point& point) const override;
 
    void SetFillColor(const Color& color);
 
    void SetFillBrush(RefPtr<Brush> brush);
 
    void SetStrokeColor(const Color& color);
 
    void SetStrokeBrush(RefPtr<Brush> brush);
 
    void SetStrokeStyle(RefPtr<StrokeStyle> stroke_style);
 
    void SetShape(RefPtr<Shape> shape);
 
    void OnRender(RenderContext& ctx) override;
 
protected:
    bool CheckVisibility(RenderContext& ctx) const override;
 
private:
    RefPtr<Brush>       fill_brush_;
    RefPtr<Brush>       stroke_brush_;
    RefPtr<StrokeStyle> stroke_style_;
    Rect                bounds_;
    RefPtr<Shape>       shape_;
};
 
class KGE_API LineActor : public ShapeActor
{
public:
    LineActor();
 
    LineActor(const Point& begin, const Point& end);
 
    virtual ~LineActor();
 
    const Point& GetBeginPoint() const;
 
    const Point& GetEndPoint() const;
 
    void SetBeginPoint(const Point& begin);
 
    void SetEndPoint(const Point& end);
 
    void SetLine(const Point& begin, const Point& end);
 
private:
    Point begin_;
    Point end_;
};
 
class KGE_API RectActor : public ShapeActor
{
public:
    RectActor();
 
    RectActor(const Size& size);
 
    virtual ~RectActor();
 
    const Size& GetRectSize() const;
 
    void SetRectSize(const Size& size);
 
private:
    Size rect_size_;
};
 
class KGE_API RoundedRectActor : public ShapeActor
{
public:
    RoundedRectActor();
 
    RoundedRectActor(const Size& size, const Vec2& radius);
 
    virtual ~RoundedRectActor();
 
    Vec2 GetRadius() const;
 
    Size GetRectSize() const;
 
    void SetRadius(const Vec2& radius);
 
    void SetRectSize(const Size& size);
 
    void SetRoundedRect(const Size& size, const Vec2& radius);
 
private:
    Size rect_size_;
    Vec2 radius_;
};
 
class KGE_API CircleActor : public ShapeActor
{
public:
    CircleActor();
 
    CircleActor(float radius);
 
    virtual ~CircleActor();
 
    float GetRadius() const;
 
    void SetRadius(float radius);
 
private:
    float radius_;
};
 
class KGE_API EllipseActor : public ShapeActor
{
public:
    EllipseActor();
 
    EllipseActor(const Vec2& radius);
 
    virtual ~EllipseActor();
 
    Vec2 GetRadius() const;
 
    void SetRadius(const Vec2& radius);
 
private:
    Vec2 radius_;
};
 
class KGE_API PolygonActor : public ShapeActor
{
public:
    PolygonActor();
 
    PolygonActor(const Vector<Point>& vertices);
 
    virtual ~PolygonActor();
 
    void SetVertices(const Vector<Point>& vertices);
};
 
inline void ShapeActor::SetStrokeColor(const Color& color)
{
    if (!stroke_brush_)
    {
        stroke_brush_ = MakePtr<Brush>();
    }
    stroke_brush_->SetColor(color);
}
 
inline void ShapeActor::SetFillColor(const Color& color)
{
    if (!fill_brush_)
    {
        fill_brush_ = MakePtr<Brush>();
    }
    fill_brush_->SetColor(color);
}
 
inline void ShapeActor::SetFillBrush(RefPtr<Brush> brush)
{
    fill_brush_ = brush;
}
 
inline void ShapeActor::SetStrokeBrush(RefPtr<Brush> brush)
{
    stroke_brush_ = brush;
}
 
inline RefPtr<Brush> ShapeActor::GetFillBrush() const
{
    return fill_brush_;
}
 
inline RefPtr<Brush> ShapeActor::GetStrokeBrush() const
{
    return stroke_brush_;
}
 
inline RefPtr<StrokeStyle> ShapeActor::GetStrokeStyle() const
{
    return stroke_style_;
}
 
inline RefPtr<Shape> ShapeActor::GetShape() const
{
    return shape_;
}
 
inline void ShapeActor::SetStrokeStyle(RefPtr<StrokeStyle> stroke_style)
{
    stroke_style_ = stroke_style;
}
 
inline const Point& LineActor::GetBeginPoint() const
{
    return begin_;
}
 
inline const Point& LineActor::GetEndPoint() const
{
    return end_;
}
 
inline void LineActor::SetBeginPoint(const Point& begin)
{
    SetLine(begin, end_);
}
 
inline void LineActor::SetEndPoint(const Point& end)
{
    SetLine(begin_, end);
}
 
inline const Size& RectActor::GetRectSize() const
{
    return rect_size_;
}
 
inline Vec2 RoundedRectActor::GetRadius() const
{
    return radius_;
}
 
inline Size RoundedRectActor::GetRectSize() const
{
    return GetSize();
}
 
inline float CircleActor::GetRadius() const
{
    return radius_;
}
 
inline Vec2 EllipseActor::GetRadius() const
{
    return radius_;
}
 
}  // namespace kiwano