hsl.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "include/effects/SkGradientShader.h"

Go to the source code of this file.

Functions
static float	min (float r, float g, float b)
static float	max (float r, float g, float b)
static float	sat (float r, float g, float b)
static float	lum (float r, float g, float b)
static void	set_sat (float *r, float *g, float *b, float s)
static void	clip_color (float *r, float *g, float *b)
static void	set_lum (float *r, float *g, float *b, float l)
static void	hue (float dr, float dg, float db, float *sr, float *sg, float *sb)
static void	saturation (float dr, float dg, float db, float *sr, float *sg, float *sb)
static void	color (float dr, float dg, float db, float *sr, float *sg, float *sb)
static void	luminosity (float dr, float dg, float db, float *sr, float *sg, float *sb)
static SkColor	blend (SkColor dst, SkColor src, void(*mode)(float, float, float, float *, float *, float *))
	DEF_SIMPLE_GM (hsl, canvas, 600, 100)
static sk_sp< SkShader >	make_grad (SkScalar width)
	DEF_SIMPLE_GM (HSL_duck, canvas, 1110, 620)

Function Documentation

blend()

static SkColor blend ( SkColor  dst, SkColor  src, void(*)(float, float, float, float *, float *, float *)  mode  )

static

Definition at line 142 of file hsl.cpp.

                                                                            {
 
    SkASSERT(SkColorGetA(dst) == 0xff
          && SkColorGetA(src) == 0xff);   // Not fundamental, just simplifying for this GM.
 
    SkColor4f d = SkColor4f::FromColor(dst),
              s = SkColor4f::FromColor(src);
 
    mode( d.fR,  d.fG,  d.fB,
         &s.fR, &s.fG, &s.fB);
 
    return s.toSkColor();
}

clip_color()

static void clip_color ( float *  r, float *  g, float *  b  )

static

Definition at line 68 of file hsl.cpp.

                                                     {
    float l  = lum(*r,*g,*b),
          mn = min(*r,*g,*b),
          mx = max(*r,*g,*b);
    auto clip = [=](float c) {
        if (mn < 0) { c = l + (c - l) * (    l) / (l - mn); }
        if (mx > 1) { c = l + (c - l) * (1 - l) / (mx - l); }
        SkASSERT(-0.0001f <  c);   // This may end up very slightly negative...
        SkASSERT(       c <= 1);
        return c;
    };
    *r = clip(*r);
    *g = clip(*g);
    *b = clip(*b);
}

color()

static void color ( float  dr, float  dg, float  db, float *  sr, float *  sg, float *  sb  )

static

Definition at line 118 of file hsl.cpp.

                                                   {
    // Hue and Saturation of Src, Luminosity of Dst.
    float R = *sr,
          G = *sg,
          B = *sb;
    set_lum(&R,&G,&B, lum(dr,dg,db));
    *sr = R;
    *sg = G;
    *sb = B;
}

DEF_SIMPLE_GM() [1/2]

DEF_SIMPLE_GM	(	hsl	,
		canvas	,
		600	,
		100
	)

Definition at line 157 of file hsl.cpp.

                                     {
    SkPaint paint;
    SkFont  font = ToolUtils::DefaultPortableFont();
 
    const char* comment = "HSL blend modes are correct when you see no circles in the squares.";
    canvas->drawString(comment, 10,10, font, paint);
 
    // Just to keep things reaaaal simple, we'll only use opaque colors.
    SkPaint bg, fg;
    bg.setColor(0xff00ff00);  // Fully-saturated bright green,  H = 120°, S = 100%, L =  50%.
    fg.setColor(0xff7f3f7f);  // Partly-saturated dim magenta,  H = 300°, S = ~33%, L = ~37%.
 
    struct {
        SkBlendMode mode;
        void (*reference)(float,float,float, float*,float*,float*);
    } tests[] = {
        { SkBlendMode::kSrc,        nullptr    },
        { SkBlendMode::kDst,        nullptr    },
        { SkBlendMode::kHue,        hue        },
        { SkBlendMode::kSaturation, saturation },
        { SkBlendMode::kColor,      color      },
        { SkBlendMode::kLuminosity, luminosity },
    };
    for (auto test : tests) {
        canvas->drawRect({20,20,80,80}, bg);
 
        fg.setBlendMode(test.mode);
        canvas->drawRect({20,20,80,80}, fg);
 
        if (test.reference) {
            SkPaint ref;
            ref.setColor(blend(bg.getColor(), fg.getColor(), test.reference));
            canvas->drawCircle(50,50, 20, ref);
        }
 
        canvas->drawString(SkBlendMode_Name(test.mode), 20, 90, font, paint);
 
        canvas->translate(100,0);
    }
}

DEF_SIMPLE_GM() [2/2]

DEF_SIMPLE_GM	(	HSL_duck	,
		canvas	,
		1110	,
		620
	)

Definition at line 212 of file hsl.cpp.

                                           {
    auto src = ToolUtils::GetResourceAsImage("images/ducky.png");
    auto dst = make_grad(src->width());
    SkRect r = SkRect::MakeIWH(src->width(), src->height());
 
    canvas->translate(10, 50);
    canvas->scale(0.5f, 0.5f);
 
    const struct {
        SkBlendMode fMode;
        const char* fName;
    } recs[] = {
        { SkBlendMode::kHue,        "Hue" },
        { SkBlendMode::kSaturation, "Saturation" },
        { SkBlendMode::kColor,      "Color" },
        { SkBlendMode::kLuminosity, "Luminosity" },
    };
 
    SkFont font = ToolUtils::DefaultPortableFont();
    font.setSize(40);
    font.setEdging(SkFont::Edging::kAntiAlias);
 
    canvas->save();
    for (auto [_, name] : recs) {
        canvas->drawSimpleText(name, strlen(name), SkTextEncoding::kUTF8, 150, -20,
                               font, SkPaint());
        canvas->translate(r.width() + 10, 0);
    }
    canvas->restore();
 
    for (SkScalar src_a : {1.0f, 0.5f}) {
        canvas->save();
        for (auto [mode, _] : recs) {
            SkPaint p;
            p.setShader(dst);
            canvas->drawRect(r, p); // bg
 
            p.setShader(nullptr);
            p.setBlendMode(mode);
            p.setAlphaf(src_a);
            canvas->drawImageRect(src, r, SkSamplingOptions(), &p);
 
            canvas->translate(r.width() + 10, 0);
        }
        SkString str;
        str.printf("alpha %g", src_a);
        canvas->drawSimpleText(str.c_str(), str.size(), SkTextEncoding::kUTF8, 10, r.height()/2,
                               font, SkPaint());
 
        canvas->restore();
        canvas->translate(0, r.height() + 10);
    }
}

hue()

static void hue ( float  dr, float  dg, float  db, float *  sr, float *  sg, float *  sb  )

static

Definition at line 92 of file hsl.cpp.

                                                 {
    // Hue of Src, Saturation and Luminosity of Dst.
    float R = *sr,
          G = *sg,
          B = *sb;
    set_sat(&R,&G,&B, sat(dr,dg,db));
    set_lum(&R,&G,&B, lum(dr,dg,db));
    *sr = R;
    *sg = G;
    *sb = B;
}

lum()

static float lum ( float  r, float  g, float  b  )

static

Definition at line 52 of file hsl.cpp.

{ return r*0.30f + g*0.59f + b*0.11f; }

luminosity()

static void luminosity ( float  dr, float  dg, float  db, float *  sr, float *  sg, float *  sb  )

static

Definition at line 130 of file hsl.cpp.

                                                        {
    // Luminosity of Src, Hue and Saturation of Dst.
    float R = dr,
          G = dg,
          B = db;
    set_lum(&R,&G,&B, lum(*sr,*sg,*sb));
    *sr = R;
    *sg = G;
    *sb = B;
}

make_grad()

static sk_sp< SkShader > make_grad ( SkScalar  width )

static

Definition at line 202 of file hsl.cpp.

                                                 {
    SkColor colors[] = {
        0xFF00CCCC, 0xFF0000CC, 0xFFCC00CC, 0xFFCC0000, 0xFFCCCC00, 0xFF00CC00,
    };
    SkPoint pts[] = {{0, 0}, {width, 0}};
 
    return SkGradientShader::MakeLinear(pts, colors, nullptr, std::size(colors),
                                        SkTileMode::kClamp);
}

max()

static float max ( float  r, float  g, float  b  )

static

Definition at line 49 of file hsl.cpp.

{ return std::max(r, std::max(g, b)); }

min()

static float min ( float  r, float  g, float  b  )

static

Definition at line 48 of file hsl.cpp.

{ return std::min(r, std::min(g, b)); }

sat()

static float sat ( float  r, float  g, float  b  )

static

Definition at line 51 of file hsl.cpp.

{ return max(r,g,b) - min(r,g,b); }

saturation()

static void saturation ( float  dr, float  dg, float  db, float *  sr, float *  sg, float *  sb  )

static

Definition at line 105 of file hsl.cpp.

                                                        {
    // Saturation of Src, Hue and Luminosity of Dst
    float R = dr,
          G = dg,
          B = db;
    set_sat(&R,&G,&B, sat(*sr,*sg,*sb));
    set_lum(&R,&G,&B, lum( dr, dg, db));  // This may seem redundant, but it is not.
    *sr = R;
    *sg = G;
    *sb = B;
}

set_lum()

static void set_lum ( float *  r, float *  g, float *  b, float  l  )

static

Definition at line 83 of file hsl.cpp.

                                                           {
    float diff = l - lum(*r,*g,*b);
    *r += diff;
    *g += diff;
    *b += diff;
    clip_color(r,g,b);
}

set_sat()

static void set_sat ( float *  r, float *  g, float *  b, float  s  )

static

Definition at line 57 of file hsl.cpp.

                                                           {
    float mn = min(*r,*g,*b),
          mx = max(*r,*g,*b);
    auto channel = [=](float c) {
        return mx == mn ? 0
                        : (c - mn) * s / (mx - mn);
    };
    *r = channel(*r);
    *g = channel(*g);
    *b = channel(*b);
}