Canvas.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/ShapeMaker.h>
#include <kiwano/render/RenderContext.h>
 
namespace kiwano
{
class CanvasRenderContext;
 
class KGE_API Canvas : public Actor
{
public:
    Canvas();
 
    Canvas(const Size& size);
 
    RefPtr<CanvasRenderContext> GetContext2D() const;
 
    void ResizeAndClear(const Size& size);
 
    RefPtr<Bitmap> GetTarget() const;
 
    void EnableCommandListMode(bool enable);
 
    void OnRender(RenderContext& ctx) override;
 
private:
    bool                  cmd_list_mode_;
    RefPtr<Bitmap>        cached_bitmap_;
    RefPtr<RenderContext> render_ctx_;
};
 
class KGE_API CanvasRenderContext : public ObjectBase
{
public:
    void BeginDraw();
 
    void EndDraw();
 
    void DrawActor(RefPtr<Actor> actor);
 
    void DrawShape(RefPtr<Shape> shape);
 
    void DrawLine(const Point& begin, const Point& end);
 
    void DrawCircle(const Point& center, float radius);
 
    void DrawEllipse(const Point& center, const Vec2& radius);
 
    void DrawRect(const Rect& rect);
 
    void DrawRoundedRect(const Rect& rect, const Vec2& radius);
 
    void FillShape(RefPtr<Shape> shape);
 
    void FillCircle(const Point& center, float radius);
 
    void FillEllipse(const Point& center, const Vec2& radius);
 
    void FillRect(const Rect& rect);
 
    void FillRoundedRect(const Rect& rect, const Vec2& radius);
 
    void DrawBitmap(RefPtr<Bitmap> bitmap, const Point& pos, const Rect* crop_rect = nullptr);
 
    void DrawBitmap(RefPtr<Bitmap> bitmap, const Point& pos, const Size& size, const Rect* crop_rect = nullptr);
 
    void DrawTextLayout(StringView text, const TextStyle& style, const Point& point);
 
    void DrawTextLayout(RefPtr<TextLayout> layout, const Point& point);
 
    void Clear();
 
    void Clear(const Color& clear_color);
 
    void SetFillColor(const Color& color);
 
    void SetFillBrush(RefPtr<Brush> brush);
 
    RefPtr<Brush> GetFillBrush() const;
 
    void SetStrokeColor(const Color& color);
 
    void SetStrokeBrush(RefPtr<Brush> brush);
 
    RefPtr<Brush> GetStrokeBrush() const;
 
    void SetStrokeStyle(RefPtr<StrokeStyle> stroke_style);
 
    RefPtr<StrokeStyle> GetStrokeStyle() const;
 
    void PushClipRect(const Rect& clip_rect);
 
    void PopClipRect();
 
    void PushLayer(Layer& layer);
 
    void PopLayer();
 
    Size GetSize() const;
 
    void SetTransform(const Matrix3x2& matrix);
 
    void SetAntialiasMode(bool enabled);
 
    void SetTextAntialiasMode(TextAntialiasMode mode);
 
    virtual ~CanvasRenderContext();
 
private:
    friend class Canvas;
 
    CanvasRenderContext(RefPtr<RenderContext> ctx);
 
private:
    RefPtr<RenderContext> ctx_;
    RefPtr<Brush>         fill_brush_;
    RefPtr<Brush>         stroke_brush_;
    RefPtr<StrokeStyle>   stroke_style_;
};
 
inline RefPtr<Bitmap> Canvas::GetTarget() const
{
    return cached_bitmap_;
}
 
inline void CanvasRenderContext::BeginDraw()
{
    KGE_ASSERT(ctx_);
    ctx_->BeginDraw();
}
 
inline void CanvasRenderContext::EndDraw()
{
    KGE_ASSERT(ctx_);
    ctx_->EndDraw();
}
 
inline void CanvasRenderContext::DrawActor(RefPtr<Actor> actor)
{
    KGE_ASSERT(ctx_);
    if (actor)
    {
        actor->OnRender(*ctx_);
    }
}
 
inline void CanvasRenderContext::DrawShape(RefPtr<Shape> shape)
{
    KGE_ASSERT(ctx_);
    if (shape)
    {
        ctx_->SetCurrentBrush(stroke_brush_);
        ctx_->SetCurrentStrokeStyle(stroke_style_);
        ctx_->DrawShape(*shape);
    }
}
 
inline void CanvasRenderContext::DrawLine(const Point& begin, const Point& end)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(stroke_brush_);
    ctx_->SetCurrentStrokeStyle(stroke_style_);
    ctx_->DrawLine(begin, end);
}
 
inline void CanvasRenderContext::DrawCircle(const Point& center, float radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(stroke_brush_);
    ctx_->SetCurrentStrokeStyle(stroke_style_);
    ctx_->DrawCircle(center, radius);
}
 
inline void CanvasRenderContext::DrawEllipse(const Point& center, const Vec2& radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(stroke_brush_);
    ctx_->SetCurrentStrokeStyle(stroke_style_);
    ctx_->DrawEllipse(center, radius);
}
 
inline void CanvasRenderContext::DrawRect(const Rect& rect)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(stroke_brush_);
    ctx_->SetCurrentStrokeStyle(stroke_style_);
    ctx_->DrawRectangle(rect);
}
 
inline void CanvasRenderContext::DrawRoundedRect(const Rect& rect, const Vec2& radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(stroke_brush_);
    ctx_->SetCurrentStrokeStyle(stroke_style_);
    ctx_->DrawRoundedRectangle(rect, radius);
}
 
inline void CanvasRenderContext::FillShape(RefPtr<Shape> shape)
{
    KGE_ASSERT(ctx_);
    if (shape)
    {
        ctx_->SetCurrentBrush(fill_brush_);
        ctx_->FillShape(*shape);
    }
}
 
inline void CanvasRenderContext::FillCircle(const Point& center, float radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(fill_brush_);
    ctx_->FillCircle(center, radius);
}
 
inline void CanvasRenderContext::FillEllipse(const Point& center, const Vec2& radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(fill_brush_);
    ctx_->FillEllipse(center, radius);
}
 
inline void CanvasRenderContext::FillRect(const Rect& rect)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(fill_brush_);
    ctx_->FillRectangle(rect);
}
 
inline void CanvasRenderContext::FillRoundedRect(const Rect& rect, const Vec2& radius)
{
    KGE_ASSERT(ctx_);
 
    ctx_->SetCurrentBrush(fill_brush_);
    ctx_->FillRoundedRectangle(rect, radius);
}
 
inline void CanvasRenderContext::DrawBitmap(RefPtr<Bitmap> bitmap, const Point& pos, const Rect* crop_rect)
{
    if (bitmap)
    {
        this->DrawBitmap(bitmap, pos, bitmap->GetSize(), crop_rect);
    }
}
 
inline void CanvasRenderContext::DrawBitmap(RefPtr<Bitmap> bitmap, const Point& pos, const Size& size,
                                             const Rect* crop_rect)
{
    KGE_ASSERT(ctx_);
 
    if (bitmap)
    {
        Rect dest_rect(pos, pos + size);
        ctx_->DrawBitmap(*bitmap, crop_rect, &dest_rect);
    }
}
 
inline void CanvasRenderContext::DrawTextLayout(StringView text, const TextStyle& style, const Point& point)
{
    RefPtr<TextLayout> layout = MakePtr<TextLayout>(text, style);
    this->DrawTextLayout(layout, point);
}
 
inline void CanvasRenderContext::DrawTextLayout(RefPtr<TextLayout> layout, const Point& point)
{
    KGE_ASSERT(ctx_);
    if (layout)
    {
        ctx_->SetCurrentBrush(fill_brush_);
        ctx_->SetCurrentStrokeStyle(stroke_style_);
        ctx_->DrawTextLayout(*layout, point, stroke_brush_);
    }
}
 
inline void CanvasRenderContext::Clear()
{
    KGE_ASSERT(ctx_);
    ctx_->Clear();
}
 
inline void CanvasRenderContext::Clear(const Color& clear_color)
{
    KGE_ASSERT(ctx_);
    ctx_->Clear(clear_color);
}
 
inline void CanvasRenderContext::SetFillColor(const Color& color)
{
    if (!fill_brush_)
    {
        fill_brush_ = MakePtr<Brush>();
    }
    fill_brush_->SetColor(color);
}
 
inline void CanvasRenderContext::SetFillBrush(RefPtr<Brush> brush)
{
    fill_brush_ = brush;
}
 
inline RefPtr<Brush> CanvasRenderContext::GetFillBrush() const
{
    return fill_brush_;
}
 
inline void CanvasRenderContext::SetStrokeBrush(RefPtr<Brush> brush)
{
    stroke_brush_ = brush;
}
 
inline void CanvasRenderContext::SetStrokeColor(const Color& color)
{
    if (!stroke_brush_)
    {
        stroke_brush_ = MakePtr<Brush>();
    }
    stroke_brush_->SetColor(color);
}
 
inline RefPtr<Brush> CanvasRenderContext::GetStrokeBrush() const
{
    return stroke_brush_;
}
 
inline void CanvasRenderContext::SetStrokeStyle(RefPtr<StrokeStyle> stroke_style)
{
    stroke_style_ = stroke_style;
}
 
inline RefPtr<StrokeStyle> CanvasRenderContext::GetStrokeStyle() const
{
    return stroke_style_;
}
 
inline void CanvasRenderContext::PushClipRect(const Rect& clip_rect)
{
    KGE_ASSERT(ctx_);
    ctx_->PushClipRect(clip_rect);
}
 
inline void CanvasRenderContext::PopClipRect()
{
    KGE_ASSERT(ctx_);
    ctx_->PopClipRect();
}
 
inline void CanvasRenderContext::PushLayer(Layer& layer)
{
    KGE_ASSERT(ctx_);
    ctx_->PushLayer(layer);
}
 
inline void CanvasRenderContext::PopLayer()
{
    KGE_ASSERT(ctx_);
    ctx_->PopLayer();
}
 
inline Size CanvasRenderContext::GetSize() const
{
    KGE_ASSERT(ctx_);
    return ctx_->GetSize();
}
 
inline void CanvasRenderContext::SetTransform(const Matrix3x2& matrix)
{
    KGE_ASSERT(ctx_);
    ctx_->SetTransform(matrix);
}
 
inline void CanvasRenderContext::SetAntialiasMode(bool enabled)
{
    KGE_ASSERT(ctx_);
    ctx_->SetAntialiasMode(enabled);
}
 
inline void CanvasRenderContext::SetTextAntialiasMode(TextAntialiasMode mode)
{
    KGE_ASSERT(ctx_);
    ctx_->SetTextAntialiasMode(mode);
}
 
}  // namespace kiwano