fastuidraw_blend_util.frag.glsl.hpp

Go to the documentation of this file.

/*!
 * \file fastuidraw_blend_util.frag.glsl.hpp
 * \brief file fastuidraw_blend_util.frag.glsl.hpp
 *
 * Copyright 2018 by Intel.
 *
 * Contact: kevin.rogovin@gmail.com
 *
 * This Source Code Form is subject to the
 * terms of the Mozilla Public License, v. 2.0.
 * If a copy of the MPL was not distributed with
 * this file, You can obtain one at
 * http://mozilla.org/MPL/2.0/.
 *
 * \author Kevin Rogovin <kevin.rogovin@gmail.com>
 *
 */

/*!\addtogroup GLSLFragCode
 * @{
 */

/*! \brief Compute the minimum color channel value */
float
fastuidraw_compute_min(in vec3 C)
{
  return min(C.r, min(C.g, C.b));
}

/*! \brief Compute the maximum color channel value */
float
fastuidraw_compute_max(in vec3 C)
{
  return max(C.r, max(C.g, C.b));
}

/*! \brief compute the luminosity of an RGB value */
float
fastuidraw_compute_luminosity(in vec3 C)
{
  return dot(C, vec3(0.3, 0.59, 0.11));
}

/*! \brief compute the saturation of an RGB value */
float
fastuidraw_compute_saturation(in vec3 C)
{
  return fastuidraw_compute_max(C) - fastuidraw_compute_min(C);
}

/*!
 * \brief
 * clip an RGB value so that its luminosity is within the range
 * \ref fastuidraw_compute_min() and fastuidraw_compute_max().
 */
vec3
fastuidraw_clipcolor(in vec3 C)
{
  float lumC = fastuidraw_compute_luminosity(C);
  float minC = fastuidraw_compute_min(C);
  float maxC = fastuidraw_compute_max(C);
  vec3 lumCv = vec3(lumC);

  if (minC < 0.0)
    {
      float factor;
      factor = lumC / (lumC - minC);
      C = lumCv + (C - lumCv) * factor;
    }
  else if (maxC > 1.0)
    {
      float factor;
      factor = (1.0 - lumC) / (maxC - lumC);
      C = lumCv + (C - lumCv) * factor;
    }
  return C;
}

/*!
 * Return an RGB color value generate from taking
 * the chroma of one color value and the luminosity
 * of another
 * \param C color value from which to take the chroma value
 * \param L color value from which to take the luminosity value
 */
vec3
fastuidraw_set_luminosity(in vec3 C, in vec3 L)
{
  float Clum = fastuidraw_compute_luminosity(C);
  float Llum = fastuidraw_compute_luminosity(L);
  float delta = Llum - Clum;
  return fastuidraw_clipcolor(C + vec3(delta));
}

/*!
 * Return an RGB color value generate from taking
 * the chroma of one color value and the luminosity
 * and saturation of other color values
 * \param C color value from which to take the chroma value
 * \param S color value from which to take the saturation value
 * \param L color value from which to take the luminosity value
 */
vec3
fastuidraw_set_saturation_and_luminosity(in vec3 C, in vec3 S, in vec3 L)
{
  float Cmin = fastuidraw_compute_min(C);
  float Csat = fastuidraw_compute_saturation(C);
  float Ssat = fastuidraw_compute_saturation(S);
  vec3 color;

  if (Csat > 0.0)
    {
      C = (C - Cmin) * Ssat / Csat;
    }
  else
    {
      C = vec3(0.0);
    }
  return fastuidraw_set_luminosity(C, L);
}

/*! \brief Undo pre-multiply by alpha on the RGB channels of a color value */
vec3
fastuidraw_undo_alpha(in vec4 S)
{
  if (S.a != 0.0)
    {
      S.a = 1.0 / S.a;
    }
  return S.rgb * S.a;
}

/*!
 * \brief
 * perform overlay blending on a single color channel
 * \param S Source input value
 * \param D Destination input value
 */
float
fastuidraw_overlay(in float S, in float D)
{
  return (D <= 0.5) ?
    (2.0 * S * D) :
    (1.0 - 2.0 * (1.0 - S) * (1.0 - D));
}

/*!
 * \brief
 * perform softlight blending on a single color channel
 * \param S Source input value
 * \param D Destination input value
 */
float
fastuidraw_softlight(in float S, in float D)
{
  if (S <= 0.5)
    {
      return D - (1.0 - 2.0 * S) * D * (1.0 - D);
    }
  else if (D <= 0.25)
    {
      return D + (2.0 * S - 1.0) * D * ((16.0 * D - 12.0) * D + 3.0);
    }
  else
    {
      return D + (2.0 * S - 1.0) * (sqrt(D) - D);
    }
}

/*!
 * \brief
 * perform hardlight blending on a single color channel
 * \param S Source input value
 * \param D Destination input value
 */
float
fastuidraw_hardlight(in float S, in float D)
{
  if (S <= 0.5)
    {
      return 2.0 * S * D;
    }
  else
    {
      return 1.0 - 2.0 * (1.0 - S) * (1.0 - D);
    }
}

/*!
 * \brief
 * perform color dodge blending on a single color channel
 * \param S Source input value
 * \param D Destination input value
 */
float
fastuidraw_color_dodge(in float S, in float D)
{
  if (D <= 0.0)
    {
      return 0.0;
    }
  else if (S >= 1.0)
    {
      return 1.0;
    }
  else
    {
      return min(1.0, D / (1.0 - S));
    }
}

/*!
 * \brief
 * perform color burn blending on a single color channel
 * \param S Source input value
 * \param D Destination input value
 */
float
fastuidraw_color_burn(in float S, in float D)
{
  if (D >= 1.0)
    {
      return 1.0;
    }
  else if (S <= 0.0)
    {
      return 0.0;
    }
  else
    {
      return 1.0 - min(1.0, (1.0 - D) / S);
    }
}

///@cond

/* Naughty macro that assumes in_src, in_fb are defined. */
#define FASTUIDRAW_PORTER_DUFF_MACRO(src_factor, dst_factor) \
  ((src_factor) * in_src + (dst_factor) * in_fb)

/* Macro that runs the expression on one channel of out_src */
#define FASTUIDRAW_SEPERABLE_FBF_BLEND_ONE_CHANNEL_MACRO(channel, expression) \
  S = Srgb.channel; D = Drgb.channel;                                   \
  out_src.channel = (expression)

/* Naughty macro that assumes in_src, in_fb are defined AND
 * expression is a scalar expression in S and D (temporaries)
 * with S representing  source  (i.e in_src with alpha undone)
 * and D representing  destination  (i.e. in_fb with alpha undone).
 */
#define FASTUIDRAW_SEPERABLE_FBF_BLEND_MACRO(expression)                \
  vec3 Srgb, Drgb;                                                      \
  float S, D;                                                           \
  Srgb = fastuidraw_undo_alpha(in_src);                                 \
  Drgb = fastuidraw_undo_alpha(in_fb);                                  \
  out_src.a = in_src.a + in_fb.a * (1.0 - in_src.a);                    \
  FASTUIDRAW_SEPERABLE_FBF_BLEND_ONE_CHANNEL_MACRO(r, expression);      \
  FASTUIDRAW_SEPERABLE_FBF_BLEND_ONE_CHANNEL_MACRO(g, expression);      \
  FASTUIDRAW_SEPERABLE_FBF_BLEND_ONE_CHANNEL_MACRO(b, expression);      \
  out_src.rgb *= in_src.a * in_fb.a;
  out_src.rgb += Srgb * (1.0 - in_fb.a) + Drgb * (1.0 - in_src.a)

/* Naughty macro that assumes in_src, in_fb are defined AND
 * expression is a vec3 expression in S and D (temporaries)
 * with S representing  source  (i.e in_src with alpha undone)
 * and D representing  destination  (i.e. in_fb with alpha undone).
 */
#define FASTUIDRAW_NON_SEPERABLE_FBF_BLEND_MACRO(expression)            \
  vec3 S, D;                                                            \
  S = fastuidraw_undo_alpha(in_src);                                    \
  D = fastuidraw_undo_alpha(in_fb);                                     \
  out_src.a = in_src.a + in_fb.a * (1.0 - in_src.a);                    \
  out_src.rgb = expression;                                             \
  out_src.rgb *= in_src.a * in_fb.a;                                    \
  out_src.rgb += S * (1.0 - in_fb.a) + D * (1.0 - in_src.a);

///@endcond

/*! @} */