@cesdk/node-native 1.77.0-nightly.20260610

package/assets/ly.img.cesdk/shaders/common/ubq_color_conversions.sksl

@@ -0,0 +1,354 @@
+// #include //ly.img.cesdk/shader/common/ubq_constants
+
+/// @file ubq_color_conversions.glsl
+/// @brief Color conversions for different color models.
+///
+
+/// @brief Convert an RGB color to an HSV color.
+///
+/// HSV is a cylindrical color space.
+/// HSV stands for Hue, saturation, value.
+///
+/// Hue goes from red primary at 0°, passing through the green
+/// primary at 120°, the blue primary at 180°, and then wrapping
+/// back to red at 360°.
+/// Saturation goes from unsaturated at 0% to full saturated at 100%.
+/// Value goes from black at 0% to white at 100%.
+/// See: @ref https://en.wikipedia.org/wiki/HSL_and_HSV
+///
+/// Note: HSV is an outdated format from the 1970s and is not recommended to be used.
+///
+/// Source: @ref https://www.laurivan.com/rgb-to-hsv-to-rgb-for-shaders/
+///
+/// @param c RGB color values
+/// @return HSV color values with hue, saturation, and value in range [0,1].
+///
+float3 rgb2hsv(float3 c) {
+  float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  float4 p = c.g < c.b ? float4(c.bg, K.wz) : float4(c.gb, K.xy);
+  float4 q = c.r < p.x ? float4(p.xyw, c.r) : float4(c.r, p.yzx);
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+/// @brief Convert an HSV color to an RGB color.
+///
+/// HSV is a cylindrical color space.
+/// HSV stands for Hue, saturation, value.
+///
+/// Hue goes from red primary at 0°, passing through the green
+/// primary at 120°, the blue primary at 180°, and then wrapping
+/// back to red at 360°.
+/// Saturation goes from unsaturated at 0% to full saturated at 100%.
+/// Value goes from black at 0% to white at 100%.
+/// See: @ref https://en.wikipedia.org/wiki/HSL_and_HSV
+///
+/// Note: HSV is an outdated format from the 1970s and is not recommended to be used.
+///
+/// Source: @ref https://www.laurivan.com/rgb-to-hsv-to-rgb-for-shaders/
+///
+/// @param c HSV color values with hue, saturation, and value in range [0,1].
+/// @return RGB color values
+///
+float3 hsv2rgb(float3 c) {
+  float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  float3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+/// @brief Convert an RGB color to an HSP color.
+///
+/// HSP stands for hue, saturation, and perceived brightness.
+///
+/// Hue goes from red primary at 0°, passing through the green
+/// primary at 120°, the blue primary at 180°, and then wrapping
+/// back to red at 360°.
+///
+/// Based on a public domain function by Darel Rex Finley, 2006
+/// See: @ref http://alienryderflex.com/hsp.html
+///
+/// @param c RGB color values in range [0,1].
+/// @return HSP color values with hue, saturation, and perceived-brightness in range [0,1].
+///
+float3 rgb2hsp(float3 c) {
+  c = clamp(c, 0.0, 1.0);
+  float r = c.r;
+  float g = c.g;
+  float b = c.b;
+  // Hue, saturation, and perceived brightness output
+  float h = 0.0;
+  float s = 0.0;
+  float p = sqrt(dot(GRAYSCALE_WEIGHTS_W3C, c * c));
+
+  // Calculate the hue and saturation. (This part works
+  // the same way as in the HSV/B and HSL systems.)
+  if (r == g && r == b) {
+    // Grey value
+    // Nothing to do as p is already set and h and s are 0.
+    return float3(h, s, p);
+  } else if (r >= g && r >= b) {
+    // r is largest
+    if (b >= g) {
+      h = 6.0 / 6.0 - 1.0 / 6.0 * (b - g) / (r - g);
+      s = 1.0 - g / r;
+    } else {
+      h = 0.0 / 6.0 + 1.0 / 6.0 * (g - b) / (r - b);
+      s = 1.0 - b / r;
+    }
+  } else if (g >= r && g >= b) {
+    // g is largest
+    if (r >= b) {
+      h = 2.0 / 6.0 - 1.0 / 6.0 * (r - b) / (g - b);
+      s = 1.0 - b / g;
+    } else {
+      h = 2.0 / 6.0 + 1.0 / 6.0 * (b - r) / (g - r);
+      s = 1.0 - r / g;
+    }
+  } else {
+    // b is largest
+    if (g >= r) {
+      h = 4.0 / 6.0 - 1.0 / 6.0 * (g - r) / (b - r);
+      s = 1.0 - r / b;
+    } else {
+      h = 4.0 / 6.0 + 1.0 / 6.0 * (r - g) / (b - g);
+      s = 1.0 - g / b;
+    }
+  }
+
+  return clamp(float3(h, s, p), 0.0, 1.0);
+}
+
+/// @brief Convert an HSP color to an RGB color.
+///
+/// HSP stands for hue, saturation and perceived brightness.
+///
+/// Hue goes from red primary at 0°, passing through the green
+/// primary at 120°, the blue primary at 180°, and then wrapping
+/// back to red at 360°.
+///
+/// Based on a public domain function by Darel Rex Finley, 2006
+/// See: @ref http://alienryderflex.com/hsp.html
+///
+/// Note that some combinations of HSP, even if in the scale
+/// 0-1, may return RGB values that exceed a value of 1.  For
+/// example, if you pass in the HSP color (0, 1, 1), the result
+/// would be the RGB color (2.037, 0, 0).
+/// An automatic rescale of the values to 0-1 will be used that
+/// keeps relative ratios.
+///
+/// @param c HSP color values in range [0,1].
+/// @return RGB in range [0,1].
+///
+float3 hsp2rgb(float3 c) {
+  float h = c.x;
+  float s = c.y;
+  float p = c.z;
+
+  // RGB output
+  float r = 0.0;
+  float g = 0.0;
+  float b = 0.0;
+
+  float minOverMax = 1.0 - s;
+  float part;
+
+  const float PR = GRAYSCALE_WEIGHTS_W3C.r;
+  const float PG = GRAYSCALE_WEIGHTS_W3C.g;
+  const float PB = GRAYSCALE_WEIGHTS_W3C.b;
+
+  if (minOverMax > 0.0) {
+    if (h < 1.0 / 6.0) {
+      // r>g>b
+      h = 6.0 * (h - 0.0 / 6.0);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      b = p / sqrt(PR / minOverMax / minOverMax + PG * part * part + PB);
+      r = b / minOverMax;
+      g = b + h * (r - b);
+    } else if (h < 2.0 / 6.0) {
+      // g>r>b
+      h = 6.0 * (-h + 2.0 / 6.0);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      b = p / sqrt(PG / minOverMax / minOverMax + PR * part * part + PB);
+      g = b / minOverMax;
+      r = b + h * (g - b);
+    } else if ((h < 3.0 / 6.0)) {
+      //  g>b>r
+      h = 6.0 * (h - 2.0 / 6.0);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      r = p / sqrt(PG / minOverMax / minOverMax + PB * part * part + PR);
+      g = r / minOverMax;
+      b = r + h * (g - r);
+    } else if ((h < 4.0 / 6.0)) {
+      //  b>g>r
+      h = 6.0 * (-h + 4.0 / 6.00);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      r = p / sqrt(PB / minOverMax / minOverMax + PG * part * part + PR);
+      b = r / minOverMax;
+      g = r + h * (b - r);
+    } else if ((h < 5.0 / 6.0)) {
+      //  b>r>g
+      h = 6.0 * (h - 4.0 / 6.0);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      g = p / sqrt(PB / minOverMax / minOverMax + PR * part * part + PG);
+      b = g / minOverMax;
+      r = g + h * (b - g);
+    } else {
+      //  r>b>g
+      h = 6.0 * (-h + 6.0 / 6.0);
+      part = 1.0 + h * (1.0 / minOverMax - 1.0);
+      g = p / sqrt(PR / minOverMax / minOverMax + PB * part * part + PG);
+      r = g / minOverMax;
+      b = g + h * (r - g);
+    }
+  } else {
+    if (h < 1.0 / 6.0) {
+      // r>g>b
+      h = 6.0 * (h - 0.0 / 6.0);
+      r = sqrt(p * p / (PR + PG * h * h));
+      g = r * h;
+      b = 0.0;
+    } else if (h < 2.0 / 6.0) {
+      //  g>r>b
+      h = 6.0 * (-h + 2.0 / 6.0);
+      g = sqrt(p * p / (PG + PR * h * h));
+      r = g * h;
+      b = 0.0;
+    } else if (h < 3.0 / 6.0) {
+      //  g>b>r
+      h = 6.0 * (h - 2.0 / 6.0);
+      g = sqrt(p * p / (PG + PB * h * h));
+      b = g * h;
+      r = 0.0;
+    } else if (h < 4.0 / 6.0) {
+      //  b>g>r
+      h = 6.0 * (-h + 4.0 / 6.0);
+      b = sqrt(p * p / (PB + PG * h * h));
+      g = b * h;
+      r = 0.0;
+    } else if (h < 5.0 / 6.0) {
+      //  b>r>g
+      h = 6.0 * (h - 4.0 / 6.0);
+      b = sqrt(p * p / (PB + PR * h * h));
+      r = b * h;
+      g = 0.0;
+    } else {
+      //  r>g>b
+      h = 6.0 * (-h + 6.0 / 6.0);
+      r = sqrt(p * p / (PR + PB * h * h));
+      b = r * h;
+      g = 0.0;
+    }
+  }
+
+  float3 outColor = float3(r, g, b);
+
+  // Handle out of range values
+  if (r > 1.0 || g > 1.0 || b > 1.0) {
+    // Rescale all values by maximum to prevent color changes.
+    float maxc = max(r, g);
+    maxc = max(maxc, b);
+    outColor /= maxc;
+  }
+
+  return outColor;
+}
+
+/// @brief Convert an RGB color to an HSL color.
+///
+/// HSL stands for hue, saturation, and lightness.
+/// See: @ref https://en.wikipedia.org/wiki/HSL_and_HSV
+///
+/// Based on colorsys implementation: colorsys.rgb_to_hls(r, g, b)
+///
+/// @param c RGB color values in range [0,1].
+/// @return HSP color values with hue, saturation, and perceived-brightness in range [0,1].
+///
+float3 rgb2hsl(float3 c) {
+  float r = c.r;
+  float g = c.g;
+  float b = c.b;
+
+  float maxc = max(r, g);
+  maxc = max(maxc, b);
+  float minc = min(r, g);
+  minc = min(minc, b);
+
+  float h = 0.0;
+  float s = 0.0;
+  float l = (minc + maxc) / 2.0;
+
+  float rc, gc, bc;
+
+  if (minc == maxc) {
+    // Grey
+    h = 0.0;
+    s = 0.0;
+    return float3(h, s, l);
+  }
+
+  if (l <= 0.5) {
+    s = (maxc - minc) / (maxc + minc);
+  } else {
+    if ((2.0 - maxc - minc) > 0.0) {
+      s = (maxc - minc) / (2.0 - maxc - minc);
+    } else {
+      s = 1.0;
+    }
+  }
+
+  rc = (maxc - r) / (maxc - minc);
+  gc = (maxc - g) / (maxc - minc);
+  bc = (maxc - b) / (maxc - minc);
+  if (r == maxc) {
+    h = bc - gc;
+  } else if (g == maxc) {
+    h = 2.0 + rc - bc;
+  } else {
+    h = 4.0 + gc - rc;
+  }
+  h = mod((h / 6.0), 1.0);
+
+  return float3(h, s, l);
+}
+
+/// @brief HSL helper function
+float _hslV(float m1, float m2, float hue) {
+  hue = mod(hue, 1.0);
+  if (hue < 1.0 / 6.0) {
+    return m1 + (m2 - m1) * hue * 6.0;
+  }
+  if (hue < 0.5) {
+    return m2;
+  }
+  if (hue < 2.0 / 3.0) {
+    return m1 + (m2 - m1) * (2.0 / 3.0 - hue) * 6.0;
+  }
+  return m1;
+}
+
+/// @brief Convert an HSL color to an RGB color.
+///
+/// HSL stands for hue, saturation, and lightness.
+/// See: @ref https://en.wikipedia.org/wiki/HSL_and_HSV
+///
+/// @param c HSL color values in range [0,1].
+/// @return RGB in range [0,1].
+///
+float3 hsl2rgb(float3 c) {
+  float h = c.x;
+  float s = c.y;
+  float l = c.z;
+  float m1, m2;
+
+  if (s == 0.0) {
+    return float3(l, l, l);
+  }
+  if (l <= 0.5) {
+    m2 = l * (1.0 + s);
+  } else {
+    m2 = l + s - (l * s);
+  }
+  m1 = 2.0 * l - m2;
+  return float3(_hslV(m1, m2, h + 1.0 / 3.0), _hslV(m1, m2, h), _hslV(m1, m2, h - 1.0 / 3.0));
+}

package/assets/ly.img.cesdk/shaders/common/ubq_constants.sksl

@@ -0,0 +1,13 @@
+// Pi related constants
+const float PI = 3.14159265358979323846;
+const float TWO_PI = 2.0 * PI;
+const float PI_BY_2 = 0.5 * PI;
+const float PI_BY_4 = 0.25 * PI;
+const float PI_BY_8 = 0.125 * PI;
+
+// Default value for avoiding /0 divisions
+const float EPSILON = 0.0000001;
+
+// Weights used for RGB -> Grayscale conversion
+const float3 GRAYSCALE_WEIGHTS = float3(0.2126, 0.7152, 0.0722);  // W3C_YIQ standard
+const float3 GRAYSCALE_WEIGHTS_W3C = float3(0.299, 0.587, 0.114);  // W3C standard

package/assets/ly.img.cesdk/shaders/common/ubq_hue_constants.sksl

@@ -0,0 +1,86 @@
+
+/// @brief Constants for the HSV, HSL, and HSP color models
+
+// Angles of the colors for HSV, HSL, and HSP color models
+// This defines where the hues are located on the color wheel.
+// Values are mapped from [0, 360] to [0,1]
+// H  0.0:
+const float HUE_RED = 0.0;
+// H ~0.0833:
+const float HUE_ORANGE = 30.0 / 360.0;
+// H ~0.1667:
+const float HUE_YELLOW = 60.0 / 360.0;
+// H ~0.2500:
+const float HUE_GREEN_YELLOW = 90.0 / 360.0;
+// H ~0.3333:
+const float HUE_GREEN = 120.0 / 360.0;
+// H ~0.4167:
+const float HUE_AQUA_GREEN = 150.0 / 360.0;
+// H ~0.5000:
+const float HUE_AQUA = 180.0 / 360.0;
+// H ~0.5833:
+const float HUE_BLUE_AQUA = 210.0 / 360.0;
+// H ~0.6667:
+const float HUE_BLUE = 240.0 / 360.0;
+// H ~0.7500:
+const float HUE_PURPLE = 270.0 / 360.0;
+// H ~0.8333:
+const float HUE_MAGENTA = 300.0 / 360.0;
+// H ~0.9167:
+const float HUE_RED_MAGENTA = 330.0 / 360.0;
+// H  1.0:
+const float HUE_RED_2 = 1.0;
+
+// Array indices for accessing the color operations by name
+const int RED = 0;
+const int ORANGE = 1;
+const int YELLOW = 2;
+const int GREEN = 3;
+const int AQUA = 4;
+const int BLUE = 5;
+const int PURPLE = 6;
+const int MAGENTA = 7;
+// Without the RED_2 special case
+const int NUM_COLOR_RANGES = 8;
+// Special case as red wraps around at 360°
+const int RED_2 = 8;
+// With the RED_2 special case
+const int NUM_COLOR_RANGES_2 = 9;
+
+// Max index value for curve points, used in for-loops
+const int MAX_RANGE_INDEX = 3;
+const int NUM_RANGE_INDICES = 4;
+const int MAX_HUE_INDEX = 3;
+const int NUM_HUE_INDICES = 4;
+
+// Point offsets for x- and y-points for constructing hue adjustment curves
+// This influences the width of the color gradient on the left side of
+// the adjusted colors. Right side is already smooth...
+const float HUE_INC_X0_OFFSET = -29.9 / 360.0;
+// This is for a smoother transition in between. Cuts off part of the ear.
+const float HUE_INC_X2_OFFSET = 5.0 / 360.0;
+// Keep first point on diagonal line
+const float HUE_INC_Y0_OFFSET = -29.9 / 360.0;
+// This is for a smoother transition in between. Cuts off part of the ear.
+// Should be set in relation to Y2.
+const float HUE_INC_Y1_OFFSET = -7.0 / 360.0;
+// This influences how much of target color is shown early. It influences a wide
+// range of the interval.
+const float HUE_INC_Y2_OFFSET = -2.0 / 360.0;
+// This is for a smoother transition in between. Cuts off part of the ear.
+const float HUE_DEC_X1_OFFSET = -5.0 / 360.0;
+// This influences the width of the color gradient on the right side of
+// the adjusted colors. Left side is already smooth...
+const float HUE_DEC_X3_OFFSET = 29.9 / 360.0;
+// This influences how much of target color is shown early. It influences a wide
+// range of the interval.
+const float HUE_DEC_Y1_OFFSET = 6.0 / 360.0;
+// This is for a smoother transition in between. Cuts off part of the ear.
+// Should be set in relation to Y1.
+const float HUE_DEC_Y2_OFFSET = 11.0 / 360.0;
+// Keep last point on diagonal line
+const float HUE_DEC_Y3_OFFSET = 29.9 / 360.0;
+
+// Max curve point value used for normlizing the values
+const float HUE_INCREASE_NORMALIZE_VALUE = HUE_YELLOW + 1.0;
+const float HUE_DECREASE_NORMALIZE_VALUE = HUE_YELLOW + 1.0 + HUE_DEC_X3_OFFSET;

package/assets/ly.img.cesdk/shaders/common/ubq_noise.sksl

@@ -0,0 +1,82 @@
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+float3 mod289(float3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+float2 mod289(float2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+float3 permute(float3 x) {
+  return mod289(((x * 34.0) + 1.0) * x);
+}
+
+float noise2d(float2 v) {
+  const float4 C = float4(0.211324865405187,   // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,   // 0.5*(sqrt(3.0)-1.0)
+                      -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439);  // 1.0 / 41.0
+                                           // First corner
+  float2 i = floor(v + dot(v, C.yy));
+  float2 x0 = v - i + dot(i, C.xx);
+
+  // Other corners
+  float2 i1;
+
+  i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
+
+  float4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+  // Permutations
+  i = mod289(i);  // Avoid truncation effects in permutation
+  float3 p = permute(permute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0));
+
+  float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+  m = m * m;
+  m = m * m;
+
+  // Gradients: 41 points uniformly over a line, mapped onto a diamond.
+  // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  float3 x = 2.0 * fract(p * C.www) - 1.0;
+  float3 h = abs(x) - 0.5;
+  float3 ox = floor(x + 0.5);
+  float3 a0 = x - ox;
+
+  // Normalise gradients implicitly by scaling m
+  // Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+
+  // Compute final noise value at P
+  float3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+float getNoise(float2 uv, float t, float scale, float speed) {
+  // generate multi-octave noise based on uv position and time
+  // move noise  over time
+  // scale noise position relative to center
+  uv -= 0.5;
+  // octave 1
+  float scl = 4.0 * scale;
+  float noise = noise2d(float2(uv.x * scl, uv.y * scl - t * speed));
+  // octave 2
+  scl = 16.0 * scale;
+  noise += noise2d(float2(uv.x * scl + t * speed, uv.y * scl)) * 0.2;
+  // octave 3
+  scl = 26.0 * scale;
+  noise += noise2d(float2(uv.x * scl + t * speed, uv.y * scl)) * 0.2;
+  return noise;
+}

package/assets/ly.img.cesdk/shaders/cross_cut.sksl

@@ -0,0 +1,38 @@
+// #include //ly.img.cesdk/shader/common/ubq_constants
+// #include //ly.img.cesdk/shader/common/ubq_noise
+uniform shader image;
+uniform float2 imageSize;
+uniform float slices;
+uniform float offset;
+uniform float speedV;
+uniform float time;
+
+float steppedVal(float v, float steps) {
+  return floor(v * steps) / steps;
+}
+
+// returns 0 - 1
+float random1d(float n) {
+  const float scale = 0.2;
+  const float speed = 1.0;  
+  return getNoise(float2(n, n), n, scale, speed);
+}
+
+// returns 0 - 1
+float noise1d(float p) {
+  float fl = floor(p);
+  float fc = fract(p);
+  return mix(random1d(fl), random1d(fl + 1.0), fc);
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  // variable width strips
+  float n = noise1d((1 - uv.y) * slices + time * speedV * 3.0);
+  float ns = steppedVal(fract(n), slices) + 2.0;
+
+  float nsr = random1d(ns);
+  uv.x += nsr * sin(time * TWO_PI + nsr * 20.0) * offset;
+  uv *= imageSize;
+  return image.eval(uv);
+}

package/assets/ly.img.cesdk/shaders/dot_pattern.sksl

@@ -0,0 +1,29 @@
+// #include //ly.img.cesdk/shader/common/ubq_constants
+
+// Inputs
+uniform shader image;
+uniform float2 imageSize;
+uniform float dots;
+uniform float size;
+uniform float blur;
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  float dotSize = 1.0 / dots;
+  float2 samplePos = uv - mod(uv, dotSize) + 0.5 * dotSize;
+  float distanceFromSamplePoint = distance(samplePos, uv);
+  float4 imageColor = image.eval(samplePos * imageSize);
+
+  float4 backgroundColor = float4(0.0);
+  
+  // Adjust blur value to avoid sharp transitions between image color and background color.
+  // Reasoning: when both lower and upper edge values are the same, smoothstep no longer provides
+  // a gradual transition between them (either immediatelly returs 0 or 1).
+  // This causes mix() to output imageColor or backgroundColor instead of doing a linear interpolation between them.
+  float adjustedBlur = max(blur, EPSILON);
+
+  float4 color =
+    mix(imageColor, backgroundColor,
+        smoothstep(dotSize * size, dotSize * (size + adjustedBlur), distanceFromSamplePoint));
+  return color;
+}

package/assets/ly.img.cesdk/shaders/duotone_filter.sksl

@@ -0,0 +1,26 @@
+// #include //ly.img.cesdk/shader/common/ubq_constants
+uniform shader image;
+uniform float4 lightColor;
+uniform float4 darkColor;
+uniform float intensity;
+
+half4 main(float2 coord) {
+  float4 sampledCol = image.eval(coord);
+  float4 color = clamp(sampledCol, 0.0, 1.0);  // necessary to get rid of all extended sRGB issues with OpenGL ES
+
+  // Apply intensity as "symmetric gamma"
+  if (intensity > 0.0) {
+    color.rgb = 1.0 - pow(1.0 - color.rgb, float3(max(intensity + 1.0, EPSILON)));
+  } else {
+    color.rgb = pow(color.rgb, float3(max(-intensity + 1.0, EPSILON)));
+  }
+
+  // Colorimetric (perceptual luminance-preserving) RGB to grayscale conversion
+  // https://en.wikipedia.org/wiki/Grayscale#Colorimetric_(perceptual_luminance-preserving)_conversion_to_grayscale
+  float luminance = dot(GRAYSCALE_WEIGHTS, color.rgb);
+
+  // Apply DuoTone
+  float4 duotone = mix(darkColor, lightColor, clamp(luminance, 0.0, 1.0));
+  duotone *= color.a;
+  return duotone;
+}