git.sesse.net Git - casparcg/blob - accelerator/ogl/image/blending_glsl.h

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Robert Nagy, ronag89@gmail.com
  20 */
  21
  22 #pragma once
  23
  24 static std::string get_adjustement_glsl()
  25 {
  26         return R"shader(
  27                         /*
  28                         ** Contrast, saturation, brightness
  29                         ** Code of this function is from TGM's shader pack
  30                         ** http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=21057
  31                         */
  32
  33                         vec3 ContrastSaturationBrightness(vec3 color, float brt, float sat, float con)
  34                         {
  35                                 const float AvgLumR = 0.5;
  36                                 const float AvgLumG = 0.5;
  37                                 const float AvgLumB = 0.5;
  38
  39                                 vec3 LumCoeff = is_hd
  40                                                 ? vec3(0.0722, 0.7152, 0.2126)
  41                                                 : vec3(0.114, 0.587, 0.299);
  42
  43                                 vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
  44                                 vec3 brtColor = color * brt;
  45                                 vec3 intensity = vec3(dot(brtColor, LumCoeff));
  46                                 vec3 satColor = mix(intensity, brtColor, sat);
  47                                 vec3 conColor = mix(AvgLumin, satColor, con);
  48                                 return conColor;
  49                         }
  50
  51                         /*
  52                         ** Gamma correction
  53                         ** Details: http://blog.mouaif.org/2009/01/22/photoshop-gamma-correction-shader/
  54                         */
  55                         #define GammaCorrection(color, gamma)                                                           pow(color, vec3(1.0 / gamma))
  56
  57                         /*
  58                         ** Levels control (input (+gamma), output)
  59                         ** Details: http://blog.mouaif.org/2009/01/28/levels-control-shader/
  60                         */
  61
  62                         #define LevelsControlInputRange(color, minInput, maxInput)                              min(max(color - vec3(minInput), vec3(0.0)) / (vec3(maxInput) - vec3(minInput)), vec3(1.0))
  63                         #define LevelsControlInput(color, minInput, gamma, maxInput)                            GammaCorrection(LevelsControlInputRange(color, minInput, maxInput), gamma)
  64                         #define LevelsControlOutputRange(color, minOutput, maxOutput)                   mix(vec3(minOutput), vec3(maxOutput), color)
  65                         #define LevelsControl(color, minInput, gamma, maxInput, minOutput, maxOutput)   LevelsControlOutputRange(LevelsControlInput(color, minInput, gamma, maxInput), minOutput, maxOutput)
  66         )shader";
  67 }
  68
  69 static std::string get_blend_glsl()
  70 {
  71         static std::string glsl = R"shader(
  72                         /*
  73                         ** Photoshop & misc math
  74                         ** Blending modes, RGB/HSL/Contrast/Desaturate, levels control
  75                         **
  76                         ** Romain Dura | Romz
  77                         ** Blog: http://blog.mouaif.org
  78                         ** Post: http://blog.mouaif.org/?p=94
  79                         */
  80
  81
  82                         /*
  83                         ** Desaturation
  84                         */
  85
  86                         vec4 Desaturate(vec3 color, float Desaturation)
  87                         {
  88                                 vec3 grayXfer = vec3(0.3, 0.59, 0.11);
  89                                 vec3 gray = vec3(dot(grayXfer, color));
  90                                 return vec4(mix(color, gray, Desaturation), 1.0);
  91                         }
  92
  93
  94                         /*
  95                         ** Hue, saturation, luminance
  96                         */
  97
  98                         vec3 RGBToHSL(vec3 color)
  99                         {
 100                                 vec3 hsl;
 101
 102                                 float fmin = min(min(color.r, color.g), color.b);
 103                                 float fmax = max(max(color.r, color.g), color.b);
 104                                 float delta = fmax - fmin;
 105
 106                                 hsl.z = (fmax + fmin) / 2.0;
 107
 108                                 if (delta == 0.0)
 109                                 {
 110                                         hsl.x = 0.0;
 111                                         hsl.y = 0.0;
 112                                 }
 113                                 else
 114                                 {
 115                                         if (hsl.z < 0.5)
 116                                                 hsl.y = delta / (fmax + fmin);
 117                                         else
 118                                                 hsl.y = delta / (2.0 - fmax - fmin);
 119
 120                                         float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;
 121                                         float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;
 122                                         float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;
 123
 124                                         if (color.r == fmax )
 125                                                 hsl.x = deltaB - deltaG;
 126                                         else if (color.g == fmax)
 127                                                 hsl.x = (1.0 / 3.0) + deltaR - deltaB;
 128                                         else if (color.b == fmax)
 129                                                 hsl.x = (2.0 / 3.0) + deltaG - deltaR;
 130
 131                                         if (hsl.x < 0.0)
 132                                                 hsl.x += 1.0;
 133                                         else if (hsl.x > 1.0)
 134                                                 hsl.x -= 1.0;
 135                                 }
 136
 137                                 return hsl;
 138                         }
 139
 140                         float HueToRGB(float f1, float f2, float hue)
 141                         {
 142                                 if (hue < 0.0)
 143                                         hue += 1.0;
 144                                 else if (hue > 1.0)
 145                                         hue -= 1.0;
 146                                 float res;
 147                                 if ((6.0 * hue) < 1.0)
 148                                         res = f1 + (f2 - f1) * 6.0 * hue;
 149                                 else if ((2.0 * hue) < 1.0)
 150                                         res = f2;
 151                                 else if ((3.0 * hue) < 2.0)
 152                                         res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;
 153                                 else
 154                                         res = f1;
 155                                 return res;
 156                         }
 157
 158                         vec3 HSLToRGB(vec3 hsl)
 159                         {
 160                                 vec3 rgb;
 161
 162                                 if (hsl.y == 0.0)
 163                                         rgb = vec3(hsl.z);
 164                                 else
 165                                 {
 166                                         float f2;
 167
 168                                         if (hsl.z < 0.5)
 169                                                 f2 = hsl.z * (1.0 + hsl.y);
 170                                         else
 171                                                 f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);
 172
 173                                         float f1 = 2.0 * hsl.z - f2;
 174
 175                                         rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));
 176                                         rgb.g = HueToRGB(f1, f2, hsl.x);
 177                                         rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));
 178                                 }
 179
 180                                 return rgb;
 181                         }
 182
 183
 184
 185
 186                         /*
 187                         ** Float blending modes
 188                         ** Adapted from here: http://www.nathanm.com/photoshop-blending-math/
 189                         ** But I modified the HardMix (wrong condition), Overlay, SoftLight, ColorDodge, ColorBurn, VividLight, PinLight (inverted layers) ones to have correct results
 190                         */
 191
 192                         #define BlendLinearDodgef                                       BlendAddf
 193                         #define BlendLinearBurnf                                        BlendSubstractf
 194                         #define BlendAddf(base, blend)                          min(base + blend, 1.0)
 195                         #define BlendSubstractf(base, blend)            max(base + blend - 1.0, 0.0)
 196                         #define BlendLightenf(base, blend)              max(blend, base)
 197                         #define BlendDarkenf(base, blend)                       min(blend, base)
 198                         #define BlendLinearLightf(base, blend)  (blend < 0.5 ? BlendLinearBurnf(base, (2.0 * blend)) : BlendLinearDodgef(base, (2.0 * (blend - 0.5))))
 199                         #define BlendScreenf(base, blend)                       (1.0 - ((1.0 - base) * (1.0 - blend)))
 200                         #define BlendOverlayf(base, blend)              (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
 201                         #define BlendSoftLightf(base, blend)            ((blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend)))
 202                         #define BlendColorDodgef(base, blend)           ((blend == 1.0) ? blend : min(base / (1.0 - blend), 1.0))
 203                         #define BlendColorBurnf(base, blend)            ((blend == 0.0) ? blend : max((1.0 - ((1.0 - base) / blend)), 0.0))
 204                         #define BlendVividLightf(base, blend)           ((blend < 0.5) ? BlendColorBurnf(base, (2.0 * blend)) : BlendColorDodgef(base, (2.0 * (blend - 0.5))))
 205                         #define BlendPinLightf(base, blend)             ((blend < 0.5) ? BlendDarkenf(base, (2.0 * blend)) : BlendLightenf(base, (2.0 *(blend - 0.5))))
 206                         #define BlendHardMixf(base, blend)              ((BlendVividLightf(base, blend) < 0.5) ? 0.0 : 1.0)
 207                         #define BlendReflectf(base, blend)              ((blend == 1.0) ? blend : min(base * base / (1.0 - blend), 1.0))
 208
 209
 210                         /*
 211                         ** Vector3 blending modes
 212                         */
 213
 214                         #define Blend(base, blend, funcf)                       vec3(funcf(base.r, blend.r), funcf(base.g, blend.g), funcf(base.b, blend.b))
 215
 216                         #define BlendNormal(base, blend)                        (blend)
 217                         #define BlendLighten                                            BlendLightenf
 218                         #define BlendDarken                                             BlendDarkenf
 219                         #define BlendMultiply(base, blend)              (base * blend)
 220                         #define BlendAverage(base, blend)                       ((base + blend) / 2.0)
 221                         #define BlendAdd(base, blend)                           min(base + blend, vec3(1.0))
 222                         #define BlendSubstract(base, blend)             max(base + blend - vec3(1.0), vec3(0.0))
 223                         #define BlendDifference(base, blend)            abs(base - blend)
 224                         #define BlendNegation(base, blend)              (vec3(1.0) - abs(vec3(1.0) - base - blend))
 225                         #define BlendExclusion(base, blend)             (base + blend - 2.0 * base * blend)
 226                         #define BlendScreen(base, blend)                        Blend(base, blend, BlendScreenf)
 227                         #define BlendOverlay(base, blend)                       Blend(base, blend, BlendOverlayf)
 228                         #define BlendSoftLight(base, blend)             Blend(base, blend, BlendSoftLightf)
 229                         #define BlendHardLight(base, blend)             BlendOverlay(blend, base)
 230                         #define BlendColorDodge(base, blend)            Blend(base, blend, BlendColorDodgef)
 231                         #define BlendColorBurn(base, blend)             Blend(base, blend, BlendColorBurnf)
 232                         #define BlendLinearDodge                                        BlendAdd
 233                         #define BlendLinearBurn                                 BlendSubstract
 234                         #define BlendLinearLight(base, blend)           Blend(base, blend, BlendLinearLightf)
 235                         #define BlendVividLight(base, blend)            Blend(base, blend, BlendVividLightf)
 236                         #define BlendPinLight(base, blend)              Blend(base, blend, BlendPinLightf)
 237                         #define BlendHardMix(base, blend)                       Blend(base, blend, BlendHardMixf)
 238                         #define BlendReflect(base, blend)                       Blend(base, blend, BlendReflectf)
 239                         #define BlendGlow(base, blend)                  BlendReflect(blend, base)
 240                         #define BlendPhoenix(base, blend)                       (min(base, blend) - max(base, blend) + vec3(1.0))
 241                         #define BlendOpacity(base, blend, F, O)         (F(base, blend) * O + blend * (1.0 - O))
 242
 243
 244                         vec3 BlendHue(vec3 base, vec3 blend)
 245                         {
 246                                 vec3 baseHSL = RGBToHSL(base);
 247                                 return HSLToRGB(vec3(RGBToHSL(blend).r, baseHSL.g, baseHSL.b));
 248                         }
 249
 250                         vec3 BlendSaturation(vec3 base, vec3 blend)
 251                         {
 252                                 vec3 baseHSL = RGBToHSL(base);
 253                                 return HSLToRGB(vec3(baseHSL.r, RGBToHSL(blend).g, baseHSL.b));
 254                         }
 255
 256                         vec3 BlendColor(vec3 base, vec3 blend)
 257                         {
 258                                 vec3 blendHSL = RGBToHSL(blend);
 259                                 return HSLToRGB(vec3(blendHSL.r, blendHSL.g, RGBToHSL(base).b));
 260                         }
 261
 262                         vec3 BlendLuminosity(vec3 base, vec3 blend)
 263                         {
 264                                 vec3 baseHSL = RGBToHSL(base);
 265                                 return HSLToRGB(vec3(baseHSL.r, baseHSL.g, RGBToHSL(blend).b));
 266                         }
 267
 268         )shader";
 269
 270         return glsl;
 271 }
 272
 273 static std::string get_chroma_glsl()
 274 {
 275         static std::string glsl = R"shader(
 276                 // Chroma keying
 277                 // Author: Tim Eves <timseves@googlemail.com>
 278                 //
 279                 // This implements the Chroma key algorithm described in the paper:
 280                 //      'Software Chroma Keying in an Imersive Virtual Environment'
 281                 //      by F. van den Bergh & V. Lalioti
 282                 // but as a pixel shader algorithm.
 283                 //
 284                 vec4  grey_xfer  = is_hd
 285                                 ? vec4(0.2126, 0.7152, 0.0722, 0)
 286                                 : vec4(0.299,  0.587,  0.114, 0);
 287
 288                 // This allows us to implement the paper's alphaMap curve in software
 289                 // rather than a largeish array
 290                 float alpha_map(float d)
 291                 {
 292                     return 1.0 - smoothstep(1.0, chroma_softness, d);
 293                 }
 294
 295                 // http://stackoverflow.com/questions/15095909/from-rgb-to-hsv-in-opengl-glsl
 296                 vec3 rgb2hsv(vec3 c)
 297                 {
 298                         vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
 299                         vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
 300                         vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
 301
 302                         float d = q.x - min(q.w, q.y);
 303                         float e = 1.0e-10;
 304                         return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
 305                 }
 306
 307                 // From the same page
 308                 vec3 hsv2rgb(vec3 c)
 309                 {
 310                         vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
 311                         vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
 312                         return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
 313                 }
 314
 315                 float AngleDiff(float angle1, float angle2)
 316                 {
 317                         return 0.5 - abs(abs(angle1 - angle2) - 0.5);
 318                 }
 319
 320                 float AngleDiffDirectional(float angle1, float angle2)
 321                 {
 322                         float diff = angle1 - angle2;
 323
 324                         return diff < -0.5
 325                                         ? diff + 1.0
 326                                         : (diff > 0.5 ? diff - 1.0 : diff);
 327                 }
 328
 329                 float Distance(float actual, float target)
 330                 {
 331                         return min(0.0, target - actual);
 332                 }
 333
 334                 float ColorDistance(vec3 hsv)
 335                 {
 336                         float hueDiff                                   = AngleDiff(hsv.x, chroma_target_hue) * 2;
 337                         float saturationDiff                    = Distance(hsv.y, chroma_min_saturation);
 338                         float brightnessDiff                    = Distance(hsv.z, chroma_min_brightness);
 339
 340                         float saturationBrightnessScore = max(brightnessDiff, saturationDiff);
 341                         float hueScore                                  = hueDiff - chroma_hue_width;
 342
 343                         return -hueScore * saturationBrightnessScore;
 344                 }
 345
 346                 vec3 supress_spill(vec3 c)
 347                 {
 348                         float hue               = c.x;
 349                         float diff              = AngleDiffDirectional(hue, chroma_target_hue);
 350                         float distance  = abs(diff) / chroma_spill_suppress;
 351
 352                         if (distance < 1)
 353                         {
 354                                 c.x = diff < 0
 355                                                 ? chroma_target_hue - chroma_spill_suppress
 356                                                 : chroma_target_hue + chroma_spill_suppress;
 357                                 c.y *= min(1.0, distance + chroma_spill_suppress_saturation);
 358                         }
 359
 360                         return c;
 361                 }
 362
 363                 // Key on any color
 364                 vec4 ChromaOnCustomColor(vec4 c)
 365                 {
 366                         vec3 hsv                = rgb2hsv(c.rgb);
 367                         float distance  = ColorDistance(hsv);
 368                         float d                 = distance * -2.0 + 1.0;
 369                     vec4 suppressed     = vec4(hsv2rgb(supress_spill(hsv)), 1.0);
 370                         float alpha             = alpha_map(d);
 371
 372                         suppressed *= alpha;
 373
 374                         return chroma_show_mask ? vec4(suppressed.a, suppressed.a, suppressed.a, 1) : suppressed;
 375                 }
 376         )shader";
 377
 378         return glsl;
 379 }