gfx.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ------------------------------------------------------------------ colour */
 
typedef uint16_t gfx_color_t;

#define GFX_RGB(r, g, b)                                                    \
    ((gfx_color_t)((((uint16_t)(r) & 0xF8u) << 8) |                         \
                   (((uint16_t)(g) & 0xFCu) << 3) |                         \
                   (((uint16_t)(b) & 0xF8u) >> 3)))
 
#define GFX_BLACK       GFX_RGB(0, 0, 0)
#define GFX_WHITE       GFX_RGB(255, 255, 255)
#define GFX_RED         GFX_RGB(255, 0, 0)
#define GFX_GREEN       GFX_RGB(0, 255, 0)
#define GFX_BLUE        GFX_RGB(0, 0, 255)
#define GFX_YELLOW      GFX_RGB(255, 255, 0)
#define GFX_CYAN        GFX_RGB(0, 255, 255)
#define GFX_MAGENTA     GFX_RGB(255, 0, 255)
#define GFX_GREY(v)     GFX_RGB(v, v, v)
 

static inline void gfx_unpack(gfx_color_t c, uint8_t *r, uint8_t *g, uint8_t *b)
{
    uint8_t r5 = (uint8_t)((c >> 11) & 0x1Fu);
    uint8_t g6 = (uint8_t)((c >> 5) & 0x3Fu);
    uint8_t b5 = (uint8_t)(c & 0x1Fu);
    if (r) { *r = (uint8_t)((r5 << 3) | (r5 >> 2)); }
    if (g) { *g = (uint8_t)((g6 << 2) | (g6 >> 4)); }
    if (b) { *b = (uint8_t)((b5 << 3) | (b5 >> 2)); }
}

gfx_color_t gfx_lerp(gfx_color_t a, gfx_color_t b, uint8_t t);
 
/* ----------------------------------------------------------------- geometry */
 
typedef struct {
    int16_t x, y, w, h;
} gfx_rect_t;
 
/*
 * Saturate rather than truncate.  The fields are int16_t and the arguments are
 * int, so a plain cast draws a shape that is entirely off-screen back onto the
 * panel at a wrapped position -- which is the opposite of clipping, and turns
 * an out-of-range blit's source offset into a read far outside its buffer.
 */
static inline int16_t gfx_i16(int v)
{
    if (v < INT16_MIN) { return INT16_MIN; }
    if (v > INT16_MAX) { return INT16_MAX; }
    return (int16_t)v;
}
 
static inline gfx_rect_t gfx_rect_make(int x, int y, int w, int h)
{
    /* Clamp the far edge in int, so a saturated origin cannot silently shrink
     * or grow the extent. */
    long x1 = (long)x + (long)w;
    long y1 = (long)y + (long)h;
    int16_t rx = gfx_i16(x);
    int16_t ry = gfx_i16(y);
    if (x1 > INT16_MAX) { x1 = INT16_MAX; }
    if (x1 < INT16_MIN) { x1 = INT16_MIN; }
    if (y1 > INT16_MAX) { y1 = INT16_MAX; }
    if (y1 < INT16_MIN) { y1 = INT16_MIN; }
    gfx_rect_t r = { rx, ry, gfx_i16((int)(x1 - rx)), gfx_i16((int)(y1 - ry)) };
    return r;
}
 
static inline bool gfx_rect_empty(gfx_rect_t r)
{
    return r.w <= 0 || r.h <= 0;
}
 
static inline bool gfx_rect_contains(gfx_rect_t r, int x, int y)
{
    return x >= r.x && y >= r.y && x < r.x + r.w && y < r.y + r.h;
}

bool gfx_rect_intersect(gfx_rect_t a, gfx_rect_t b, gfx_rect_t *out);
 
/* ------------------------------------------------------------------- canvas */
 
typedef struct {
    gfx_color_t *pixels;  
    int16_t      width;   
    int16_t      height;  
    int32_t      stride;  
    gfx_rect_t   clip;    
} gfx_canvas_t;

void gfx_canvas_init(gfx_canvas_t *c, gfx_color_t *pixels,
                     int width, int height, int32_t stride);

bool gfx_canvas_sub(const gfx_canvas_t *src, gfx_rect_t window, gfx_canvas_t *out);

bool gfx_clip_set(gfx_canvas_t *c, gfx_rect_t r);
bool gfx_clip_intersect(gfx_canvas_t *c, gfx_rect_t r);
void gfx_clip_reset(gfx_canvas_t *c);
static inline gfx_rect_t gfx_clip_get(const gfx_canvas_t *c) { return c->clip; }
 
/* --------------------------------------------------------------- primitives */
 
void gfx_clear(gfx_canvas_t *c, gfx_color_t color);
void gfx_pixel(gfx_canvas_t *c, int x, int y, gfx_color_t color);
gfx_color_t gfx_pixel_get(const gfx_canvas_t *c, int x, int y);
 
void gfx_fill_rect(gfx_canvas_t *c, int x, int y, int w, int h, gfx_color_t color);
void gfx_draw_rect(gfx_canvas_t *c, int x, int y, int w, int h, gfx_color_t color);
void gfx_hline(gfx_canvas_t *c, int x, int y, int w, gfx_color_t color);
void gfx_vline(gfx_canvas_t *c, int x, int y, int h, gfx_color_t color);
void gfx_line(gfx_canvas_t *c, int x0, int y0, int x1, int y1, gfx_color_t color);
void gfx_thick_line(gfx_canvas_t *c, int x0, int y0, int x1, int y1,
                    int thickness, gfx_color_t color);
 
void gfx_draw_circle(gfx_canvas_t *c, int cx, int cy, int r, gfx_color_t color);
 
/*
 * Antialiased disc and capsule, filled from the distance to their own centre
 * or spine.  The capsule is a thick line with round ends, and its sides and
 * caps come out of one expression -- so there is no seam where they meet,
 * which a disc drawn over a rectangle cannot avoid.
 */
void gfx_fill_circle_aa(gfx_canvas_t *c, int cx, int cy, int r,
                        gfx_color_t col);
void gfx_capsule_aa(gfx_canvas_t *c, int ax, int ay, int bx, int by,
                    int thickness, gfx_color_t col);
void gfx_fill_circle(gfx_canvas_t *c, int cx, int cy, int r, gfx_color_t color);
 
/*
 * An arc of @p thickness centred on (cx, cy), from @p a0_deg to @p a1_deg.
 * Angles are degrees counter-clockwise from the +x axis, so 90 is straight up
 * on screen.  The radial edges are antialiased.
 */
void gfx_arc(gfx_canvas_t *c, int cx, int cy, int r, int thickness,
             float a0_deg, float a1_deg, gfx_color_t col);
 
/*
 * The same arc, with each end brought up out of @p into over @p fade_deg and
 * taken back down into it.  An arc that stops dead has two bright full-width
 * ends that read as breakage; one that dissolves reads as an arc lit over
 * part of its length.
 */
void gfx_arc_fade(gfx_canvas_t *c, int cx, int cy, int r, int thickness,
                  float a0_deg, float a1_deg, gfx_color_t col,
                  gfx_color_t into, float fade_deg);
 
void gfx_draw_round_rect(gfx_canvas_t *c, int x, int y, int w, int h,
                         int r, gfx_color_t color);
void gfx_fill_round_rect(gfx_canvas_t *c, int x, int y, int w, int h,
                         int r, gfx_color_t color);
 
/*
 * Chamfered (cut-corner) rectangles.  The cut is a 45-degree bevel of the
 * given size, controlled per corner: cutting only the top-left and
 * bottom-right of a panel gives a different look from cutting all four.  A
 * cut of 0 leaves that corner square.
 */
void gfx_fill_chamfer_rect(gfx_canvas_t *c, int x, int y, int w, int h,
                           int cut, gfx_color_t color);
void gfx_draw_chamfer_rect(gfx_canvas_t *c, int x, int y, int w, int h,
                           int cut, gfx_color_t color);
void gfx_fill_chamfer_rect_ex(gfx_canvas_t *c, int x, int y, int w, int h,
                              int tl, int tr, int br, int bl, gfx_color_t color);
void gfx_draw_chamfer_rect_ex(gfx_canvas_t *c, int x, int y, int w, int h,
                              int tl, int tr, int br, int bl, gfx_color_t color);

void gfx_fill_rect_gradient(gfx_canvas_t *c, int x, int y, int w, int h,
                            gfx_color_t a, gfx_color_t b);
 
/* -------------------------------------------------------------------- blits */

void gfx_blit(gfx_canvas_t *c, int x, int y, const gfx_color_t *src,
              int w, int h, int32_t src_stride);
void gfx_blit_key(gfx_canvas_t *c, int x, int y, const gfx_color_t *src,
                  int w, int h, int32_t src_stride, gfx_color_t key);
void gfx_blit_1bpp(gfx_canvas_t *c, int x, int y, const uint8_t *bits,
                   int w, int h, gfx_color_t fg);
 
/* --------------------------------------------------------------------- text */
 
/*
 * Text is UTF-8 (Unicode Transformation Format, 8-bit).  Every string a
 * primitive below takes is decoded to code points, and one code point is one
 * cell: the width of a string is its code point count times the cell width,
 * not its byte count.  A font holds the contiguous block first..last and,
 * after it, `extra_count` further glyphs for the code points listed in
 * `extra` (the German letters A, O and U with diaeresis, upper and lower
 * case, and the sharp s).  A code point the font does not hold draws as '?',
 * and a byte that does not start a well-formed sequence is one '?' cell.
 */
typedef struct {
    const uint8_t *glyphs;  
    uint8_t width;          
    uint8_t height;         
    uint8_t bytes_per_row;  
    uint8_t bpp;            
    uint8_t first;          
    uint8_t last;           
    uint8_t extra_count;    
    const uint16_t *extra;  
} gfx_font_t;

extern const gfx_font_t gfx_font_8x16;
extern const gfx_font_t gfx_font_16x28;
extern const gfx_font_t gfx_font_num_24x30;
extern const gfx_font_t gfx_font_10x20;
extern const gfx_font_t gfx_font_12x24;
extern const gfx_font_t gfx_font_20x36;
extern const gfx_font_t gfx_font_num_32x44;
 
/* ------------------------------------------------- seven-segment numerals */
 
/*
 * The look of a bench instrument rather than of a screen: digits built from
 * seven bars, with the unlit ones optionally left showing.  Covers 0-9, '-',
 * '.', ':' and space; anything else draws as blank.
 */
typedef struct {
    int  digit_w;    
    int  digit_h;
    int  thickness;  
    int  gap;        
    int  slant;      
    bool ghost;      
} gfx_seg_style_t;

int gfx_seg_text(gfx_canvas_t *c, int x, int y, const char *s,
                 const gfx_seg_style_t *st, gfx_color_t on, gfx_color_t off);
int gfx_seg_width(const char *s, const gfx_seg_style_t *st);

uint32_t gfx_utf8_next(const char **s);

int gfx_text_cells(const char *s);

size_t gfx_text_prefix(const char *s, int cells);

int gfx_text_width(const gfx_font_t *font, const char *s, int scale);
int gfx_text_height(const gfx_font_t *font, int scale);

int gfx_char(gfx_canvas_t *c, int x, int y, char ch, const gfx_font_t *font,
             gfx_color_t fg, int scale);
int gfx_text(gfx_canvas_t *c, int x, int y, const char *s,
             const gfx_font_t *font, gfx_color_t fg, int scale);
int gfx_text_bg(gfx_canvas_t *c, int x, int y, const char *s,
                const gfx_font_t *font, gfx_color_t fg, gfx_color_t bg, int scale);

int gfx_text_rotated_points(gfx_canvas_t *c, int cx, int cy, const char *s,
                            const gfx_font_t *font, int scale, uint8_t alpha,
                            float angle_deg, uint32_t *out, int max_out);
 
void gfx_text_rotated(gfx_canvas_t *c, int cx, int cy, const char *s,
                      const gfx_font_t *font, gfx_color_t fg, int scale,
                      uint8_t alpha, float angle_deg);
 
typedef enum {
    GFX_ALIGN_LEFT = 0,
    GFX_ALIGN_CENTER,
    GFX_ALIGN_RIGHT,
} gfx_align_t;

void gfx_text_in(gfx_canvas_t *c, gfx_rect_t box, const char *s,
                 const gfx_font_t *font, gfx_color_t fg, int scale,
                 gfx_align_t align);
 
#ifdef GFX_TEXT_TRACE
/*
 * The fit check's view of a frame, compiled in only when GFX_TEXT_TRACE is
 * defined: the panel and the host suite build without it.  The harness
 * that defines GFX_TEXT_TRACE defines these two.  Coordinates are the
 * canvas's own; the harness maps a sub-canvas back to the panel from its
 * pixel pointer.
 *
 * gfx_trace_text() is called for every string drawn: its box, and the box
 * gfx_text_in() was given (NULL from the other primitives).
 * gfx_trace_box() is called for every filled rounded or chamfered
 * rectangle: the shapes a label sits inside.
 */
void gfx_trace_text(const gfx_canvas_t *c, int x, int y, int w, int h,
                    const char *s, const gfx_rect_t *box);
void gfx_trace_box(const gfx_canvas_t *c, int x, int y, int w, int h);
#endif
 
#ifdef __cplusplus
}
#endif