How Does the pSBC Function Work for Shading, Blending, and Color Conversion?

This function, pSBC, takes a HEX or RGB web color and performs operations on it, such as shading, blending, or conversion between formats. Here's how it works:

Shading: pSBC can lighten or darken a color by a specified percentage. It accomplishes this without converting to HSL, unlike larger and slower HSL-based functions. The results of pSBC may therefore differ from those of HSL functions.

Blending: pSBC can blend two colors together using linear or logarithmic blending. By specifying the blending percentage, it can create a smooth transition between the two colors. Alpha channels are supported, allowing for transparent blending.

Conversion: pSBC automatically converts HEX to RGB or RGB to HEX when blending colors or performing shading. It also handles 3-digit HEX codes (e.g., "#C41") and expands them to standard 6-digit HEX codes.

Features:

• Automatic detection and acceptance of standard HEX and RGB color formats.
• Shading colors to white or black by percentage.
• Blending colors together by percentage.
• Conversion between HEX and RGB, either solo or during blending.
• Expansion of 3-digit HEX codes to standard 6-digit codes.
• Handling of alpha channels for linear blending of transparent colors.

Usage:

To use pSBC, you can pass it three parameters:

• p: The percentage of shading or blending (from -1 to 1).
• c0: The first color as a HEX or RGB string.
• c1: The second color for blending or shading. If omitted, c is used for shading and "c" for conversion.

For example, pSBC(0.5, "rgb(20,60,200)", "rgba(200,60,20,0.67423)") would blend the two colors by 50%.

Code:

The code for pSBC is provided below:

<code class="js">const pSBC = (p, c0, c1, l = false) => {
  let r, g, b, P, f, t, h, i = parseInt;
  if (typeof p != "number" || p < -1 || p > 1 || typeof c0 != "string" || (c0[0] != "r" && c0[0] != "#") || (c1 && !a)) return null;
  if (!this.pSBCr) this.pSBCr = (d) => {
    let n = d.length, x = {};
    if (n > 9) {
      [r, g, b, a] = d = d.split(",");
      n = d.length;
      if (n < 3 || n > 4) return null;
      x.r = i(r[3] == "a" ? r.slice(5) : r.slice(4)), x.g = i(g), x.b = i(b), x.a = a ? parseFloat(a) : -1
    } else {
      if (n == 8 || n == 6 || n < 4) return null;
      if (n < 6) d = "#" + d[1] + d[1] + d[2] + d[2] + d[3] + d[3] + (n > 4 ? d[4] + d[4] : "");
      d = i(d.slice(1), 16);
      if (n == 9 || n == 5) x.r = d >> 24 & 255, x.g = d >> 16 & 255, x.b = d >> 8 & 255, x.a = m((d & 255) / 0.255) / 1000;
      else x.r = d >> 16, x.g = d >> 8 & 255, x.b = d & 255, x.a = -1
    }
    return x
  };
  h = c0.length > 9, h = a ? c1.length > 9 ? true : c1 == "c" ? !h : false : h, f = this.pSBCr(c0), P = p < 0, t = c1 && c1 != "c" ? this.pSBCr(c1) : P ? { r: 0, g: 0, b: 0, a: -1 } : { r: 255, g: 255, b: 255, a: -1 }, p = P ? p * -1 : p, P = 1 - p;
  if (!f || !t) return null;
  if (l) r = m(P * f.r + p * t.r), g = m(P * f.g + p * t.g), b = m(P * f.b + p * t.b);
  else r = m((P * f.r ** 2 + p * t.r ** 2) ** 0.5), g = m((P * f.g ** 2 + p * t.g ** 2) ** 0.5), b = m((P * f.b ** 2 + p * t.b ** 2) ** 0.5);
  a = f.a, t = t.a, f = a >= 0 || t >= 0, a = f ? a < 0 ? t : t < 0 ? a : a * P + t * p : 0;
  if (h) return "rgb" + (f ? "a(" : "(") + r + "," + g + "," + b + (f ? "," + m(a * 1000) / 1000 : "") + ")";
  else return "#" + (4294967296 + r * 16777216 + g * 65536 + b * 256 + (f ? m(a * 255) : 0)).toString(16).slice(1, f ? undefined : -2)
};

Micro Functions:

If speed and size are your top priorities, you can use the two-liner RGB functions below. These functions sacrifice some features, such as error checking, HEX conversion, and alpha channel support. They are incredibly fast and small:

<code class="js">const RGB_Linear_Blend = (p, c0, c1) => {
  var i = parseInt, r = Math.round, P = 1 - p, [a, b, c, d] = c0.split(","), [e, f, g, h] = c1.split(","), x = d || h, j = x ? "," + (!d ? h : !h ? d : r((parseFloat(d) * P + parseFloat(h) * p) * 1000) / 1000 + ")") : ")";
  return "rgb" + (x ? "a(" : "(") + r(i(a[3] == "a" ? a.slice(5) : a.slice(4)) * P + i(e[3] == "a" ? e.slice(5) : e.slice(4)) * p) + "," + r(i(b) * P + i(f) * p) + "," + r(i(c) * P + i(g) * p) + j;
};

const RGB_Linear_Shade = (p, c) => {
  var i = parseInt, r = Math.round, [a, b, c, d] = c.split(","), P = p < 0, t = P ? 0 : 255 * p, P = P ? 1 + p : 1 - p;
  return "rgb" + (d ? "a(" : "(") + r(i(a[3] == "a" ? a.slice(5) : a.slice(4)) * P + t) + "," + r(i(b) * P + t) + "," + r(i(c) * P + t) + (d ? "," + d : ")");
};

const RGB_Log_Blend = (p, c0, c1) => {
  var i = parseInt, r = Math.round, P = 1 - p, [a, b, c, d] = c0.split(","), [e, f, g, h] = c1.split(","), x = d || h, j = x ? "," + (!d ? h : !h ? d : r((parseFloat(d) * P + parseFloat(h) * p) * 1000) / 1000 + ")") : ")";</code>

The above is the detailed content of How Does the pSBC Function Work for Shading, Blending, and Color Conversion?. For more information, please follow other related articles on the PHP Chinese website!