RenderContext.h

// Copyright (c) 2016-2019 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/core/Time.h>
#include <kiwano/render/Brush.h>
#include <kiwano/render/Shape.h>
#include <kiwano/render/Layer.h>
#include <kiwano/render/TextLayout.h>
#include <kiwano/render/Texture.h>
 
namespace kiwano
{
 
enum class TextAntialiasMode
{
    Default,    
    ClearType,  
    GrayScale,  
    None        
};
 
enum class BlendMode
{
    SourceOver = 0,
    Copy       = 1,
    Min        = 2,
    Add        = 3,
    Max        = 4,
};
 
class KGE_API RenderContext : public NativeObject
{
public:
    static RefPtr<RenderContext> Create(RefPtr<Texture> texture, const PixelSize& size);
 
    virtual void BeginDraw();
 
    virtual void EndDraw();
 
    virtual void CreateTexture(Texture& texture, const PixelSize& size) = 0;
 
    virtual void DrawTexture(const Texture& texture, const Rect* src_rect = nullptr,
                             const Rect* dest_rect = nullptr) = 0;
 
    virtual void DrawTextLayout(const TextLayout& layout, const Point& offset, RefPtr<Brush> outline_brush) = 0;
 
    virtual void DrawShape(const Shape& shape) = 0;
 
    virtual void DrawLine(const Point& point1, const Point& point2) = 0;
 
    virtual void DrawRectangle(const Rect& rect) = 0;
 
    virtual void DrawRoundedRectangle(const Rect& rect, const Vec2& radius) = 0;
 
    virtual void DrawCircle(const Point& center, float radius);
 
    virtual void DrawEllipse(const Point& center, const Vec2& radius) = 0;
 
    virtual void FillShape(const Shape& shape) = 0;
 
    virtual void FillRectangle(const Rect& rect) = 0;
 
    virtual void FillRoundedRectangle(const Rect& rect, const Vec2& radius) = 0;
 
    virtual void FillCircle(const Point& center, float radius);
 
    virtual void FillEllipse(const Point& center, const Vec2& radius) = 0;
 
    virtual void PushClipRect(const Rect& clip_rect) = 0;
 
    virtual void PopClipRect() = 0;
 
    virtual void PushLayer(Layer& layer) = 0;
 
    virtual void PopLayer() = 0;
 
    virtual void Clear() = 0;
 
    virtual void Clear(const Color& clear_color) = 0;
 
    virtual Size GetSize() const = 0;
 
    virtual float GetBrushOpacity() const;
 
    virtual RefPtr<Brush> GetCurrentBrush() const;
 
    virtual const Matrix3x2& GetGlobalTransform() const;
 
    virtual void SetBrushOpacity(float opacity);
 
    virtual void SetCurrentBrush(RefPtr<Brush> brush);
 
    virtual void SetCurrentStrokeStyle(RefPtr<StrokeStyle> stroke);
 
    virtual void SetBlendMode(BlendMode blend) = 0;
 
    virtual void SetAntialiasMode(bool enabled) = 0;
 
    virtual void SetTextAntialiasMode(TextAntialiasMode mode) = 0;
 
    virtual bool CheckVisibility(const Rect& bounds, const Matrix3x2& transform) = 0;
 
    virtual void Resize(const Size& size) = 0;
 
    virtual void SetTransform(const Matrix3x2& matrix) = 0;
 
    virtual void SetGlobalTransform(const Matrix3x2& matrix);
 
    virtual void SetGlobalTransform(const Matrix3x2* matrix);
 
    virtual RefPtr<Texture> GetTarget() const = 0;
 
public:
    struct Status
    {
        uint32_t primitives;  
        Time     start;       
        Duration duration;    
 
        Status();
    };
 
    void SetCollectingStatus(bool enable);
 
    const Status& GetStatus() const;
 
protected:
    RenderContext();
 
    void IncreasePrimitivesCount(uint32_t increase = 1) const;
 
protected:
    bool                antialias_;
    bool                fast_global_transform_;
    mutable bool        collecting_status_;
    float               brush_opacity_;
    TextAntialiasMode   text_antialias_;
    RefPtr<Brush>       current_brush_;
    RefPtr<StrokeStyle> current_stroke_;
    Rect                visible_size_;
    Matrix3x2           global_transform_;
    mutable Status      status_;
};
 
inline RenderContext::Status::Status()
    : primitives(0)
{
}
 
inline const RenderContext::Status& RenderContext::GetStatus() const
{
    return status_;
}
 
}  // namespace kiwano