@cesdk/node-native 1.77.0-nightly.20260610

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

@@ -0,0 +1,85 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float amount;
+uniform float time;
+
+const int num_iter = 16;
+const float reci_num_iter_f = 1.0 / float(num_iter);
+const float gamma = 2.2;
+const float MAX_DIST_PX = 200.0;
+
+float2 barrelDistortion(float2 p, float2 amt) {
+  p = 2.0 * p - 1.0;
+  // float BarrelPower = 1.125;
+  const float maxBarrelPower = 3.0;
+  float theta = atan(p.y, p.x);
+  float radius = length(p);
+  radius = pow(radius, 1.0 + maxBarrelPower * amt.x);
+  p.x = radius * cos(theta);
+  p.y = radius * sin(theta);
+  return 0.5 * (p + 1.0);
+}
+
+float sat(float t) {
+  return clamp(t, 0.0, 1.0);
+}
+
+float linterp(float t) {
+  return sat(1.0 - abs(2.0 * t - 1.0));
+}
+
+float remap(float t, float a, float b) {
+  return sat((t - a) / (b - a));
+}
+
+float3 spectrum_offset(float t) {
+  float3 ret;
+  float lo = step(t, 0.5);
+  float hi = 1.0 - lo;
+  float w = linterp(remap(t, 1.0 / 6.0, 5.0 / 6.0));
+  ret = float3(lo, 1.0, hi) * float3(1.0 - w, w, 1.0 - w);
+
+  return pow(ret, float3(1.0 / 2.2));
+}
+
+float nrand(float2 n) {
+  return fract(sin(dot(n.xy, float2(12.9898, 78.233))) * 43758.5453);
+}
+
+float4 lin2srgb(float4 c) {
+  return pow(c, float4(gamma));
+}
+
+float4 srgb2lin(float4 c) {
+  return pow(c, float4(1.0 / gamma));
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  uv.y = 1.0 - uv.y;
+  // resolution independent
+  float2 max_distort = float2(amount);
+
+  float2 oversiz = barrelDistortion(float2(1, 1), max_distort);
+  uv = 2.0 * uv - 1.0;
+  uv = uv / (oversiz * oversiz);
+  uv = 0.5 * uv + 0.5;
+
+  float4 sumcol = float4(0.0);
+  float4 sumw = float4(0.0);
+  float rnd = nrand(uv + fract(time));
+  for (int i = 0; i < num_iter; ++i) {
+    float t = (float(i) + rnd) * reci_num_iter_f;
+    float4 w = float4(spectrum_offset(t), 1.0);
+    sumw += w;
+    float2 sampleUV = barrelDistortion(uv, max_distort * t);
+    float2 sampleCoord = imageSize * float2(sampleUV.x, 1.0 - sampleUV.y); 
+    sumcol += w * srgb2lin(unpremul(image.eval(sampleCoord)));
+  }
+
+  sumcol /= sumw;
+  float4 outcol = lin2srgb(sumcol);
+  outcol += rnd / 255.0;
+  outcol.rgb *= outcol.a;
+  return outcol;
+}

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

@@ -0,0 +1,31 @@
+uniform shader image;
+uniform float size;
+uniform float amount;
+uniform float darkness;
+half4 main(float2 coord) {
+
+  float4 sum = float4(0.0);
+
+  float weights[4];
+  weights[0] = 0.1531;
+  weights[1] = 0.12245;
+  weights[2] = 0.0918;
+  weights[3] = 0.051;
+
+  float4 baseColor = unpremul(image.eval(coord));
+  for (int i = 1; i <= 4; i++) {
+    float weight = weights[i - 1];
+    float offset = size * float(i);
+    sum += weight * (unpremul(image.eval(coord + float2(offset,  0))) - darkness);
+    sum += weight * (unpremul(image.eval(coord + float2(-offset, 0))) - darkness);
+    sum += weight * (unpremul(image.eval(coord + float2(0,  offset))) - darkness);
+    sum += weight * (unpremul(image.eval(coord + float2(0, -offset))) - darkness);
+  }
+  sum += 2.0 * 0.1633 * (baseColor - darkness);
+
+  // Additive Blend
+  float4 result = baseColor + max(sum, 0.0) * amount;
+  result = clamp(result, float4(0.0), float4(1.0));
+  result.rgb *= result.a;
+  return result;
+}

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

@@ -0,0 +1,14 @@
+uniform shader image;
+uniform float angle;
+uniform float scale;
+
+half4 main(float2 coord) {
+  float4 color = unpremul(image.eval(coord));
+  float average = (color.r + color.g + color.b) / 3.0;
+  float s = sin(angle), c = cos(angle);
+  float2 point = float2(c * coord.x - s * coord.y, s * coord.x + c * coord.y) * scale;
+  float pattern = (sin(point.x) * sin(point.y)) * 4.0;
+  float4 result = float4(float3(average * 10.0 - 5.0 + pattern), color.a);
+  result.rbg *= result.a;
+  return result;
+}

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

@@ -0,0 +1,30 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float scale;
+
+float luma(float3 color) {
+  return dot(color, float3(0.299, 0.587, 0.114));
+}
+
+half4 main(float2 coord) {
+  
+  float2 uv = coord / imageSize;
+  uv.y = 1.0 - uv.y;
+
+  float2 center = float2(0.5);
+  float noiseScale = 1.;
+  float radius = 0.5;
+  float2 d = uv - center;
+  float r = length(d * float2(1., imageSize.y / imageSize.x)) * scale;
+  float a = atan(d.y, d.x) + noiseScale * (radius - r) / radius;
+  float2 uvt = center + r * float2(cos(a), sin(a));
+
+  float c = (.75 + .25 * sin(uvt.x * 1000.));
+  float4 color = unpremul(image.eval(coord));
+  float l = luma(color.rgb);
+  float f = smoothstep(.5 * c, c, l);
+  f = smoothstep(0., .5, f);
+  float3 col = float3(f);
+
+  return float4(col * color.a, color.a);
+}

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

@@ -0,0 +1,19 @@
+// #include //ly.img.cesdk/shader/common/ubq_noise
+uniform shader image;
+uniform float2 imageSize;
+uniform float amount;
+uniform float scale;
+uniform float speed;
+uniform float time;
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  uv.y = 1 - uv.y;
+  float noise = getNoise(uv, time * 24.0, scale, speed);
+  float2 noiseUv = uv + amount * noise;
+  // wrap
+  noiseUv = fract(noiseUv);
+  noiseUv.y = 1 - noiseUv.y;
+  noiseUv *= imageSize;
+  return image.eval(noiseUv);
+}

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

@@ -0,0 +1,70 @@
+uniform shader image;
+uniform shader lookupTable;
+uniform float2 lookupTableSize;
+uniform int2 tileCount;
+uniform float intensity;
+
+// Try to get the exact pixel of the lut map image
+float3 lutColor(int texPosX, int texPosY) {
+  float2 pos = (0.5 + float2(float(texPosX), float(texPosY)));
+  return lookupTable.eval(pos).rgb;
+}
+
+float3 bilinearInterpolate(float3 cRfGf, float3 cRfGc, float3 cRcGf, float3 cRcGc, float redFract, float greenFract) {
+  return mix(mix(cRfGf, cRcGf, redFract), mix(cRfGc, cRcGc, redFract), greenFract);
+}
+
+half4 main(float2 coord) {
+  float2 lutResolution = lookupTableSize;
+  float u_horizontalTileCount = float(tileCount.x);
+  float u_verticalTileCount = float(tileCount.y);
+
+  float4 inputColor = clamp(unpremul(image.eval(coord)), 0.0, 1.0);
+  float3 sourceColor = inputColor.rgb;
+
+  float3 ranges = float3(floor(lutResolution.x / u_horizontalTileCount - 1.0),
+                     floor(lutResolution.y / u_verticalTileCount - 1.0),
+                     floor(u_horizontalTileCount * u_horizontalTileCount - 1.0));
+
+  float3 tmp = sourceColor * ranges;
+  int3 floors = int3(tmp);
+  int3 ceils = int3(ceil(tmp));
+  float3 fracts = fract(tmp);
+
+  // Map tile index to tile pixel pos.
+  int2 pixelsPerTile = int2(lutResolution.x / u_horizontalTileCount, lutResolution.y / u_verticalTileCount);
+
+  int2 tileFloor;  // Blue tile index
+  tileFloor.y = floors.z / tileCount.x;
+  tileFloor.x = (floors.z - (tileFloor.y * tileCount.x));
+
+  int2 tileCeil;  // Blue tile index
+  tileCeil.y = ceils.z / tileCount.x;
+  tileCeil.x = (ceils.z - (tileCeil.y * tileCount.x));
+
+  tileFloor *= pixelsPerTile;
+  tileCeil *= pixelsPerTile;
+
+  // Interpolate between red and green
+  float3 lutColorFB =
+    bilinearInterpolate(lutColor(tileFloor.x + floors.x, tileFloor.y + floors.y),
+                        lutColor(tileFloor.x + floors.x, tileFloor.y + ceils.y),
+                        lutColor(tileFloor.x + ceils.x, tileFloor.y + floors.y),
+                        lutColor(tileFloor.x + ceils.x, tileFloor.y + ceils.y), fracts.x, fracts.y);
+  float3 lutColorCB =
+    bilinearInterpolate(lutColor(tileCeil.x + floors.x, tileCeil.y + floors.y),
+                        lutColor(tileCeil.x + floors.x, tileCeil.y + ceils.y),
+                        lutColor(tileCeil.x + ceils.x, tileCeil.y + floors.y),
+                        lutColor(tileCeil.x + ceils.x, tileCeil.y + ceils.y), fracts.x, fracts.y);
+
+  // Interpolate between the blue values
+  float3 interpolation = mix(lutColorFB, lutColorCB, fracts.z);
+
+  // Round Color Values to prevent that for ex. 254.999999 is cutting to 254 instead of 255;
+  interpolation = clamp(floor(interpolation * 255. + .5) / 255., 0.0, 1.0);
+
+  float4 filteredColor = float4(interpolation.rgb, inputColor.a);
+  float4 color = mix(inputColor, filteredColor, intensity);
+  color.rgb *= color.a;
+  return color;
+}

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

@@ -0,0 +1,16 @@
+// #include //ly.img.cesdk/shader/common/ubq_constants
+uniform shader image;
+uniform float4 maskColor;
+uniform float4 maskMultiplier;
+uniform float4 notMaskMultiplier;
+uniform float2 replaceInsteadMultiply;
+
+half4 main(float2 coord) {
+  half4 color = image.eval(coord);
+  if (color == maskColor) {
+    color = mix(color * maskMultiplier, maskMultiplier, replaceInsteadMultiply.x);
+  } else {
+    color = mix(color * notMaskMultiplier, notMaskMultiplier, replaceInsteadMultiply.y);
+  }  
+  return color;
+}

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

@@ -0,0 +1,21 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float side;
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  if (side == 0) {
+    if (uv.x > 0.5)
+      uv.x = 1.0 - uv.x;
+  } else if (side == 1) {
+    if (uv.x < 0.5)
+      uv.x = 1.0 - uv.x;
+  } else if (side == 2) {
+    if (uv.y > 0.5)
+      uv.y = 1.0 - uv.y;
+  } else if (side == 3) {
+    if (uv.y < 0.5)
+      uv.y = 1.0 - uv.y;
+  }
+  uv *= imageSize;
+  return image.eval(uv);
+}

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

@@ -0,0 +1,40 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float amount;
+uniform float passthrough;
+half4 main(float2 coord) {
+
+  float3x3 G[2];
+  G[0] = mat3(1.0, 2.0, 1.0, 0.0, 0.0, 0.0, -1.0, -2.0, -1.0);
+  G[1] = mat3(1.0, 0.0, -1.0, 2.0, 0.0, -2.0, 1.0, 0.0, -1.0);
+
+  // There used to be a bug in this shader which caused us to always use 1/512 as the 
+  // relative texel size. Using correct pixel offsets instead results in far better
+  // outputs for lower resolution images but also makes the outline a lot less pronounced
+  // in higher resolution images. In order to mitigate this, we now always offset at
+  // least 1/512 of the image size so that the output is the same as before for higher resolution
+  // images.
+  float2 texelScale = max(float2(1.0), imageSize / float2(512.0));
+
+  /* fetch the 3x3 neighbourhood and use the RGB vectors length as intensity value */
+  float3x3 I;
+  for (float i = 0.0; i < 3.0; i++) {
+    for (float j = 0.0; j < 3.0; j++) {
+      float3 probe = unpremul(image.eval(coord + texelScale * float2(i - 1, j - 1))).rgb;
+      I[int(i)][int(j)] = length(probe);
+    }
+  }
+
+  /* calculate the convolution values for all the masks */
+  float cnv[2];
+  for (int i = 0; i < 2; i++) {
+    float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);
+    cnv[i] = dp3 * dp3;
+  }                                                                                                                        
+
+  float4 orig = unpremul(image.eval(coord));
+
+  float4 color = orig * passthrough + float4(0.5 * sqrt(cnv[0] * cnv[0] + cnv[1] * cnv[1])) * amount;
+  color.rgb *= color.a;
+  return color;
+}

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

@@ -0,0 +1,10 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float2 pixelCount;
+half4 main(float2 coord) {
+  float2 tc = coord / imageSize;
+  tc.x = (floor(tc.x * pixelCount.x) + 0.5) / pixelCount.x;
+  tc.y = (floor(tc.y * pixelCount.y) + 0.5) / pixelCount.y;
+  tc *= imageSize;
+  return image.eval(tc);
+}

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

@@ -0,0 +1,18 @@
+uniform float4 backgroundColor;
+uniform float imageWidth;
+uniform float scaleX;
+uniform float scaleY;
+uniform float smoothness;
+
+half4 main(float2 coord) {
+  float2 point = coord * float2(scaleX, scaleY);
+  float pattern = mod(point.x + point.y, 64.0);
+  float edge0 = smoothstep(32.0 - 11.31 - smoothness, 32.0 - 11.31 + smoothness, pattern);
+  float edge1 = smoothstep(32.0 + 11.31 + smoothness, 32.0 + 11.31 - smoothness, pattern);
+  float4 lines = 0.25 * float4(float3(edge0 * edge1), 1.0);
+
+  float4 darkening = float4(0, 0, 0, 0.25);
+  float4 linesColor = lines + (1 - lines.a) * darkening;
+  float4 outColor = linesColor + (1 - linesColor.a) * backgroundColor;
+  return outColor;
+}

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

@@ -0,0 +1,8 @@
+uniform shader image;
+uniform float levels;
+half4 main(float2 coord) {
+  float4 col = unpremul(image.eval(coord));
+  col.rgb = floor((col.rgb * levels) + float3(0.5)) / levels;
+  col.rgb *= col.a;
+  return col;
+}

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

@@ -0,0 +1,22 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float radius;
+uniform float segments;
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  float2 normCoord = 2.0 * uv - 1.0;
+
+  // to polar coords
+  float r = length(normCoord);
+  float phi = atan(normCoord.y, normCoord.x);
+
+  r = r - mod(r, radius) + 0.03;
+  phi = phi - mod(phi, segments);
+
+  normCoord.x = r * cos(phi);
+  normCoord.y = r * sin(phi);
+
+  float2 textureCoordinateToUse = normCoord / 2.0 + 0.5;
+  textureCoordinateToUse *= imageSize; 
+  return image.eval(textureCoordinateToUse);
+}

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

@@ -0,0 +1,57 @@
+// #include //ly.img.cesdk/shader/common/ubq_color_conversions
+// #include //ly.img.cesdk/shader/common/ubq_constants
+uniform shader image;
+uniform float3 fromRgb;
+uniform float4 toRgba;
+uniform float colorMatch;
+uniform float brightnessMatch;
+uniform float smoothness;
+uniform float spill;
+
+// zWeight influences the weight of the vertical distance (perceived brightness, in this shader).
+float cylindricalDistance(float3 p1, float3 p2, float zWeight) {
+  p1.x *= TWO_PI;
+  p2.x *= TWO_PI;
+
+  float a = sin(p1.x) * p1.y - sin(p2.x) * p2.y;
+  float b = cos(p1.x) * p1.y - cos(p2.x) * p2.y;
+  float c = p1.z - p2.z;
+
+  return sqrt(a * a + b * b + (c * c) * zWeight);
+}
+
+half4 main(float2 coord) {
+  float4 rgba = unpremul(image.eval(coord));
+  float3 hsp = rgb2hsp(rgba.rgb);
+  float3 fromHsp = rgb2hsp(fromRgb);
+  float3 toHsp = rgb2hsp(toRgba.rgb);
+
+  float recolorBrightness = clamp(toHsp.z + (hsp.z - fromHsp.z), 0, 1);
+  float3 recolorHsp = float3(toHsp.x, toHsp.y, recolorBrightness);
+
+  // Since we'll want to keep transparent pixels transparent, the final alpha is the combination of the source and 
+  // `to` alphas. This avoids recoloring pure transparent pixels which are typically "black", i.e. (0, 0, 0, 0).
+  float4 recolorRgba = float4(hsp2rgb(recolorHsp), rgba.a * toRgba.a);
+
+  // Measure the distance between the source and `from` colors, adjusting for brightness weight.
+  float distance = cylindricalDistance(hsp, fromHsp, brightnessMatch);
+
+  float mask = distance - colorMatch;
+
+  // Apply smoothness.
+  float smoothnessVal = pow(clamp(mask / smoothness, 0., 1.), 1.5);
+  recolorRgba = mix(recolorRgba, rgba, smoothnessVal);
+
+  // Apply spill.
+  // When greenscreening, spill will desaturate the color of the remaining pixels. This helps avoid a green halo around 
+  // the subject.
+  // When recoloring to an opaque color, we rather want no spill adjustment. Thus, if spill is 0, ensure no spill is 
+  // applied by bumping spillVal to 1.
+  float spillVal = pow(clamp(mask / spill, 0., 1.), 1.5);
+  spillVal = min(spillVal + step(spill, EPSILON), 1);
+  recolorRgba.rgb = mix(float3(hsp.z), recolorRgba.rgb, spillVal);
+
+  recolorRgba.rgb *= recolorRgba.a;
+
+  return recolorRgba;
+}

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

@@ -0,0 +1,74 @@
+// #include //ly.img.cesdk/shader/common/ubq_color_conversions
+uniform shader image;
+uniform float offset;
+uniform float darkness;
+
+// Obtaining the nearest value to the predefined HSL levels
+float nearestLevel(float col) {
+  const int levCount = 6;  // TODO: Include option for the user to choose the amount of levels
+  const float interval = 1.0 / float(levCount);
+
+  for (float i = 0.0; i <= 1.0; i += interval) {
+    if (col >= i && col <= (i + interval)) {
+      return (abs(col - i) < abs(col - (i + interval))) ? i : (i + interval);
+    }
+  }
+  return 0;
+}
+
+half4 main(float2 coord) {
+  float4 rgba = unpremul(image.eval(coord));
+  float3 origCol = rgba.rgb;
+  float alpha = rgba.a;
+
+  // Applying the edge detection filter to create an outline
+
+  // Obtaining the local 3x3 matrix
+  float4 A[9];
+  A[0] = unpremul(image.eval(coord + float2(-1, -1)));
+  A[1] = unpremul(image.eval(coord + float2(0, -1)));
+  A[2] = unpremul(image.eval(coord + float2(1, -1)));
+  A[3] = unpremul(image.eval(coord + float2(-1, 0)));
+  A[4] = rgba;
+  A[5] = unpremul(image.eval(coord + float2(1, 0)));
+  A[6] = unpremul(image.eval(coord + float2(-1, 1)));
+  A[7] = unpremul(image.eval(coord + float2(0, 1)));
+  A[8] = unpremul(image.eval(coord + float2(1, 1)));
+
+  // Computing the x-direction gradient
+  float4 sum_x = -A[0] + (A[2]) - (A[3] * 2.0) + (A[5] * 2.0) - (A[6]) + (A[8]);
+
+  // Computing the y-direction gradient
+  float4 sum_y = A[0] + (A[1] * 2.0) + A[2] - A[6] - (A[7] * 2.0) - A[8];
+
+  // Computing the sum
+  float4 sum = sqrt((sum_x * sum_x) + (sum_y * sum_y));
+
+  // Combining the colors to obtain a black color for the outline
+  float sumLength = length(sum);
+  float outlineShade = 1.0 - sumLength;
+  float4 outlineCol = float4(outlineShade, outlineShade, outlineShade, alpha);
+
+  // Thresholding
+  if (outlineShade > 0.5)
+    outlineShade = 1.0;
+
+  // Applying the cel-shading effect
+  float3 hslColor = rgb2hsl(origCol);
+  hslColor.x = nearestLevel(hslColor.x);
+  hslColor.y = nearestLevel(hslColor.y);
+  hslColor.z = nearestLevel(hslColor.z);
+
+  float3 outColor = hsl2rgb(hslColor);
+
+  float4 tc = float4(outColor.r, outColor.g, outColor.b, alpha);
+
+  // If pixel is an edge, set pixel to the outline color
+  if (outlineShade != 1.0) {
+    tc = outlineCol;
+  }
+
+  tc.rgb *= tc.a;
+
+  return tc;
+}

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

@@ -0,0 +1,22 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float amount;
+uniform float angle;
+
+float4 imageEval(float2 uv) {
+  uv.y = 1.0 - uv.y;
+  float2 coord = uv * imageSize;
+  return unpremul(image.eval(coord));
+}
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  uv.y = 1.0 - uv.y;
+  float2 offset = amount * float2(sin(angle), cos(angle));
+  float2 greenAlpha = unpremul(image.eval(coord)).ga;
+  float2 redAlpha = imageEval(uv + offset).ra;
+  float2 blueAlpha = imageEval(uv - offset).ba;
+  float3 color = float3(redAlpha.x, greenAlpha.x, blueAlpha.x);
+  float avgAlpha = (redAlpha.y + greenAlpha.y + blueAlpha.y) / 3.0;
+  return float4(color * avgAlpha, avgAlpha);
+}

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

@@ -0,0 +1,21 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float amount;
+uniform float position;
+half4 main(float2 coord) {
+  float weights[5];
+  weights[0] = 0.1633;
+  weights[1] = 0.1531;
+  weights[2] = 0.12245;
+  weights[3] = 0.0918;
+  weights[4] = 0.051;
+
+  float vv = amount * abs((1 - position) * imageSize.y - coord.y);
+  float4 sum = 0.1633 * image.eval(coord);
+  for (int i = 1; i <= 4; i++) {
+    float weight = weights[i];
+    sum += weight * image.eval(coord - float2(0, float(i) * vv));
+    sum += weight * image.eval(coord + float2(0, float(i) * vv));
+  }
+  return sum;
+}

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

@@ -0,0 +1,25 @@
+// #include //ly.img.cesdk/shader/common/ubq_noise
+uniform shader image;
+uniform float2 imageSize;
+uniform float time;
+uniform float distortion;
+uniform float distortion2;
+uniform float speed;
+uniform float rollSpeed;
+
+half4 main(float2 coord) {
+  float2 uv = coord / imageSize;
+  uv.y = 1.0 - uv.y;
+  float ty = time * speed * 17.346;
+  float yt = uv.y - ty;
+
+  // thick distortion
+  float offset = noise2d(float2(yt * 3.0, 0.0)) * 0.2;
+  offset = offset * distortion * offset * distortion * offset;
+  // fine distortion
+  offset += noise2d(float2(yt * 50.0, 0.0)) * distortion2 * 0.002;
+
+  uv = float2(fract(uv.x + offset), fract(uv.y - time * rollSpeed));
+  uv.y = 1.0 - uv.y;
+  return image.eval(uv * imageSize);
+}

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

@@ -0,0 +1,12 @@
+uniform shader image;
+uniform float2 imageSize;
+uniform float offset;
+uniform float darkness;
+half4 main(float2 coord) {
+  float4 texel = unpremul(image.eval(coord));
+  float2 uv = coord / imageSize;
+  uv = (uv - float2(0.5)) * float2(offset);
+  float4 color = float4(mix(texel.rgb, float3(1.0 - darkness), dot(uv, uv)), texel.a);
+  color.rgb *= color.a;
+  return color;
+}

package/example.js

@@ -0,0 +1,31 @@
+/* eslint-disable no-console */
+
+// Minimal example for @cesdk/node-native. See
+// https://img.ly/docs/cesdk/node-native/ for complete documentation.
+
+const fs = require('fs/promises');
+const CreativeEngine = require('./lib/index.js');
+
+const license = process.env.CESDK_LICENSE;
+
+CreativeEngine.init({ license }).then(async (engine) => {
+  try {
+    console.log('Creating scene');
+    const scene = engine.scene.create();
+    const page = engine.block.create('page');
+    engine.block.appendChild(scene, page);
+    engine.block.setWidth(page, 1920);
+    engine.block.setHeight(page, 1080);
+
+    console.log('Exporting page as PNG');
+    const pngBlob = await engine.block.export(page, 'image/png', {});
+    const outPath = './example-output.png';
+    await fs.writeFile(outPath, Buffer.from(await pngBlob.arrayBuffer()));
+    console.log(`Wrote ${outPath}`);
+  } catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+  } finally {
+    engine.dispose();
+  }
+});