ds_renderer.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_RENDERER_H
#define _DS_RENDERER_H
 
 
#include <ds_types.h>
#include <ds_font.h>
 
#include <ds_string.h>
#include <ds_surface.h>
 
 
 
DsSize DsTextSize(const ds_bitmap_font_t* font, float row_spacing, const char* text, size_t length = -1);
 
 
 
class DsRenderer
{
public:
    void setSurface(DsSurface &surface);
 
    DsSurface& getSurface(void);
 
 
    void pushClipRegion(DsRegion &region);
 
 
    void popClipRegion(void);
 
    
    void unrollClipRegions(uint8_t level);
 
    
    void clearClipRegions(void);
 
 
 
    DsRenderer newRenderer(DsSurface &surface);
 
    
    void setSupersampling(int32_t ss);
 
 
    void drawLine(DsPoint p0, DsPoint p1, DsColor color);
    
 
    void drawRectangle(DsRect rect, uint16_t thickness, DsColor color);
 
    
    inline void drawRoundedRectangle(DsRect rect, DsColor color, uint16_t corner_radius)
    {
        drawRoundedRectangle(rect, color, corner_radius, corner_radius, corner_radius, corner_radius);
    }
 
    void drawRoundedRectangle(DsRect rect, DsColor color, uint16_t corner_radius_tl, uint16_t corner_radius_tr, uint16_t corner_radius_br, uint16_t corner_radius_bl);
 
    
    void fillRectangle(DsRect rect, DsColor color);
    
    
    inline void fillRoundedRectangle(DsRect rect, DsColor color, uint16_t corner_radius)
    {
        fillRoundedRectangle(rect, color, corner_radius, corner_radius, corner_radius, corner_radius);
    }
 
    void fillRoundedRectangle(DsRect rect, DsColor color, uint16_t corner_radius_tl, uint16_t corner_radius_tr, uint16_t corner_radius_br, uint16_t corner_radius_bl);
    
    
    void drawPoly(const DsPoint* points, uint32_t np, DsColor color);
 
    
    void fillPoly(const DsPoint* points, uint32_t np, DsColor color);
 
 
    inline void drawCircle(DsFPoint center, float radius, float thickness, DsColor color)
    {
        drawEllipse(DsEllipse(center, radius), thickness, color);
    }
 
    inline void fillCircle(DsFPoint center, float radius, DsColor color)
    {
        fillEllipse(DsEllipse(center, radius), color);
    }
 
    void drawEllipse(DsEllipse ellipse, float thickness, DsColor color);
 
    
    void fillEllipse(DsEllipse ellipse, DsColor color);
 
 
    void drawEllipseArc(DsEllipse ellipse, float thickness, float start_angle, float end_angle, DsColor color);
 
 
    void fillEllipseArc(DsEllipse ellipse, float start_angle, float end_angle, DsColor color);
 
 
    inline void drawCircleArc(DsFPoint center, float radius, float thickness, float start_angle, float end_angle, DsColor color)
    {
        drawEllipseArc(DsEllipse(center, radius), thickness, start_angle, end_angle, color);
    }
    
 
    inline void fillCircleArc(DsFPoint center, float radius, float start_angle, float end_angle, DsColor color)
    {
        fillEllipseArc(DsEllipse(center, radius), start_angle, end_angle, color);
    }
 
 
    void drawLineAA(const DsFPoint &p0, const DsFPoint &p1, float thickness, DsColor color);
 
    
    void drawPolyAA(const DsFPoint* points, uint32_t np, float thickness, DsColor color);
    
    
    void fillPolyAA(const DsFPoint* points, uint32_t np, DsColor color);
 
 
    inline void fillRectangleAA(DsFRect rect, DsColor color)
    {
        fillRoundedRectangleAA(rect, color, 0, 0, 0, 0);
    }
 
 
    inline void drawRoundedRectangleAA(DsFRect rect, DsColor color, float thickness, float corner_radius)
    {
        drawRoundedRectangleAA(rect, color, thickness, corner_radius, corner_radius, corner_radius, corner_radius);
    }
 
    void drawRoundedRectangleAA(DsFRect rect, DsColor color, float thickness, float corner_radius_tl, float corner_radius_tr, float corner_radius_br, float corner_radius_bl);
 
 
    inline void fillRoundedRectangleAA(DsFRect rect, DsColor color, float corner_radius)
    {
        if (corner_radius > 0)
            fillRoundedRectangleAA(rect, color, corner_radius, corner_radius, corner_radius, corner_radius);
        else
            fillRectangle(rect, color);
    }
 
    void fillRoundedRectangleAA(DsFRect rect, DsColor color, float corner_radius_tl, float corner_radius_tr, float corner_radius_br, float corner_radius_bl);
 
 
    void drawEllipseAA(DsEllipse ellipse, float thickness, DsColor color);
 
 
    void fillEllipseAA(DsEllipse ellipse, DsColor color);
 
 
    inline void drawCircleAA(DsFPoint center, float radius, float thickness, DsColor color)
    {
        drawEllipseAA(DsEllipse(center, radius), thickness, color);
    }
 
    inline void fillCircleAA(DsFPoint center, float radius, DsColor color)
    {
        fillEllipseAA(DsEllipse(center, radius), color);
    }
 
 
    void drawEllipseArcAA(DsEllipse ellipse, float thickness, float start, float end, DsColor color);
 
 
    void fillEllipseArcAA(DsEllipse ellipse, float start, float end, DsColor color);
 
 
    inline void drawCircleArcAA(DsFPoint center, float radius, float thickness, float start, float end, DsColor color)
    {
        drawEllipseArcAA(DsEllipse(center, radius), thickness, start, end, color);
    }
    
 
    inline void fillCircleArcAA(DsFPoint center, float radius, float start, float end, DsColor color)
    {
        fillEllipseArcAA(DsEllipse(center, radius), start, end, color);
    }
 
    
 
    DsRect renderText(DsPoint pos, const ds_bitmap_font_t* font, DsColor color, const char* text, size_t length = DsString::npos);
 
    DsRect renderMultilineText(DsPoint pos, const ds_bitmap_font_t* font, DsColor color, const DsAlignment &line_alignment, float row_spacing, const char* text, size_t length = DsString::npos);
    
    
    DsRect renderTextAligned(const DsRect &boundary, const DsAlignment &alignment, const DsPoint &offset, const ds_bitmap_font_t* font, DsColor color, const char* text, size_t length = DsString::npos);
    
    
    DsRect renderMultilineTextAligned(const DsRect &boundary, const DsAlignment &text_alignment, const DsPoint &offset, const ds_bitmap_font_t* font, DsColor color, const DsAlignment &line_alignment, float row_spacing, const char* text, size_t length = DsString::npos);
 
 
    DsRect renderTextCentered(DsPoint pos, const ds_bitmap_font_t* font, DsColor color, const char* text, size_t length = DsString::npos);
    
    
    DsRect renderMultilineTextCentered(DsPoint pos, const ds_bitmap_font_t* font, DsColor color, const DsAlignment &line_alignment, float row_spacing, const char* text, size_t length = DsString::npos);
 
 
    void moveClipRegions(const DsFPoint &offset);
    static bool clipLine(const DsRect &bounds, int32_t &x0, int32_t &y0, int32_t &x1, int32_t &y1);
    
private:
    friend class DsScreen;
 
    typedef struct
    {
        uint8_t* pixels;
        uint32_t width;
        int32_t min;
        int32_t max;
    }ds_scanline_t;
 
    uint32_t mSsCoeffLog2;
    uint32_t mSsCoeff;
    uint32_t mSsInc8;
    uint32_t mSsInc32;
    float mSsYInc;
    ds_scanline_t mScanlineBuffers[2];
 
    DsSurface* mSurface;
    uint8_t* mScanlineAlpha;
 
    DsRegion* mClipRegions[8];      
    uint8_t mClipRegionCount;
 
    DsRenderer(const void* memory, const void* memory_aa, uint32_t width, uint32_t height);
 
    void scanline_blend(int32_t y, int32_t xl, int32_t xr);
    void render_line_h(int32_t y, int32_t x0, int32_t x1, DsColor color);
    void render_line_v(int32_t x, int32_t y0, int32_t y1, DsColor color);
 
    void scanline_clear_aa(ds_scanline_t* line);
    void scanline_blend_init_aa(DsColor color);
    void scanline_blend_aa(ds_scanline_t* line, int32_t y, int32_t xoff);
    void scanline_draw_aa(float y, float xl, float xr, ds_scanline_t* line, int32_t xoff);
};
 
 
#endif