The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Add GLSL shader node using PyOpenGL (#12148)
pythongosssss96d6bd1a4ad3
diff --git a/blueprints/.glsl/Brightness_and_Contrast_1.frag b/blueprints/.glsl/Brightness_and_Contrast_1.fragnew file mode 100644index 000000000..da5424080--- /dev/null+++ b/blueprints/.glsl/Brightness_and_Contrast_1.frag@@ -0,0 +1,44 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform float u_float0; // Brightness slider -100..100+uniform float u_float1; // Contrast slider -100..100++in vec2 v_texCoord;+out vec4 fragColor;++const float MID_GRAY = 0.18; // 18% reflectance++// sRGB gamma 2.2 approximation+vec3 srgbToLinear(vec3 c) {+ return pow(max(c, 0.0), vec3(2.2));+}++vec3 linearToSrgb(vec3 c) {+ return pow(max(c, 0.0), vec3(1.0/2.2));+}++float mapBrightness(float b) {+ return clamp(b / 100.0, -1.0, 1.0);+}++float mapContrast(float c) {+ return clamp(c / 100.0 + 1.0, 0.0, 2.0);+}++void main() {+ vec4 orig = texture(u_image0, v_texCoord);++ float brightness = mapBrightness(u_float0);+ float contrast = mapContrast(u_float1);++ vec3 lin = srgbToLinear(orig.rgb);++ lin = (lin - MID_GRAY) * contrast + brightness + MID_GRAY;++ // Convert back to sRGB+ vec3 result = linearToSrgb(clamp(lin, 0.0, 1.0));++ fragColor = vec4(result, orig.a);+}diff --git a/blueprints/.glsl/Chromatic_Aberration_16.frag b/blueprints/.glsl/Chromatic_Aberration_16.fragnew file mode 100644index 000000000..09a271146--- /dev/null+++ b/blueprints/.glsl/Chromatic_Aberration_16.frag@@ -0,0 +1,72 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform int u_int0; // Mode+uniform float u_float0; // Amount (0 to 100)++in vec2 v_texCoord;+out vec4 fragColor;++const int MODE_LINEAR = 0;+const int MODE_RADIAL = 1;+const int MODE_BARREL = 2;+const int MODE_SWIRL = 3;+const int MODE_DIAGONAL = 4;++const float AMOUNT_SCALE = 0.0005;+const float RADIAL_MULT = 4.0;+const float BARREL_MULT = 8.0;+const float INV_SQRT2 = 0.70710678118;++void main() {+ vec2 uv = v_texCoord;+ vec4 original = texture(u_image0, uv);++ float amount = u_float0 * AMOUNT_SCALE;++ if (amount < 0.000001) {+ fragColor = original;+ return;+ }++ // Aspect-corrected coordinates for circular effects+ float aspect = u_resolution.x / u_resolution.y;+ vec2 centered = uv - 0.5;+ vec2 corrected = vec2(centered.x * aspect, centered.y);+ float r = length(corrected);+ vec2 dir = r > 0.0001 ? corrected / r : vec2(0.0);+ vec2 offset = vec2(0.0);++ if (u_int0 == MODE_LINEAR) {+ // Horizontal shift (no aspect correction needed)+ offset = vec2(amount, 0.0);+ }+ else if (u_int0 == MODE_RADIAL) {+ // Outward from center, stronger at edges+ offset = dir * r * amount * RADIAL_MULT;+ offset.x /= aspect; // Convert back to UV space+ }+ else if (u_int0 == MODE_BARREL) {+ // Lens distortion simulation (r² falloff)+ offset = dir * r * r * amount * BARREL_MULT;+ offset.x /= aspect; // Convert back to UV space+ }+ else if (u_int0 == MODE_SWIRL) {+ // Perpendicular to radial (rotational aberration)+ vec2 perp = vec2(-dir.y, dir.x);+ offset = perp * r * amount * RADIAL_MULT;+ offset.x /= aspect; // Convert back to UV space+ }+ else if (u_int0 == MODE_DIAGONAL) {+ // 45° offset (no aspect correction needed)+ offset = vec2(amount, amount) * INV_SQRT2;+ }++ float red = texture(u_image0, uv + offset).r;+ float green = original.g;+ float blue = texture(u_image0, uv - offset).b;++ fragColor = vec4(red, green, blue, original.a);+}\ No newline at end of filediff --git a/blueprints/.glsl/Color_Adjustment_15.frag b/blueprints/.glsl/Color_Adjustment_15.fragnew file mode 100644index 000000000..697525f14--- /dev/null+++ b/blueprints/.glsl/Color_Adjustment_15.frag@@ -0,0 +1,78 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform float u_float0; // temperature (-100 to 100)+uniform float u_float1; // tint (-100 to 100)+uniform float u_float2; // vibrance (-100 to 100)+uniform float u_float3; // saturation (-100 to 100)++in vec2 v_texCoord;+out vec4 fragColor;++const float INPUT_SCALE = 0.01;+const float TEMP_TINT_PRIMARY = 0.3;+const float TEMP_TINT_SECONDARY = 0.15;+const float VIBRANCE_BOOST = 2.0;+const float SATURATION_BOOST = 2.0;+const float SKIN_PROTECTION = 0.5;+const float EPSILON = 0.001;+const vec3 LUMA_WEIGHTS = vec3(0.299, 0.587, 0.114);++void main() {+ vec4 tex = texture(u_image0, v_texCoord);+ vec3 color = tex.rgb;++ // Scale inputs: -100/100 → -1/1+ float temperature = u_float0 * INPUT_SCALE;+ float tint = u_float1 * INPUT_SCALE;+ float vibrance = u_float2 * INPUT_SCALE;+ float saturation = u_float3 * INPUT_SCALE;++ // Temperature (warm/cool): positive = warm, negative = cool+ color.r += temperature * TEMP_TINT_PRIMARY;+ color.b -= temperature * TEMP_TINT_PRIMARY;++ // Tint (green/magenta): positive = green, negative = magenta+ color.g += tint * TEMP_TINT_PRIMARY;+ color.r -= tint * TEMP_TINT_SECONDARY;+ color.b -= tint * TEMP_TINT_SECONDARY;++ // Single clamp after temperature/tint+ color = clamp(color, 0.0, 1.0);++ // Vibrance with skin protection+ if (vibrance != 0.0) {+ float maxC = max(color.r, max(color.g, color.b));+ float minC = min(color.r, min(color.g, color.b));+ float sat = maxC - minC;+ float gray = dot(color, LUMA_WEIGHTS);++ if (vibrance < 0.0) {+ // Desaturate: -100 → gray+ color = mix(vec3(gray), color, 1.0 + vibrance);+ } else {+ // Boost less saturated colors more+ float vibranceAmt = vibrance * (1.0 - sat);++ // Branchless skin tone protection+ float isWarmTone = step(color.b, color.g) * step(color.g, color.r);+ float warmth = (color.r - color.b) / max(maxC, EPSILON);+ float skinTone = isWarmTone * warmth * sat * (1.0 - sat);+ vibranceAmt *= (1.0 - skinTone * SKIN_PROTECTION);++ color = mix(vec3(gray), color, 1.0 + vibranceAmt * VIBRANCE_BOOST);+ }+ }++ // Saturation+ if (saturation != 0.0) {+ float gray = dot(color, LUMA_WEIGHTS);+ float satMix = saturation < 0.0+ ? 1.0 + saturation // -100 → gray+ : 1.0 + saturation * SATURATION_BOOST; // +100 → 3x boost+ color = mix(vec3(gray), color, satMix);+ }++ fragColor = vec4(clamp(color, 0.0, 1.0), tex.a);+}\ No newline at end of filediff --git a/blueprints/.glsl/Edge-Preserving_Blur_128.frag b/blueprints/.glsl/Edge-Preserving_Blur_128.fragnew file mode 100644index 000000000..f269aebd6--- /dev/null+++ b/blueprints/.glsl/Edge-Preserving_Blur_128.frag@@ -0,0 +1,94 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform float u_float0; // Blur radius (0–20, default ~5)+uniform float u_float1; // Edge threshold (0–100, default ~30)+uniform int u_int0; // Step size (0/1 = every pixel, 2+ = skip pixels)++in vec2 v_texCoord;+out vec4 fragColor;++const int MAX_RADIUS = 20;+const float EPSILON = 0.0001;++// Perceptual luminance+float getLuminance(vec3 rgb) {+ return dot(rgb, vec3(0.299, 0.587, 0.114));+}++vec4 bilateralFilter(vec2 uv, vec2 texelSize, int radius,+ float sigmaSpatial, float sigmaColor)+{+ vec4 center = texture(u_image0, uv);+ vec3 centerRGB = center.rgb;++ float invSpatial2 = -0.5 / (sigmaSpatial * sigmaSpatial);+ float invColor2 = -0.5 / (sigmaColor * sigmaColor + EPSILON);++ vec3 sumRGB = vec3(0.0);+ float sumWeight = 0.0;++ int step = max(u_int0, 1);+ float radius2 = float(radius * radius);++ for (int dy = -MAX_RADIUS; dy <= MAX_RADIUS; dy++) {+ if (dy < -radius || dy > radius) continue;+ if (abs(dy) % step != 0) continue;++ for (int dx = -MAX_RADIUS; dx <= MAX_RADIUS; dx++) {+ if (dx < -radius || dx > radius) continue;+ if (abs(dx) % step != 0) continue;++ vec2 offset = vec2(float(dx), float(dy));+ float dist2 = dot(offset, offset);+ if (dist2 > radius2) continue;++ vec3 sampleRGB = texture(u_image0, uv + offset * texelSize).rgb;++ // Spatial Gaussian+ float spatialWeight = exp(dist2 * invSpatial2);++ // Perceptual color distance (weighted RGB)+ vec3 diff = sampleRGB - centerRGB;+ float colorDist = dot(diff * diff, vec3(0.299, 0.587, 0.114));+ float colorWeight = exp(colorDist * invColor2);++ float w = spatialWeight * colorWeight;+ sumRGB += sampleRGB * w;+ sumWeight += w;+ }+ }++ vec3 resultRGB = sumRGB / max(sumWeight, EPSILON);+ return vec4(resultRGB, center.a); // preserve center alpha+}++void main() {+ vec2 texelSize = 1.0 / vec2(textureSize(u_image0, 0));++ float radiusF = clamp(u_float0, 0.0, float(MAX_RADIUS));+ int radius = int(radiusF + 0.5);++ if (radius == 0) {+ fragColor = texture(u_image0, v_texCoord);+ return;+ }++ // Edge threshold → color sigma+ // Squared curve for better low-end control+ float t = clamp(u_float1, 0.0, 100.0) / 100.0;+ t *= t;+ float sigmaColor = mix(0.01, 0.5, t);++ // Spatial sigma tied to radius+ float sigmaSpatial = max(radiusF * 0.75, 0.5);++ fragColor = bilateralFilter(+ v_texCoord,+ texelSize,+ radius,+ sigmaSpatial,+ sigmaColor+ );+}\ No newline at end of filediff --git a/blueprints/.glsl/Film_Grain_15.frag b/blueprints/.glsl/Film_Grain_15.fragnew file mode 100644index 000000000..21585825b--- /dev/null+++ b/blueprints/.glsl/Film_Grain_15.frag@@ -0,0 +1,124 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform float u_float0; // grain amount [0.0 – 1.0] typical: 0.2–0.8+uniform float u_float1; // grain size [0.3 – 3.0] lower = finer grain+uniform float u_float2; // color amount [0.0 – 1.0] 0 = monochrome, 1 = RGB grain+uniform float u_float3; // luminance bias [0.0 – 1.0] 0 = uniform, 1 = shadows only+uniform int u_int0; // noise mode [0 or 1] 0 = smooth, 1 = grainy++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;++// High-quality integer hash (pcg-like)+uint pcg(uint v) {+ uint state = v * 747796405u + 2891336453u;+ uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;+ return (word >> 22u) ^ word;+}++// 2D -> 1D hash input+uint hash2d(uvec2 p) {+ return pcg(p.x + pcg(p.y));+}++// Hash to float [0, 1]+float hashf(uvec2 p) {+ return float(hash2d(p)) / float(0xffffffffu);+}++// Hash to float with offset (for RGB channels)+float hashf(uvec2 p, uint offset) {+ return float(pcg(hash2d(p) + offset)) / float(0xffffffffu);+}++// Convert uniform [0,1] to roughly Gaussian distribution+// Using simple approximation: average of multiple samples+float toGaussian(uvec2 p) {+ float sum = hashf(p, 0u) + hashf(p, 1u) + hashf(p, 2u) + hashf(p, 3u);+ return (sum - 2.0) * 0.7; // Centered, scaled+}++float toGaussian(uvec2 p, uint offset) {+ float sum = hashf(p, offset) + hashf(p, offset + 1u)+ + hashf(p, offset + 2u) + hashf(p, offset + 3u);+ return (sum - 2.0) * 0.7;+}++// Smooth noise with better interpolation+float smoothNoise(vec2 p) {+ vec2 i = floor(p);+ vec2 f = fract(p);++ // Quintic interpolation (less banding than cubic)+ f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);++ uvec2 ui = uvec2(i);+ float a = toGaussian(ui);+ float b = toGaussian(ui + uvec2(1u, 0u));+ float c = toGaussian(ui + uvec2(0u, 1u));+ float d = toGaussian(ui + uvec2(1u, 1u));++ return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);+}++float smoothNoise(vec2 p, uint offset) {+ vec2 i = floor(p);+ vec2 f = fract(p);++ f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);++ uvec2 ui = uvec2(i);+ float a = toGaussian(ui, offset);+ float b = toGaussian(ui + uvec2(1u, 0u), offset);+ float c = toGaussian(ui + uvec2(0u, 1u), offset);+ float d = toGaussian(ui + uvec2(1u, 1u), offset);++ return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);+}++void main() {+ vec4 color = texture(u_image0, v_texCoord);++ // Luminance (Rec.709)+ float luma = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));++ // Grain UV (resolution-independent)+ vec2 grainUV = v_texCoord * u_resolution / max(u_float1, 0.01);+ uvec2 grainPixel = uvec2(grainUV);++ float g;+ vec3 grainRGB;++ if (u_int0 == 1) {+ // Grainy mode: pure hash noise (no interpolation = no banding)+ g = toGaussian(grainPixel);+ grainRGB = vec3(+ toGaussian(grainPixel, 100u),+ toGaussian(grainPixel, 200u),+ toGaussian(grainPixel, 300u)+ );+ } else {+ // Smooth mode: interpolated with quintic curve+ g = smoothNoise(grainUV);+ grainRGB = vec3(+ smoothNoise(grainUV, 100u),+ smoothNoise(grainUV, 200u),+ smoothNoise(grainUV, 300u)+ );+ }++ // Luminance weighting (less grain in highlights)+ float lumWeight = mix(1.0, 1.0 - luma, clamp(u_float3, 0.0, 1.0));++ // Strength+ float strength = u_float0 * 0.15;++ // Color vs monochrome grain+ vec3 grainColor = mix(vec3(g), grainRGB, clamp(u_float2, 0.0, 1.0));++ color.rgb += grainColor * strength * lumWeight;+ fragColor0 = vec4(clamp(color.rgb, 0.0, 1.0), color.a);+}diff --git a/blueprints/.glsl/Glow_30.frag b/blueprints/.glsl/Glow_30.fragnew file mode 100644index 000000000..0ee152628--- /dev/null+++ b/blueprints/.glsl/Glow_30.frag@@ -0,0 +1,133 @@+#version 300 es+precision mediump float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform int u_int0; // Blend mode+uniform int u_int1; // Color tint+uniform float u_float0; // Intensity+uniform float u_float1; // Radius+uniform float u_float2; // Threshold++in vec2 v_texCoord;+out vec4 fragColor;++const int BLEND_ADD = 0;+const int BLEND_SCREEN = 1;+const int BLEND_SOFT = 2;+const int BLEND_OVERLAY = 3;+const int BLEND_LIGHTEN = 4;++const float GOLDEN_ANGLE = 2.39996323;+const int MAX_SAMPLES = 48;+const vec3 LUMA = vec3(0.299, 0.587, 0.114);++float hash(vec2 p) {+ p = fract(p * vec2(123.34, 456.21));+ p += dot(p, p + 45.32);+ return fract(p.x * p.y);+}++vec3 hexToRgb(int h) {+ return vec3(+ float((h >> 16) & 255),+ float((h >> 8) & 255),+ float(h & 255)+ ) * (1.0 / 255.0);+}++vec3 blend(vec3 base, vec3 glow, int mode) {+ if (mode == BLEND_SCREEN) {+ return 1.0 - (1.0 - base) * (1.0 - glow);+ }+ if (mode == BLEND_SOFT) {+ return mix(+ base - (1.0 - 2.0 * glow) * base * (1.0 - base),+ base + (2.0 * glow - 1.0) * (sqrt(base) - base),+ step(0.5, glow)+ );+ }+ if (mode == BLEND_OVERLAY) {+ return mix(+ 2.0 * base * glow,+ 1.0 - 2.0 * (1.0 - base) * (1.0 - glow),+ step(0.5, base)+ );+ }+ if (mode == BLEND_LIGHTEN) {+ return max(base, glow);+ }+ return base + glow;+}++void main() {+ vec4 original = texture(u_image0, v_texCoord);++ float intensity = u_float0 * 0.05;+ float radius = u_float1 * u_float1 * 0.012;++ if (intensity < 0.001 || radius < 0.1) {+ fragColor = original;+ return;+ }++ float threshold = 1.0 - u_float2 * 0.01;+ float t0 = threshold - 0.15;+ float t1 = threshold + 0.15;++ vec2 texelSize = 1.0 / u_resolution;+ float radius2 = radius * radius;++ float sampleScale = clamp(radius * 0.75, 0.35, 1.0);+ int samples = int(float(MAX_SAMPLES) * sampleScale);++ float noise = hash(gl_FragCoord.xy);+ float angleOffset = noise * GOLDEN_ANGLE;+ float radiusJitter = 0.85 + noise * 0.3;++ float ca = cos(GOLDEN_ANGLE);+ float sa = sin(GOLDEN_ANGLE);+ vec2 dir = vec2(cos(angleOffset), sin(angleOffset));++ vec3 glow = vec3(0.0);+ float totalWeight = 0.0;++ // Center tap+ float centerMask = smoothstep(t0, t1, dot(original.rgb, LUMA));+ glow += original.rgb * centerMask * 2.0;+ totalWeight += 2.0;++ for (int i = 1; i < MAX_SAMPLES; i++) {+ if (i >= samples) break;++ float fi = float(i);+ float dist = sqrt(fi / float(samples)) * radius * radiusJitter;++ vec2 offset = dir * dist * texelSize;+ vec3 c = texture(u_image0, v_texCoord + offset).rgb;+ float mask = smoothstep(t0, t1, dot(c, LUMA));++ float w = 1.0 - (dist * dist) / (radius2 * 1.5);+ w = max(w, 0.0);+ w *= w;++ glow += c * mask * w;+ totalWeight += w;++ dir = vec2(+ dir.x * ca - dir.y * sa,+ dir.x * sa + dir.y * ca+ );+ }++ glow *= intensity / max(totalWeight, 0.001);++ if (u_int1 > 0) {+ glow *= hexToRgb(u_int1);+ }++ vec3 result = blend(original.rgb, glow, u_int0);+ result += (noise - 0.5) * (1.0 / 255.0);++ fragColor = vec4(clamp(result, 0.0, 1.0), original.a);+}\ No newline at end of filediff --git a/blueprints/.glsl/Hue_and_Saturation_1.frag b/blueprints/.glsl/Hue_and_Saturation_1.fragnew file mode 100644index 000000000..0fa6810af--- /dev/null+++ b/blueprints/.glsl/Hue_and_Saturation_1.frag@@ -0,0 +1,222 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform int u_int0; // Mode: 0=Master, 1=Reds, 2=Yellows, 3=Greens, 4=Cyans, 5=Blues, 6=Magentas, 7=Colorize+uniform int u_int1; // Color Space: 0=HSL, 1=HSB/HSV+uniform float u_float0; // Hue (-180 to 180)+uniform float u_float1; // Saturation (-100 to 100)+uniform float u_float2; // Lightness/Brightness (-100 to 100)+uniform float u_float3; // Overlap (0 to 100) - feathering between adjacent color ranges++in vec2 v_texCoord;+out vec4 fragColor;++// Color range modes+const int MODE_MASTER = 0;+const int MODE_RED = 1;+const int MODE_YELLOW = 2;+const int MODE_GREEN = 3;+const int MODE_CYAN = 4;+const int MODE_BLUE = 5;+const int MODE_MAGENTA = 6;+const int MODE_COLORIZE = 7;++// Color space modes+const int COLORSPACE_HSL = 0;+const int COLORSPACE_HSB = 1;++const float EPSILON = 0.0001;++//=============================================================================+// RGB <-> HSL Conversions+//=============================================================================++vec3 rgb2hsl(vec3 c) {+ float maxC = max(max(c.r, c.g), c.b);+ float minC = min(min(c.r, c.g), c.b);+ float delta = maxC - minC;++ float h = 0.0;+ float s = 0.0;+ float l = (maxC + minC) * 0.5;++ if (delta > EPSILON) {+ s = l < 0.5+ ? delta / (maxC + minC)+ : delta / (2.0 - maxC - minC);++ if (maxC == c.r) {+ h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);+ } else if (maxC == c.g) {+ h = (c.b - c.r) / delta + 2.0;+ } else {+ h = (c.r - c.g) / delta + 4.0;+ }+ h /= 6.0;+ }++ return vec3(h, s, l);+}++float hue2rgb(float p, float q, float t) {+ t = fract(t);+ if (t < 1.0/6.0) return p + (q - p) * 6.0 * t;+ if (t < 0.5) return q;+ if (t < 2.0/3.0) return p + (q - p) * (2.0/3.0 - t) * 6.0;+ return p;+}++vec3 hsl2rgb(vec3 hsl) {+ if (hsl.y < EPSILON) return vec3(hsl.z);++ float q = hsl.z < 0.5+ ? hsl.z * (1.0 + hsl.y)+ : hsl.z + hsl.y - hsl.z * hsl.y;+ float p = 2.0 * hsl.z - q;++ return vec3(+ hue2rgb(p, q, hsl.x + 1.0/3.0),+ hue2rgb(p, q, hsl.x),+ hue2rgb(p, q, hsl.x - 1.0/3.0)+ );+}++vec3 rgb2hsb(vec3 c) {+ float maxC = max(max(c.r, c.g), c.b);+ float minC = min(min(c.r, c.g), c.b);+ float delta = maxC - minC;++ float h = 0.0;+ float s = (maxC > EPSILON) ? delta / maxC : 0.0;+ float b = maxC;++ if (delta > EPSILON) {+ if (maxC == c.r) {+ h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);+ } else if (maxC == c.g) {+ h = (c.b - c.r) / delta + 2.0;+ } else {+ h = (c.r - c.g) / delta + 4.0;+ }+ h /= 6.0;+ }++ return vec3(h, s, b);+}++vec3 hsb2rgb(vec3 hsb) {+ vec3 rgb = clamp(abs(mod(hsb.x * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);+ return hsb.z * mix(vec3(1.0), rgb, hsb.y);+}++//=============================================================================+// Color Range Weight Calculation+//=============================================================================++float hueDistance(float a, float b) {+ float d = abs(a - b);+ return min(d, 1.0 - d);+}++float getHueWeight(float hue, float center, float overlap) {+ float baseWidth = 1.0 / 6.0;+ float feather = baseWidth * overlap;++ float d = hueDistance(hue, center);++ float inner = baseWidth * 0.5;+ float outer = inner + feather;++ return 1.0 - smoothstep(inner, outer, d);+}++float getModeWeight(float hue, int mode, float overlap) {+ if (mode == MODE_MASTER || mode == MODE_COLORIZE) return 1.0;++ if (mode == MODE_RED) {+ return max(+ getHueWeight(hue, 0.0, overlap),+ getHueWeight(hue, 1.0, overlap)+ );+ }++ float center = float(mode - 1) / 6.0;+ return getHueWeight(hue, center, overlap);+}++//=============================================================================+// Adjustment Functions+//=============================================================================++float adjustLightness(float l, float amount) {+ return amount > 0.0+ ? l + (1.0 - l) * amount+ : l + l * amount;+}++float adjustBrightness(float b, float amount) {+ return clamp(b + amount, 0.0, 1.0);+}++float adjustSaturation(float s, float amount) {+ return amount > 0.0+ ? s + (1.0 - s) * amount+ : s + s * amount;+}++vec3 colorize(vec3 rgb, float hue, float sat, float light) {+ float lum = dot(rgb, vec3(0.299, 0.587, 0.114));+ float l = adjustLightness(lum, light);++ vec3 hsl = vec3(fract(hue), clamp(sat, 0.0, 1.0), clamp(l, 0.0, 1.0));+ return hsl2rgb(hsl);+}++//=============================================================================+// Main+//=============================================================================++void main() {+ vec4 original = texture(u_image0, v_texCoord);++ float hueShift = u_float0 / 360.0; // -180..180 -> -0.5..0.5+ float satAmount = u_float1 / 100.0; // -100..100 -> -1..1+ float lightAmount= u_float2 / 100.0; // -100..100 -> -1..1+ float overlap = u_float3 / 100.0; // 0..100 -> 0..1++ vec3 result;++ if (u_int0 == MODE_COLORIZE) {+ result = colorize(original.rgb, hueShift, satAmount, lightAmount);+ fragColor = vec4(result, original.a);+ return;+ }++ vec3 hsx = (u_int1 == COLORSPACE_HSL)+ ? rgb2hsl(original.rgb)+ : rgb2hsb(original.rgb);++ float weight = getModeWeight(hsx.x, u_int0, overlap);++ if (u_int0 != MODE_MASTER && hsx.y < EPSILON) {+ weight = 0.0;+ }++ if (weight > EPSILON) {+ float h = fract(hsx.x + hueShift * weight);+ float s = clamp(adjustSaturation(hsx.y, satAmount * weight), 0.0, 1.0);+ float v = (u_int1 == COLORSPACE_HSL)+ ? clamp(adjustLightness(hsx.z, lightAmount * weight), 0.0, 1.0)+ : clamp(adjustBrightness(hsx.z, lightAmount * weight), 0.0, 1.0);++ vec3 adjusted = vec3(h, s, v);+ result = (u_int1 == COLORSPACE_HSL)+ ? hsl2rgb(adjusted)+ : hsb2rgb(adjusted);+ } else {+ result = original.rgb;+ }++ fragColor = vec4(result, original.a);+}diff --git a/blueprints/.glsl/Image_Blur_1.frag b/blueprints/.glsl/Image_Blur_1.fragnew file mode 100644index 000000000..83238111d--- /dev/null+++ b/blueprints/.glsl/Image_Blur_1.frag@@ -0,0 +1,111 @@+#version 300 es+#pragma passes 2+precision highp float;++// Blur type constants+const int BLUR_GAUSSIAN = 0;+const int BLUR_BOX = 1;+const int BLUR_RADIAL = 2;++// Radial blur config+const int RADIAL_SAMPLES = 12;+const float RADIAL_STRENGTH = 0.0003;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform int u_int0; // Blur type (BLUR_GAUSSIAN, BLUR_BOX, BLUR_RADIAL)+uniform float u_float0; // Blur radius/amount+uniform int u_pass; // Pass index (0 = horizontal, 1 = vertical)++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;++float gaussian(float x, float sigma) {+ return exp(-(x * x) / (2.0 * sigma * sigma));+}++void main() {+ vec2 texelSize = 1.0 / u_resolution;+ float radius = max(u_float0, 0.0);++ // Radial (angular) blur - single pass, doesn't use separable+ if (u_int0 == BLUR_RADIAL) {+ // Only execute on first pass+ if (u_pass > 0) {+ fragColor0 = texture(u_image0, v_texCoord);+ return;+ }++ vec2 center = vec2(0.5);+ vec2 dir = v_texCoord - center;+ float dist = length(dir);++ if (dist < 1e-4) {+ fragColor0 = texture(u_image0, v_texCoord);+ return;+ }++ vec4 sum = vec4(0.0);+ float totalWeight = 0.0;+ float angleStep = radius * RADIAL_STRENGTH;++ dir /= dist;++ float cosStep = cos(angleStep);+ float sinStep = sin(angleStep);++ float negAngle = -float(RADIAL_SAMPLES) * angleStep;+ vec2 rotDir = vec2(+ dir.x * cos(negAngle) - dir.y * sin(negAngle),+ dir.x * sin(negAngle) + dir.y * cos(negAngle)+ );++ for (int i = -RADIAL_SAMPLES; i <= RADIAL_SAMPLES; i++) {+ vec2 uv = center + rotDir * dist;+ float w = 1.0 - abs(float(i)) / float(RADIAL_SAMPLES);+ sum += texture(u_image0, uv) * w;+ totalWeight += w;++ rotDir = vec2(+ rotDir.x * cosStep - rotDir.y * sinStep,+ rotDir.x * sinStep + rotDir.y * cosStep+ );+ }++ fragColor0 = sum / max(totalWeight, 0.001);+ return;+ }++ // Separable Gaussian / Box blur+ int samples = int(ceil(radius));++ if (samples == 0) {+ fragColor0 = texture(u_image0, v_texCoord);+ return;+ }++ // Direction: pass 0 = horizontal, pass 1 = vertical+ vec2 dir = (u_pass == 0) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);++ vec4 color = vec4(0.0);+ float totalWeight = 0.0;+ float sigma = radius / 2.0;++ for (int i = -samples; i <= samples; i++) {+ vec2 offset = dir * float(i) * texelSize;+ vec4 sample_color = texture(u_image0, v_texCoord + offset);++ float weight;+ if (u_int0 == BLUR_GAUSSIAN) {+ weight = gaussian(float(i), sigma);+ } else {+ // BLUR_BOX+ weight = 1.0;+ }++ color += sample_color * weight;+ totalWeight += weight;+ }++ fragColor0 = color / totalWeight;+}diff --git a/blueprints/.glsl/Image_Channels_23.frag b/blueprints/.glsl/Image_Channels_23.fragnew file mode 100644index 000000000..76d70af13--- /dev/null+++ b/blueprints/.glsl/Image_Channels_23.frag@@ -0,0 +1,19 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;+layout(location = 1) out vec4 fragColor1;+layout(location = 2) out vec4 fragColor2;+layout(location = 3) out vec4 fragColor3;++void main() {+ vec4 color = texture(u_image0, v_texCoord);+ // Output each channel as grayscale to separate render targets+ fragColor0 = vec4(vec3(color.r), 1.0); // Red channel+ fragColor1 = vec4(vec3(color.g), 1.0); // Green channel+ fragColor2 = vec4(vec3(color.b), 1.0); // Blue channel+ fragColor3 = vec4(vec3(color.a), 1.0); // Alpha channel+}diff --git a/blueprints/.glsl/Image_Levels_1.frag b/blueprints/.glsl/Image_Levels_1.fragnew file mode 100644index 000000000..f34ed1d81--- /dev/null+++ b/blueprints/.glsl/Image_Levels_1.frag@@ -0,0 +1,71 @@+#version 300 es+precision highp float;++// Levels Adjustment+// u_int0: channel (0=RGB, 1=R, 2=G, 3=B) default: 0+// u_float0: input black (0-255) default: 0+// u_float1: input white (0-255) default: 255+// u_float2: gamma (0.01-9.99) default: 1.0+// u_float3: output black (0-255) default: 0+// u_float4: output white (0-255) default: 255++uniform sampler2D u_image0;+uniform int u_int0;+uniform float u_float0;+uniform float u_float1;+uniform float u_float2;+uniform float u_float3;+uniform float u_float4;++in vec2 v_texCoord;+out vec4 fragColor;++vec3 applyLevels(vec3 color, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {+ float inRange = max(inWhite - inBlack, 0.0001);+ vec3 result = clamp((color - inBlack) / inRange, 0.0, 1.0);+ result = pow(result, vec3(1.0 / gamma));+ result = mix(vec3(outBlack), vec3(outWhite), result);+ return result;+}++float applySingleChannel(float value, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {+ float inRange = max(inWhite - inBlack, 0.0001);+ float result = clamp((value - inBlack) / inRange, 0.0, 1.0);+ result = pow(result, 1.0 / gamma);+ result = mix(outBlack, outWhite, result);+ return result;+}++void main() {+ vec4 texColor = texture(u_image0, v_texCoord);+ vec3 color = texColor.rgb;++ float inBlack = u_float0 / 255.0;+ float inWhite = u_float1 / 255.0;+ float gamma = u_float2;+ float outBlack = u_float3 / 255.0;+ float outWhite = u_float4 / 255.0;++ vec3 result;++ if (u_int0 == 0) {+ result = applyLevels(color, inBlack, inWhite, gamma, outBlack, outWhite);+ }+ else if (u_int0 == 1) {+ result = color;+ result.r = applySingleChannel(color.r, inBlack, inWhite, gamma, outBlack, outWhite);+ }+ else if (u_int0 == 2) {+ result = color;+ result.g = applySingleChannel(color.g, inBlack, inWhite, gamma, outBlack, outWhite);+ }+ else if (u_int0 == 3) {+ result = color;+ result.b = applySingleChannel(color.b, inBlack, inWhite, gamma, outBlack, outWhite);+ }+ else {+ result = color;+ }++ fragColor = vec4(result, texColor.a);+}\ No newline at end of filediff --git a/blueprints/.glsl/README.md b/blueprints/.glsl/README.mdnew file mode 100644index 000000000..d4084284b--- /dev/null+++ b/blueprints/.glsl/README.md@@ -0,0 +1,28 @@+# GLSL Shader Sources++This folder contains the GLSL fragment shaders extracted from blueprint JSON files for easier editing and version control.++## File Naming Convention++`{Blueprint_Name}_{node_id}.frag`++- **Blueprint_Name**: The JSON filename with spaces/special chars replaced by underscores+- **node_id**: The GLSLShader node ID within the subgraph++## Usage++```bash+# Extract shaders from blueprint JSONs to this folder+python update_blueprints.py extract++# Patch edited shaders back into blueprint JSONs+python update_blueprints.py patch+```++## Workflow++1. Run `extract` to pull current shaders from JSONs+2. Edit `.frag` files+3. Run `patch` to update the blueprint JSONs+4. Test+5. Commit both `.frag` files and updated JSONsdiff --git a/blueprints/.glsl/Sharpen_23.frag b/blueprints/.glsl/Sharpen_23.fragnew file mode 100644index 000000000..c03f94b66--- /dev/null+++ b/blueprints/.glsl/Sharpen_23.frag@@ -0,0 +1,28 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform float u_float0; // strength [0.0 – 2.0] typical: 0.3–1.0++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;++void main() {+ vec2 texel = 1.0 / u_resolution;++ // Sample center and neighbors+ vec4 center = texture(u_image0, v_texCoord);+ vec4 top = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));+ vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0, texel.y));+ vec4 left = texture(u_image0, v_texCoord + vec2(-texel.x, 0.0));+ vec4 right = texture(u_image0, v_texCoord + vec2( texel.x, 0.0));++ // Edge enhancement (Laplacian)+ vec4 edges = center * 4.0 - top - bottom - left - right;++ // Add edges back scaled by strength+ vec4 sharpened = center + edges * u_float0;++ fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);+}\ No newline at end of filediff --git a/blueprints/.glsl/Unsharp_Mask_26.frag b/blueprints/.glsl/Unsharp_Mask_26.fragnew file mode 100644index 000000000..f5990cb4a--- /dev/null+++ b/blueprints/.glsl/Unsharp_Mask_26.frag@@ -0,0 +1,61 @@+#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;+uniform float u_float0; // amount [0.0 - 3.0] typical: 0.5-1.5+uniform float u_float1; // radius [0.5 - 10.0] blur radius in pixels+uniform float u_float2; // threshold [0.0 - 0.1] min difference to sharpen++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;++float gaussian(float x, float sigma) {+ return exp(-(x * x) / (2.0 * sigma * sigma));+}++float getLuminance(vec3 color) {+ return dot(color, vec3(0.2126, 0.7152, 0.0722));+}++void main() {+ vec2 texel = 1.0 / u_resolution;+ float radius = max(u_float1, 0.5);+ float amount = u_float0;+ float threshold = u_float2;++ vec4 original = texture(u_image0, v_texCoord);++ // Gaussian blur for the "unsharp" mask+ int samples = int(ceil(radius));+ float sigma = radius / 2.0;++ vec4 blurred = vec4(0.0);+ float totalWeight = 0.0;++ for (int x = -samples; x <= samples; x++) {+ for (int y = -samples; y <= samples; y++) {+ vec2 offset = vec2(float(x), float(y)) * texel;+ vec4 sample_color = texture(u_image0, v_texCoord + offset);++ float dist = length(vec2(float(x), float(y)));+ float weight = gaussian(dist, sigma);+ blurred += sample_color * weight;+ totalWeight += weight;+ }+ }+ blurred /= totalWeight;++ // Unsharp mask = original - blurred+ vec3 mask = original.rgb - blurred.rgb;++ // Luminance-based threshold with smooth falloff+ float lumaDelta = abs(getLuminance(original.rgb) - getLuminance(blurred.rgb));+ float thresholdScale = smoothstep(0.0, threshold, lumaDelta);+ mask *= thresholdScale;++ // Sharpen: original + mask * amount+ vec3 sharpened = original.rgb + mask * amount;++ fragColor0 = vec4(clamp(sharpened, 0.0, 1.0), original.a);+}diff --git a/blueprints/.glsl/update_blueprints.py b/blueprints/.glsl/update_blueprints.pynew file mode 100644index 000000000..c5bd0ed54--- /dev/null+++ b/blueprints/.glsl/update_blueprints.py@@ -0,0 +1,159 @@+#!/usr/bin/env python3+"""+Shader Blueprint Updater++Syncs GLSL shader files between this folder and blueprint JSON files.++File naming convention:+ {Blueprint Name}_{node_id}.frag++Usage:+ python update_blueprints.py extract # Extract shaders from JSONs to here+ python update_blueprints.py patch # Patch shaders back into JSONs+ python update_blueprints.py # Same as patch (default)+"""++import json+import logging+import sys+import re+from pathlib import Path++logging.basicConfig(level=logging.INFO, format='%(message)s')+logger = logging.getLogger(__name__)++GLSL_DIR = Path(__file__).parent+BLUEPRINTS_DIR = GLSL_DIR.parent+++def get_blueprint_files():+ """Get all blueprint JSON files."""+ return sorted(BLUEPRINTS_DIR.glob("*.json"))+++def sanitize_filename(name):+ """Convert blueprint name to safe filename."""+ return re.sub(r'[^\w\-]', '_', name)+++def extract_shaders():+ """Extract all shaders from blueprint JSONs to this folder."""+ extracted = 0+ for json_path in get_blueprint_files():+ blueprint_name = json_path.stem++ try:+ with open(json_path, 'r') as f:+ data = json.load(f)+ except (json.JSONDecodeError, IOError) as e:+ logger.warning("Skipping %s: %s", json_path.name, e)+ continue++ # Find GLSLShader nodes in subgraphs+ for subgraph in data.get('definitions', {}).get('subgraphs', []):+ for node in subgraph.get('nodes', []):+ if node.get('type') == 'GLSLShader':+ node_id = node.get('id')+ widgets = node.get('widgets_values', [])++ # Find shader code (first string that looks like GLSL)+ for widget in widgets:+ if isinstance(widget, str) and widget.startswith('#version'):+ safe_name = sanitize_filename(blueprint_name)+ frag_name = f"{safe_name}_{node_id}.frag"+ frag_path = GLSL_DIR / frag_name++ with open(frag_path, 'w') as f:+ f.write(widget)++ logger.info(" Extracted: %s", frag_name)+ extracted += 1+ break++ logger.info("\nExtracted %d shader(s)", extracted)+++def patch_shaders():+ """Patch shaders from this folder back into blueprint JSONs."""+ # Build lookup: blueprint_name -> [(node_id, shader_code), ...]+ shader_updates = {}++ for frag_path in sorted(GLSL_DIR.glob("*.frag")):+ # Parse filename: {blueprint_name}_{node_id}.frag+ parts = frag_path.stem.rsplit('_', 1)+ if len(parts) != 2:+ logger.warning("Skipping %s: invalid filename format", frag_path.name)+ continue++ blueprint_name, node_id_str = parts++ try:+ node_id = int(node_id_str)+ except ValueError:+ logger.warning("Skipping %s: invalid node_id", frag_path.name)+ continue++ with open(frag_path, 'r') as f:+ shader_code = f.read()++ if blueprint_name not in shader_updates:+ shader_updates[blueprint_name] = []+ shader_updates[blueprint_name].append((node_id, shader_code))++ # Apply updates to JSON files+ patched = 0+ for json_path in get_blueprint_files():+ blueprint_name = sanitize_filename(json_path.stem)++ if blueprint_name not in shader_updates:+ continue++ try:+ with open(json_path, 'r') as f:+ data = json.load(f)+ except (json.JSONDecodeError, IOError) as e:+ logger.error("Error reading %s: %s", json_path.name, e)+ continue++ modified = False+ for node_id, shader_code in shader_updates[blueprint_name]:+ # Find the node and update+ for subgraph in data.get('definitions', {}).get('subgraphs', []):+ for node in subgraph.get('nodes', []):+ if node.get('id') == node_id and node.get('type') == 'GLSLShader':+ widgets = node.get('widgets_values', [])+ if len(widgets) > 0 and widgets[0] != shader_code:+ widgets[0] = shader_code+ modified = True+ logger.info(" Patched: %s (node %d)", json_path.name, node_id)+ patched += 1++ if modified:+ with open(json_path, 'w') as f:+ json.dump(data, f)++ if patched == 0:+ logger.info("No changes to apply.")+ else:+ logger.info("\nPatched %d shader(s)", patched)+++def main():+ if len(sys.argv) < 2:+ command = "patch"+ else:+ command = sys.argv[1].lower()++ if command == "extract":+ logger.info("Extracting shaders from blueprints...")+ extract_shaders()+ elif command in ("patch", "update", "apply"):+ logger.info("Patching shaders into blueprints...")+ patch_shaders()+ else:+ logger.info(__doc__)+ sys.exit(1)+++if __name__ == "__main__":+ main()diff --git a/blueprints/Brightness and Contrast.json b/blueprints/Brightness and Contrast.jsonnew file mode 100644index 000000000..2d670654d--- /dev/null+++ b/blueprints/Brightness and Contrast.json@@ -0,0 +1 @@+{"revision":0,"last_node_id":140,"last_link_id":0,"nodes":[{"id":140,"type":"916dff42-6166-4d45-b028-04eaf69fbb35","pos":[500,1440],"size":[250,178],"flags":{},"order":2,"mode":0,"inputs":[{"label":"image","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":null}],"outputs":[{"label":"IMAGE","localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[]}],"properties":{"proxyWidgets":[["4","value"],["5","value"]]},"widgets_values":[],"title":"Brightness and Contrast"}],"links":[],"version":0.4,"definitions":{"subgraphs":[{"id":"916dff42-6166-4d45-b028-04eaf69fbb35","version":1,"state":{"lastGroupId":0,"lastNodeId":143,"lastLinkId":118,"lastRerouteId":0},"revision":0,"config":{},"name":"Brightness and Contrast","inputNode":{"id":-10,"bounding":[360,-176,120,60]},"outputNode":{"id":-20,"bounding":[1410,-176,120,60]},"inputs":[{"id":"a5aae7ea-b511-4045-b5da-94101e269cd7","name":"images.image0","type":"IMAGE","linkIds":[117],"localized_name":"images.image0","label":"image","pos":[460,-156]}],"outputs":[{"id":"30b72604-69b3-4944-b253-a9099bbd73a9","name":"IMAGE0","type":"IMAGE","linkIds":[118],"localized_name":"IMAGE0","label":"IMAGE","pos":[1430,-156]}],"widgets":[],"nodes":[{"id":4,"type":"PrimitiveFloat","pos":[540,-280],"size":[270,58],"flags":{},"order":0,"mode":0,"inputs":[{"label":"brightness","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[115]}],"properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":100,"precision":1,"step":1},"widgets_values":[50]},{"id":5,"type":"PrimitiveFloat","pos":[540,-170],"size":[270,58],"flags":{},"order":1,"mode":0,"inputs":[{"label":"contrast","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[116]}],"properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":100,"precision":1,"step":1},"widgets_values":[0]},{"id":143,"type":"GLSLShader","pos":[840,-280],"size":[400,212],"flags":{},"order":2,"mode":0,"inputs":[{"label":"image0","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":117},{"label":"image1","localized_name":"images.image1","name":"images.image1","shape":7,"type":"IMAGE","link":null},{"label":"u_float0","localized_name":"floats.u_float0","name":"floats.u_float0","shape":7,"type":"FLOAT","link":115},{"label":"u_float1","localized_name":"floats.u_float1","name":"floats.u_float1","shape":7,"type":"FLOAT","link":116},{"label":"u_float2","localized_name":"floats.u_float2","name":"floats.u_float2","shape":7,"type":"FLOAT","link":null},{"label":"u_int0","localized_name":"ints.u_int0","name":"ints.u_int0","shape":7,"type":"INT","link":null},{"localized_name":"fragment_shader","name":"fragment_shader","type":"STRING","widget":{"name":"fragment_shader"},"link":null},{"localized_name":"size_mode","name":"size_mode","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"size_mode"},"link":null}],"outputs":[{"localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[118]},{"localized_name":"IMAGE1","name":"IMAGE1","type":"IMAGE","links":null},{"localized_name":"IMAGE2","name":"IMAGE2","type":"IMAGE","links":null},{"localized_name":"IMAGE3","name":"IMAGE3","type":"IMAGE","links":null}],"properties":{"Node name for S&R":"GLSLShader"},"widgets_values":["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform float u_float0; // Brightness slider -100..100\nuniform float u_float1; // Contrast slider -100..100\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nconst float MID_GRAY = 0.18; // 18% reflectance\n\n// sRGB gamma 2.2 approximation\nvec3 srgbToLinear(vec3 c) {\n return pow(max(c, 0.0), vec3(2.2));\n}\n\nvec3 linearToSrgb(vec3 c) {\n return pow(max(c, 0.0), vec3(1.0/2.2));\n}\n\nfloat mapBrightness(float b) {\n return clamp(b / 100.0, -1.0, 1.0);\n}\n\nfloat mapContrast(float c) {\n return clamp(c / 100.0 + 1.0, 0.0, 2.0);\n}\n\nvoid main() {\n vec4 orig = texture(u_image0, v_texCoord);\n\n float brightness = mapBrightness(u_float0);\n float contrast = mapContrast(u_float1);\n\n vec3 lin = srgbToLinear(orig.rgb);\n\n lin = (lin - MID_GRAY) * contrast + brightness + MID_GRAY;\n\n // Convert back to sRGB\n vec3 result = linearToSrgb(clamp(lin, 0.0, 1.0));\n\n fragColor = vec4(result, orig.a);\n}\n","from_input"]}],"groups":[],"links":[{"id":115,"origin_id":4,"origin_slot":0,"target_id":143,"target_slot":2,"type":"FLOAT"},{"id":116,"origin_id":5,"origin_slot":0,"target_id":143,"target_slot":3,"type":"FLOAT"},{"id":117,"origin_id":-10,"origin_slot":0,"target_id":143,"target_slot":0,"type":"IMAGE"},{"id":118,"origin_id":143,"origin_slot":0,"target_id":-20,"target_slot":0,"type":"IMAGE"}],"extra":{"workflowRendererVersion":"LG"}}]},"extra":{}}\ No newline at end of filediff --git a/blueprints/Chromatic Aberration.json b/blueprints/Chromatic Aberration.jsonnew file mode 100644index 000000000..ffbf41c4e--- /dev/null+++ b/blueprints/Chromatic Aberration.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 19, "last_link_id": 0, "nodes": [{"id": 19, "type": "2c5ef154-2bde-496d-bc8b-9dcf42f2913f", "pos": [3710, -2070], "size": [260, 82], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "title": "Chromatic Aberration", "properties": {"proxyWidgets": [["17", "choice"], ["18", "value"]]}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "2c5ef154-2bde-496d-bc8b-9dcf42f2913f", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 18, "lastLinkId": 23, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Chromatic Aberration", "inputNode": {"id": -10, "bounding": [3270, -2050, 120, 60]}, "outputNode": {"id": -20, "bounding": [4260, -2050, 120, 60]}, "inputs": [{"id": "3b33ac46-93a6-4b1c-896a-ed6fbd24e59c", "name": "images.image0", "type": "IMAGE", "linkIds": [20], "localized_name": "images.image0", "label": "image", "pos": [3370, -2030]}], "outputs": [{"id": "abe7cd79-a87b-4bd0-8923-d79a57d81a6e", "name": "IMAGE0", "type": "IMAGE", "linkIds": [23], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [4280, -2030]}], "widgets": [], "nodes": [{"id": 16, "type": "GLSLShader", "pos": [3810, -2320], "size": [390, 212], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 20}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 22}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": 21}, {"label": "u_int1", "localized_name": "ints.u_int1", "name": "ints.u_int1", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [23]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform int u_int0; // Mode\nuniform float u_float0; // Amount (0 to 100)\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nconst int MODE_LINEAR = 0;\nconst int MODE_RADIAL = 1;\nconst int MODE_BARREL = 2;\nconst int MODE_SWIRL = 3;\nconst int MODE_DIAGONAL = 4;\n\nconst float AMOUNT_SCALE = 0.0005;\nconst float RADIAL_MULT = 4.0;\nconst float BARREL_MULT = 8.0;\nconst float INV_SQRT2 = 0.70710678118;\n\nvoid main() {\n vec2 uv = v_texCoord;\n vec4 original = texture(u_image0, uv);\n\n float amount = u_float0 * AMOUNT_SCALE;\n\n if (amount < 0.000001) {\n fragColor = original;\n return;\n }\n\n // Aspect-corrected coordinates for circular effects\n float aspect = u_resolution.x / u_resolution.y;\n vec2 centered = uv - 0.5;\n vec2 corrected = vec2(centered.x * aspect, centered.y);\n float r = length(corrected);\n vec2 dir = r > 0.0001 ? corrected / r : vec2(0.0);\n vec2 offset = vec2(0.0);\n\n if (u_int0 == MODE_LINEAR) {\n // Horizontal shift (no aspect correction needed)\n offset = vec2(amount, 0.0);\n }\n else if (u_int0 == MODE_RADIAL) {\n // Outward from center, stronger at edges\n offset = dir * r * amount * RADIAL_MULT;\n offset.x /= aspect; // Convert back to UV space\n }\n else if (u_int0 == MODE_BARREL) {\n // Lens distortion simulation (r\u00b2 falloff)\n offset = dir * r * r * amount * BARREL_MULT;\n offset.x /= aspect; // Convert back to UV space\n }\n else if (u_int0 == MODE_SWIRL) {\n // Perpendicular to radial (rotational aberration)\n vec2 perp = vec2(-dir.y, dir.x);\n offset = perp * r * amount * RADIAL_MULT;\n offset.x /= aspect; // Convert back to UV space\n }\n else if (u_int0 == MODE_DIAGONAL) {\n // 45\u00b0 offset (no aspect correction needed)\n offset = vec2(amount, amount) * INV_SQRT2;\n }\n \n float red = texture(u_image0, uv + offset).r;\n float green = original.g;\n float blue = texture(u_image0, uv - offset).b;\n \n fragColor = vec4(red, green, blue, original.a);\n}", "from_input"]}, {"id": 18, "type": "PrimitiveFloat", "pos": [3810, -2430], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "amount", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [22]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 100, "step": 1}, "widgets_values": [30]}, {"id": 17, "type": "CustomCombo", "pos": [3520, -2320], "size": [270, 222], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "mode", "localized_name": "choice", "name": "choice", "type": "COMBO", "widget": {"name": "choice"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": null}, {"localized_name": "INDEX", "name": "INDEX", "type": "INT", "links": [21]}], "properties": {"Node name for S&R": "CustomCombo"}, "widgets_values": ["Linear", 0, "Linear", "Radial", "Barrel", "Swirl", "Diagonal", ""]}], "groups": [], "links": [{"id": 22, "origin_id": 18, "origin_slot": 0, "target_id": 16, "target_slot": 2, "type": "FLOAT"}, {"id": 21, "origin_id": 17, "origin_slot": 1, "target_id": 16, "target_slot": 4, "type": "INT"}, {"id": 20, "origin_id": -10, "origin_slot": 0, "target_id": 16, "target_slot": 0, "type": "IMAGE"}, {"id": 23, "origin_id": 16, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Color Adjustment.json b/blueprints/Color Adjustment.jsonnew file mode 100644index 000000000..f9c488250--- /dev/null+++ b/blueprints/Color Adjustment.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 14, "last_link_id": 0, "nodes": [{"id": 14, "type": "36677b92-5dd8-47a5-9380-4da982c1894f", "pos": [3610, -2630], "size": [270, 150], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "properties": {"proxyWidgets": [["4", "value"], ["5", "value"], ["7", "value"], ["6", "value"]]}, "widgets_values": [], "title": "Color Adjustment"}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "36677b92-5dd8-47a5-9380-4da982c1894f", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 16, "lastLinkId": 36, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Color Adjustment", "inputNode": {"id": -10, "bounding": [3110, -3560, 120, 60]}, "outputNode": {"id": -20, "bounding": [4070, -3560, 120, 60]}, "inputs": [{"id": "0431d493-5f28-4430-bd00-84733997fc08", "name": "images.image0", "type": "IMAGE", "linkIds": [29], "localized_name": "images.image0", "label": "image", "pos": [3210, -3540]}], "outputs": [{"id": "bee8ea06-a114-4612-8937-939f2c927bdb", "name": "IMAGE0", "type": "IMAGE", "linkIds": [28], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [4090, -3540]}], "widgets": [], "nodes": [{"id": 15, "type": "GLSLShader", "pos": [3590, -3940], "size": [420, 252], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 29}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 34}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": 30}, {"label": "u_float2", "localized_name": "floats.u_float2", "name": "floats.u_float2", "shape": 7, "type": "FLOAT", "link": 31}, {"label": "u_float3", "localized_name": "floats.u_float3", "name": "floats.u_float3", "shape": 7, "type": "FLOAT", "link": 33}, {"label": "u_float4", "localized_name": "floats.u_float4", "name": "floats.u_float4", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [28]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform float u_float0; // temperature (-100 to 100)\nuniform float u_float1; // tint (-100 to 100)\nuniform float u_float2; // vibrance (-100 to 100)\nuniform float u_float3; // saturation (-100 to 100)\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nconst float INPUT_SCALE = 0.01;\nconst float TEMP_TINT_PRIMARY = 0.3;\nconst float TEMP_TINT_SECONDARY = 0.15;\nconst float VIBRANCE_BOOST = 2.0;\nconst float SATURATION_BOOST = 2.0;\nconst float SKIN_PROTECTION = 0.5;\nconst float EPSILON = 0.001;\nconst vec3 LUMA_WEIGHTS = vec3(0.299, 0.587, 0.114);\n\nvoid main() {\n vec4 tex = texture(u_image0, v_texCoord);\n vec3 color = tex.rgb;\n \n // Scale inputs: -100/100 \u2192 -1/1\n float temperature = u_float0 * INPUT_SCALE;\n float tint = u_float1 * INPUT_SCALE;\n float vibrance = u_float2 * INPUT_SCALE;\n float saturation = u_float3 * INPUT_SCALE;\n \n // Temperature (warm/cool): positive = warm, negative = cool\n color.r += temperature * TEMP_TINT_PRIMARY;\n color.b -= temperature * TEMP_TINT_PRIMARY;\n \n // Tint (green/magenta): positive = green, negative = magenta\n color.g += tint * TEMP_TINT_PRIMARY;\n color.r -= tint * TEMP_TINT_SECONDARY;\n color.b -= tint * TEMP_TINT_SECONDARY;\n \n // Single clamp after temperature/tint\n color = clamp(color, 0.0, 1.0);\n \n // Vibrance with skin protection\n if (vibrance != 0.0) {\n float maxC = max(color.r, max(color.g, color.b));\n float minC = min(color.r, min(color.g, color.b));\n float sat = maxC - minC;\n float gray = dot(color, LUMA_WEIGHTS);\n \n if (vibrance < 0.0) {\n // Desaturate: -100 \u2192 gray\n color = mix(vec3(gray), color, 1.0 + vibrance);\n } else {\n // Boost less saturated colors more\n float vibranceAmt = vibrance * (1.0 - sat);\n \n // Branchless skin tone protection\n float isWarmTone = step(color.b, color.g) * step(color.g, color.r);\n float warmth = (color.r - color.b) / max(maxC, EPSILON);\n float skinTone = isWarmTone * warmth * sat * (1.0 - sat);\n vibranceAmt *= (1.0 - skinTone * SKIN_PROTECTION);\n \n color = mix(vec3(gray), color, 1.0 + vibranceAmt * VIBRANCE_BOOST);\n }\n }\n \n // Saturation\n if (saturation != 0.0) {\n float gray = dot(color, LUMA_WEIGHTS);\n float satMix = saturation < 0.0\n ? 1.0 + saturation // -100 \u2192 gray\n : 1.0 + saturation * SATURATION_BOOST; // +100 \u2192 3x boost\n color = mix(vec3(gray), color, satMix);\n }\n \n fragColor = vec4(clamp(color, 0.0, 1.0), tex.a);\n}", "from_input"]}, {"id": 6, "type": "PrimitiveFloat", "pos": [3290, -3610], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "vibrance", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [26, 31]}], "title": "Vibrance", "properties": {"Node name for S&R": "PrimitiveFloat", "max": 100, "min": -100, "step": 1}, "widgets_values": [0]}, {"id": 7, "type": "PrimitiveFloat", "pos": [3290, -3720], "size": [270, 58], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "saturation", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [33]}], "title": "Saturation", "properties": {"Node name for S&R": "PrimitiveFloat", "max": 100, "min": -100, "step": 1}, "widgets_values": [0]}, {"id": 5, "type": "PrimitiveFloat", "pos": [3290, -3830], "size": [270, 58], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "tint", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [30]}], "title": "Tint", "properties": {"Node name for S&R": "PrimitiveFloat", "max": 100, "min": -100, "step": 1}, "widgets_values": [0]}, {"id": 4, "type": "PrimitiveFloat", "pos": [3290, -3940], "size": [270, 58], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "temperature", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [34]}], "title": "Temperature", "properties": {"Node name for S&R": "PrimitiveFloat", "max": 100, "min": -100, "step": 1}, "widgets_values": [100]}], "groups": [], "links": [{"id": 34, "origin_id": 4, "origin_slot": 0, "target_id": 15, "target_slot": 2, "type": "FLOAT"}, {"id": 30, "origin_id": 5, "origin_slot": 0, "target_id": 15, "target_slot": 3, "type": "FLOAT"}, {"id": 31, "origin_id": 6, "origin_slot": 0, "target_id": 15, "target_slot": 4, "type": "FLOAT"}, {"id": 33, "origin_id": 7, "origin_slot": 0, "target_id": 15, "target_slot": 5, "type": "FLOAT"}, {"id": 29, "origin_id": -10, "origin_slot": 0, "target_id": 15, "target_slot": 0, "type": "IMAGE"}, {"id": 28, "origin_id": 15, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Edge-Preserving Blur.json b/blueprints/Edge-Preserving Blur.jsonnew file mode 100644index 000000000..ad7d62658--- /dev/null+++ b/blueprints/Edge-Preserving Blur.json@@ -0,0 +1 @@+{"revision":0,"last_node_id":136,"last_link_id":0,"nodes":[{"id":136,"type":"c6dc0f88-416b-4db1-bed1-442d793de5ad","pos":[669.0822222222221,835.5507407407408],"size":[210,106],"flags":{},"order":1,"mode":0,"inputs":[{"label":"image","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":null}],"outputs":[{"label":"IMAGE","localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[]}],"properties":{"proxyWidgets":[["130","value"],["131","value"],["133","value"]]},"widgets_values":[],"title":"Edge-Preserving Blur"}],"links":[],"version":0.4,"definitions":{"subgraphs":[{"id":"c6dc0f88-416b-4db1-bed1-442d793de5ad","version":1,"state":{"lastGroupId":0,"lastNodeId":138,"lastLinkId":109,"lastRerouteId":0},"revision":0,"config":{},"name":"Edge-Preserving Blur","inputNode":{"id":-10,"bounding":[1750,-620,120,60]},"outputNode":{"id":-20,"bounding":[2700,-620,120,60]},"inputs":[{"id":"06a6d0ad-25d7-4784-8c72-7fc8e7110a22","name":"images.image0","type":"IMAGE","linkIds":[106],"localized_name":"images.image0","label":"image","pos":[1850,-600]}],"outputs":[{"id":"3ae9f5d7-be63-4c9f-9893-6f848defa377","name":"IMAGE0","type":"IMAGE","linkIds":[99],"localized_name":"IMAGE0","label":"IMAGE","pos":[2720,-600]}],"widgets":[],"nodes":[{"id":128,"type":"GLSLShader","pos":[2220,-860],"size":[420,252],"flags":{},"order":3,"mode":0,"inputs":[{"label":"image0","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":106},{"label":"image1","localized_name":"images.image1","name":"images.image1","shape":7,"type":"IMAGE","link":null},{"label":"u_float0","localized_name":"floats.u_float0","name":"floats.u_float0","shape":7,"type":"FLOAT","link":100},{"label":"u_float1","localized_name":"floats.u_float1","name":"floats.u_float1","shape":7,"type":"FLOAT","link":101},{"label":"u_float2","localized_name":"floats.u_float2","name":"floats.u_float2","shape":7,"type":"FLOAT","link":null},{"label":"u_int0","localized_name":"ints.u_int0","name":"ints.u_int0","shape":7,"type":"INT","link":107},{"label":"u_int1","localized_name":"ints.u_int1","name":"ints.u_int1","shape":7,"type":"INT","link":103},{"label":"u_int2","localized_name":"ints.u_int2","name":"ints.u_int2","shape":7,"type":"INT","link":null},{"localized_name":"fragment_shader","name":"fragment_shader","type":"STRING","widget":{"name":"fragment_shader"},"link":null},{"localized_name":"size_mode","name":"size_mode","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"size_mode"},"link":null}],"outputs":[{"localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[99]},{"localized_name":"IMAGE1","name":"IMAGE1","type":"IMAGE","links":null},{"localized_name":"IMAGE2","name":"IMAGE2","type":"IMAGE","links":null},{"localized_name":"IMAGE3","name":"IMAGE3","type":"IMAGE","links":null}],"properties":{"Node name for S&R":"GLSLShader"},"widgets_values":["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform float u_float0; // Blur radius (0–20, default ~5)\nuniform float u_float1; // Edge threshold (0–100, default ~30)\nuniform int u_int0; // Step size (0/1 = every pixel, 2+ = skip pixels)\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nconst int MAX_RADIUS = 20;\nconst float EPSILON = 0.0001;\n\n// Perceptual luminance\nfloat getLuminance(vec3 rgb) {\n return dot(rgb, vec3(0.299, 0.587, 0.114));\n}\n\nvec4 bilateralFilter(vec2 uv, vec2 texelSize, int radius,\n float sigmaSpatial, float sigmaColor)\n{\n vec4 center = texture(u_image0, uv);\n vec3 centerRGB = center.rgb;\n\n float invSpatial2 = -0.5 / (sigmaSpatial * sigmaSpatial);\n float invColor2 = -0.5 / (sigmaColor * sigmaColor + EPSILON);\n\n vec3 sumRGB = vec3(0.0);\n float sumWeight = 0.0;\n\n int step = max(u_int0, 1);\n float radius2 = float(radius * radius);\n\n for (int dy = -MAX_RADIUS; dy <= MAX_RADIUS; dy++) {\n if (dy < -radius || dy > radius) continue;\n if (abs(dy) % step != 0) continue;\n\n for (int dx = -MAX_RADIUS; dx <= MAX_RADIUS; dx++) {\n if (dx < -radius || dx > radius) continue;\n if (abs(dx) % step != 0) continue;\n\n vec2 offset = vec2(float(dx), float(dy));\n float dist2 = dot(offset, offset);\n if (dist2 > radius2) continue;\n\n vec3 sampleRGB = texture(u_image0, uv + offset * texelSize).rgb;\n\n // Spatial Gaussian\n float spatialWeight = exp(dist2 * invSpatial2);\n\n // Perceptual color distance (weighted RGB)\n vec3 diff = sampleRGB - centerRGB;\n float colorDist = dot(diff * diff, vec3(0.299, 0.587, 0.114));\n float colorWeight = exp(colorDist * invColor2);\n\n float w = spatialWeight * colorWeight;\n sumRGB += sampleRGB * w;\n sumWeight += w;\n }\n }\n\n vec3 resultRGB = sumRGB / max(sumWeight, EPSILON);\n return vec4(resultRGB, center.a); // preserve center alpha\n}\n\nvoid main() {\n vec2 texelSize = 1.0 / vec2(textureSize(u_image0, 0));\n\n float radiusF = clamp(u_float0, 0.0, float(MAX_RADIUS));\n int radius = int(radiusF + 0.5);\n\n if (radius == 0) {\n fragColor = texture(u_image0, v_texCoord);\n return;\n }\n\n // Edge threshold → color sigma\n // Squared curve for better low-end control\n float t = clamp(u_float1, 0.0, 100.0) / 100.0;\n t *= t;\n float sigmaColor = mix(0.01, 0.5, t);\n\n // Spatial sigma tied to radius\n float sigmaSpatial = max(radiusF * 0.75, 0.5);\n\n fragColor = bilateralFilter(\n v_texCoord,\n texelSize,\n radius,\n sigmaSpatial,\n sigmaColor\n );\n}","from_input"]},{"id":130,"type":"PrimitiveFloat","pos":[1930,-860],"size":[270,58],"flags":{},"order":0,"mode":0,"inputs":[{"label":"blur_radius","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[100]}],"properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":20,"step":0.5,"precision":1},"widgets_values":[20]},{"id":131,"type":"PrimitiveFloat","pos":[1930,-760],"size":[270,58],"flags":{},"order":1,"mode":0,"inputs":[{"label":"edge_threshold","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[101]}],"properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":100,"step":1},"widgets_values":[50]},{"id":133,"type":"PrimitiveInt","pos":[1930,-660],"size":[270,82],"flags":{},"order":2,"mode":0,"inputs":[{"label":"step_size","localized_name":"value","name":"value","type":"INT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"INT","name":"INT","type":"INT","links":[103,107]}],"properties":{"Node name for S&R":"PrimitiveInt","min":0},"widgets_values":[1,"fixed"]}],"groups":[],"links":[{"id":100,"origin_id":130,"origin_slot":0,"target_id":128,"target_slot":2,"type":"FLOAT"},{"id":101,"origin_id":131,"origin_slot":0,"target_id":128,"target_slot":3,"type":"FLOAT"},{"id":107,"origin_id":133,"origin_slot":0,"target_id":128,"target_slot":5,"type":"INT"},{"id":103,"origin_id":133,"origin_slot":0,"target_id":128,"target_slot":6,"type":"INT"},{"id":106,"origin_id":-10,"origin_slot":0,"target_id":128,"target_slot":0,"type":"IMAGE"},{"id":99,"origin_id":128,"origin_slot":0,"target_id":-20,"target_slot":0,"type":"IMAGE"}],"extra":{"workflowRendererVersion":"LG"}}]},"extra":{}}\ No newline at end of filediff --git a/blueprints/Film Grain.json b/blueprints/Film Grain.jsonnew file mode 100644index 000000000..d4af46911--- /dev/null+++ b/blueprints/Film Grain.json@@ -0,0 +1 @@+{"revision":0,"last_node_id":22,"last_link_id":0,"nodes":[{"id":22,"type":"3324cf54-bcff-405f-a4bf-c5122c72fe56","pos":[4800,-1180],"size":[250,154],"flags":{},"order":4,"mode":0,"inputs":[{"label":"image","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":null}],"outputs":[{"label":"IMAGE","localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[]}],"title":"Film Grain","properties":{"proxyWidgets":[["17","value"],["18","value"],["19","value"],["20","value"],["21","choice"]]},"widgets_values":[]}],"links":[],"version":0.4,"definitions":{"subgraphs":[{"id":"3324cf54-bcff-405f-a4bf-c5122c72fe56","version":1,"state":{"lastGroupId":0,"lastNodeId":21,"lastLinkId":30,"lastRerouteId":0},"revision":0,"config":{},"name":"Film Grain","inputNode":{"id":-10,"bounding":[4096.671470760602,-948.2184031393472,120,60]},"outputNode":{"id":-20,"bounding":[4900,-948.2184031393472,120,60]},"inputs":[{"id":"062968ea-da25-47e7-a180-d913c267f148","name":"images.image0","type":"IMAGE","linkIds":[22],"localized_name":"images.image0","label":"image","pos":[4196.671470760602,-928.2184031393472]}],"outputs":[{"id":"43247d06-a39f-4733-9828-c39400fe02a4","name":"IMAGE0","type":"IMAGE","linkIds":[23],"localized_name":"IMAGE0","label":"IMAGE","pos":[4920,-928.2184031393472]}],"widgets":[],"nodes":[{"id":15,"type":"GLSLShader","pos":[4510,-1180],"size":[330,272],"flags":{},"order":5,"mode":0,"inputs":[{"label":"image0","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":22},{"label":"image1","localized_name":"images.image1","name":"images.image1","shape":7,"type":"IMAGE","link":null},{"label":"u_float0","localized_name":"floats.u_float0","name":"floats.u_float0","shape":7,"type":"FLOAT","link":26},{"label":"u_float1","localized_name":"floats.u_float1","name":"floats.u_float1","shape":7,"type":"FLOAT","link":27},{"label":"u_float2","localized_name":"floats.u_float2","name":"floats.u_float2","shape":7,"type":"FLOAT","link":28},{"label":"u_float3","localized_name":"floats.u_float3","name":"floats.u_float3","shape":7,"type":"FLOAT","link":29},{"label":"u_float4","localized_name":"floats.u_float4","name":"floats.u_float4","shape":7,"type":"FLOAT","link":null},{"label":"u_int0","localized_name":"ints.u_int0","name":"ints.u_int0","shape":7,"type":"INT","link":30},{"label":"u_int1","localized_name":"ints.u_int1","name":"ints.u_int1","shape":7,"type":"INT","link":null},{"localized_name":"fragment_shader","name":"fragment_shader","type":"STRING","widget":{"name":"fragment_shader"},"link":null},{"localized_name":"size_mode","name":"size_mode","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"size_mode"},"link":null}],"outputs":[{"localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[23]},{"localized_name":"IMAGE1","name":"IMAGE1","type":"IMAGE","links":null},{"localized_name":"IMAGE2","name":"IMAGE2","type":"IMAGE","links":null},{"localized_name":"IMAGE3","name":"IMAGE3","type":"IMAGE","links":null}],"properties":{"Node name for S&R":"GLSLShader"},"widgets_values":["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform float u_float0; // grain amount [0.0 – 1.0] typical: 0.2–0.8\nuniform float u_float1; // grain size [0.3 – 3.0] lower = finer grain\nuniform float u_float2; // color amount [0.0 – 1.0] 0 = monochrome, 1 = RGB grain\nuniform float u_float3; // luminance bias [0.0 – 1.0] 0 = uniform, 1 = shadows only\nuniform int u_int0; // noise mode [0 or 1] 0 = smooth, 1 = grainy\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\n// High-quality integer hash (pcg-like)\nuint pcg(uint v) {\n uint state = v * 747796405u + 2891336453u;\n uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;\n return (word >> 22u) ^ word;\n}\n\n// 2D -> 1D hash input\nuint hash2d(uvec2 p) {\n return pcg(p.x + pcg(p.y));\n}\n\n// Hash to float [0, 1]\nfloat hashf(uvec2 p) {\n return float(hash2d(p)) / float(0xffffffffu);\n}\n\n// Hash to float with offset (for RGB channels)\nfloat hashf(uvec2 p, uint offset) {\n return float(pcg(hash2d(p) + offset)) / float(0xffffffffu);\n}\n\n// Convert uniform [0,1] to roughly Gaussian distribution\n// Using simple approximation: average of multiple samples\nfloat toGaussian(uvec2 p) {\n float sum = hashf(p, 0u) + hashf(p, 1u) + hashf(p, 2u) + hashf(p, 3u);\n return (sum - 2.0) * 0.7; // Centered, scaled\n}\n\nfloat toGaussian(uvec2 p, uint offset) {\n float sum = hashf(p, offset) + hashf(p, offset + 1u) \n + hashf(p, offset + 2u) + hashf(p, offset + 3u);\n return (sum - 2.0) * 0.7;\n}\n\n// Smooth noise with better interpolation\nfloat smoothNoise(vec2 p) {\n vec2 i = floor(p);\n vec2 f = fract(p);\n \n // Quintic interpolation (less banding than cubic)\n f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n \n uvec2 ui = uvec2(i);\n float a = toGaussian(ui);\n float b = toGaussian(ui + uvec2(1u, 0u));\n float c = toGaussian(ui + uvec2(0u, 1u));\n float d = toGaussian(ui + uvec2(1u, 1u));\n \n return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nfloat smoothNoise(vec2 p, uint offset) {\n vec2 i = floor(p);\n vec2 f = fract(p);\n \n f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n \n uvec2 ui = uvec2(i);\n float a = toGaussian(ui, offset);\n float b = toGaussian(ui + uvec2(1u, 0u), offset);\n float c = toGaussian(ui + uvec2(0u, 1u), offset);\n float d = toGaussian(ui + uvec2(1u, 1u), offset);\n \n return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\nvoid main() {\n vec4 color = texture(u_image0, v_texCoord);\n \n // Luminance (Rec.709)\n float luma = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));\n \n // Grain UV (resolution-independent)\n vec2 grainUV = v_texCoord * u_resolution / max(u_float1, 0.01);\n uvec2 grainPixel = uvec2(grainUV);\n \n float g;\n vec3 grainRGB;\n \n if (u_int0 == 1) {\n // Grainy mode: pure hash noise (no interpolation = no banding)\n g = toGaussian(grainPixel);\n grainRGB = vec3(\n toGaussian(grainPixel, 100u),\n toGaussian(grainPixel, 200u),\n toGaussian(grainPixel, 300u)\n );\n } else {\n // Smooth mode: interpolated with quintic curve\n g = smoothNoise(grainUV);\n grainRGB = vec3(\n smoothNoise(grainUV, 100u),\n smoothNoise(grainUV, 200u),\n smoothNoise(grainUV, 300u)\n );\n }\n \n // Luminance weighting (less grain in highlights)\n float lumWeight = mix(1.0, 1.0 - luma, clamp(u_float3, 0.0, 1.0));\n \n // Strength\n float strength = u_float0 * 0.15;\n \n // Color vs monochrome grain\n vec3 grainColor = mix(vec3(g), grainRGB, clamp(u_float2, 0.0, 1.0));\n \n color.rgb += grainColor * strength * lumWeight;\n fragColor0 = vec4(clamp(color.rgb, 0.0, 1.0), color.a);\n}\n","from_input"]},{"id":21,"type":"CustomCombo","pos":[4280,-780],"size":[210,153.8888931274414],"flags":{},"order":0,"mode":0,"inputs":[{"label":"grain_mode","localized_name":"choice","name":"choice","type":"COMBO","widget":{"name":"choice"},"link":null}],"outputs":[{"localized_name":"STRING","name":"STRING","type":"STRING","links":null},{"localized_name":"INDEX","name":"INDEX","type":"INT","links":[30]}],"properties":{"Node name for S&R":"CustomCombo"},"widgets_values":["Smooth",0,"Smooth","Grainy",""]},{"id":17,"type":"PrimitiveFloat","pos":[4276.671470760602,-1180.3256994061358],"size":[210,58],"flags":{},"order":1,"mode":0,"inputs":[{"label":"grain_amount","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[26]}],"title":"Grain amount","properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":1,"step":0.05,"precision":2},"widgets_values":[0.25]},{"id":18,"type":"PrimitiveFloat","pos":[4280,-1080],"size":[210,58],"flags":{},"order":2,"mode":0,"inputs":[{"label":"grain_size","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[27]}],"title":"Grain size","properties":{"Node name for S&R":"PrimitiveFloat","min":0.05,"max":3,"precision":2,"step":0.05},"widgets_values":[0.1]},{"id":19,"type":"PrimitiveFloat","pos":[4280,-980],"size":[210,58],"flags":{},"order":3,"mode":0,"inputs":[{"label":"color_amount","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[28]}],"title":"Color amount","properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":1,"precision":2,"step":0.05},"widgets_values":[0]},{"id":20,"type":"PrimitiveFloat","pos":[4280,-880],"size":[210,58],"flags":{},"order":4,"mode":0,"inputs":[{"label":"shadow_focus","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[29]}],"title":"Luminance bias","properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":1,"precision":2,"step":0.05},"widgets_values":[0]}],"groups":[],"links":[{"id":26,"origin_id":17,"origin_slot":0,"target_id":15,"target_slot":2,"type":"FLOAT"},{"id":27,"origin_id":18,"origin_slot":0,"target_id":15,"target_slot":3,"type":"FLOAT"},{"id":28,"origin_id":19,"origin_slot":0,"target_id":15,"target_slot":4,"type":"FLOAT"},{"id":29,"origin_id":20,"origin_slot":0,"target_id":15,"target_slot":5,"type":"FLOAT"},{"id":30,"origin_id":21,"origin_slot":1,"target_id":15,"target_slot":7,"type":"INT"},{"id":22,"origin_id":-10,"origin_slot":0,"target_id":15,"target_slot":0,"type":"IMAGE"},{"id":23,"origin_id":15,"origin_slot":0,"target_id":-20,"target_slot":0,"type":"IMAGE"}],"extra":{"workflowRendererVersion":"LG"}}]}}\ No newline at end of filediff --git a/blueprints/Glow.json b/blueprints/Glow.jsonnew file mode 100644index 000000000..0cfaf8fc2--- /dev/null+++ b/blueprints/Glow.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 37, "last_link_id": 0, "nodes": [{"id": 37, "type": "0a99445a-aaf8-4a7f-aec3-d7d710ae1495", "pos": [2160, -360], "size": [260, 154], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "properties": {"proxyWidgets": [["34", "value"], ["35", "value"], ["33", "value"], ["31", "choice"], ["32", "color"]]}, "widgets_values": [], "title": "Glow"}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "0a99445a-aaf8-4a7f-aec3-d7d710ae1495", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 36, "lastLinkId": 53, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Glow", "inputNode": {"id": -10, "bounding": [2110, -165, 120, 60]}, "outputNode": {"id": -20, "bounding": [3170, -165, 120, 60]}, "inputs": [{"id": "ffc7cf94-be90-4d56-a3b8-d0514d61c015", "name": "images.image0", "type": "IMAGE", "linkIds": [45], "localized_name": "images.image0", "label": "image", "pos": [2210, -145]}], "outputs": [{"id": "04986101-50be-4762-8957-8e2a5e460bbb", "name": "IMAGE0", "type": "IMAGE", "linkIds": [53], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [3190, -145]}], "widgets": [], "nodes": [{"id": 30, "type": "GLSLShader", "pos": [2590, -520], "size": [520, 272], "flags": {}, "order": 5, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 45}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 51}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": 50}, {"label": "u_float2", "localized_name": "floats.u_float2", "name": "floats.u_float2", "shape": 7, "type": "FLOAT", "link": 52}, {"label": "u_float3", "localized_name": "floats.u_float3", "name": "floats.u_float3", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": 46}, {"label": "u_int1", "localized_name": "ints.u_int1", "name": "ints.u_int1", "shape": 7, "type": "INT", "link": 47}, {"label": "u_int2", "localized_name": "ints.u_int2", "name": "ints.u_int2", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [53]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform int u_int0; // Blend mode\nuniform int u_int1; // Color tint\nuniform float u_float0; // Intensity\nuniform float u_float1; // Radius\nuniform float u_float2; // Threshold\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nconst int BLEND_ADD = 0;\nconst int BLEND_SCREEN = 1;\nconst int BLEND_SOFT = 2;\nconst int BLEND_OVERLAY = 3;\nconst int BLEND_LIGHTEN = 4;\n\nconst float GOLDEN_ANGLE = 2.39996323;\nconst int MAX_SAMPLES = 48;\nconst vec3 LUMA = vec3(0.299, 0.587, 0.114);\n\nfloat hash(vec2 p) {\n p = fract(p * vec2(123.34, 456.21));\n p += dot(p, p + 45.32);\n return fract(p.x * p.y);\n}\n\nvec3 hexToRgb(int h) {\n return vec3(\n float((h >> 16) & 255),\n float((h >> 8) & 255),\n float(h & 255)\n ) * (1.0 / 255.0);\n}\n\nvec3 blend(vec3 base, vec3 glow, int mode) {\n if (mode == BLEND_SCREEN) {\n return 1.0 - (1.0 - base) * (1.0 - glow);\n }\n if (mode == BLEND_SOFT) {\n return mix(\n base - (1.0 - 2.0 * glow) * base * (1.0 - base),\n base + (2.0 * glow - 1.0) * (sqrt(base) - base),\n step(0.5, glow)\n );\n }\n if (mode == BLEND_OVERLAY) {\n return mix(\n 2.0 * base * glow,\n 1.0 - 2.0 * (1.0 - base) * (1.0 - glow),\n step(0.5, base)\n );\n }\n if (mode == BLEND_LIGHTEN) {\n return max(base, glow);\n }\n return base + glow;\n}\n\nvoid main() {\n vec4 original = texture(u_image0, v_texCoord);\n \n float intensity = u_float0 * 0.05;\n float radius = u_float1 * u_float1 * 0.012;\n \n if (intensity < 0.001 || radius < 0.1) {\n fragColor = original;\n return;\n }\n \n float threshold = 1.0 - u_float2 * 0.01;\n float t0 = threshold - 0.15;\n float t1 = threshold + 0.15;\n \n vec2 texelSize = 1.0 / u_resolution;\n float radius2 = radius * radius;\n \n float sampleScale = clamp(radius * 0.75, 0.35, 1.0);\n int samples = int(float(MAX_SAMPLES) * sampleScale);\n \n float noise = hash(gl_FragCoord.xy);\n float angleOffset = noise * GOLDEN_ANGLE;\n float radiusJitter = 0.85 + noise * 0.3;\n \n float ca = cos(GOLDEN_ANGLE);\n float sa = sin(GOLDEN_ANGLE);\n vec2 dir = vec2(cos(angleOffset), sin(angleOffset));\n \n vec3 glow = vec3(0.0);\n float totalWeight = 0.0;\n \n // Center tap\n float centerMask = smoothstep(t0, t1, dot(original.rgb, LUMA));\n glow += original.rgb * centerMask * 2.0;\n totalWeight += 2.0;\n \n for (int i = 1; i < MAX_SAMPLES; i++) {\n if (i >= samples) break;\n \n float fi = float(i);\n float dist = sqrt(fi / float(samples)) * radius * radiusJitter;\n \n vec2 offset = dir * dist * texelSize;\n vec3 c = texture(u_image0, v_texCoord + offset).rgb;\n float mask = smoothstep(t0, t1, dot(c, LUMA));\n \n float w = 1.0 - (dist * dist) / (radius2 * 1.5);\n w = max(w, 0.0);\n w *= w;\n \n glow += c * mask * w;\n totalWeight += w;\n \n dir = vec2(\n dir.x * ca - dir.y * sa,\n dir.x * sa + dir.y * ca\n );\n }\n \n glow *= intensity / max(totalWeight, 0.001);\n \n if (u_int1 > 0) {\n glow *= hexToRgb(u_int1);\n }\n \n vec3 result = blend(original.rgb, glow, u_int0);\n result += (noise - 0.5) * (1.0 / 255.0);\n \n fragColor = vec4(clamp(result, 0.0, 1.0), original.a);\n}", "from_input"]}, {"id": 34, "type": "PrimitiveFloat", "pos": [2290, -510], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "intensity", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [51]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 100, "precision": 1, "step": 1}, "widgets_values": [30]}, {"id": 35, "type": "PrimitiveFloat", "pos": [2290, -410], "size": [270, 58], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "radius", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [50]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 100, "precision": 1, "step": 1}, "widgets_values": [25]}, {"id": 33, "type": "PrimitiveFloat", "pos": [2290, -310], "size": [270, 58], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "threshold", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [52]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 100, "precision": 1, "step": 1}, "widgets_values": [100]}, {"id": 32, "type": "ColorToRGBInt", "pos": [2290, -210], "size": [270, 58], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "color_tint", "localized_name": "color", "name": "color", "type": "COLOR", "widget": {"name": "color"}, "link": null}], "outputs": [{"localized_name": "rgb_int", "name": "rgb_int", "type": "INT", "links": [47]}], "properties": {"Node name for S&R": "ColorToRGBInt"}, "widgets_values": ["#45edf5"]}, {"id": 31, "type": "CustomCombo", "pos": [2290, -110], "size": [270, 222], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "blend_mode", "localized_name": "choice", "name": "choice", "type": "COMBO", "widget": {"name": "choice"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": null}, {"localized_name": "INDEX", "name": "INDEX", "type": "INT", "links": [46]}], "properties": {"Node name for S&R": "CustomCombo"}, "widgets_values": ["add", 0, "add", "screen", "soft", "overlay", "lighten", ""]}], "groups": [], "links": [{"id": 51, "origin_id": 34, "origin_slot": 0, "target_id": 30, "target_slot": 2, "type": "FLOAT"}, {"id": 50, "origin_id": 35, "origin_slot": 0, "target_id": 30, "target_slot": 3, "type": "FLOAT"}, {"id": 52, "origin_id": 33, "origin_slot": 0, "target_id": 30, "target_slot": 4, "type": "FLOAT"}, {"id": 46, "origin_id": 31, "origin_slot": 1, "target_id": 30, "target_slot": 6, "type": "INT"}, {"id": 47, "origin_id": 32, "origin_slot": 0, "target_id": 30, "target_slot": 7, "type": "INT"}, {"id": 45, "origin_id": -10, "origin_slot": 0, "target_id": 30, "target_slot": 0, "type": "IMAGE"}, {"id": 53, "origin_id": 30, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Hue and Saturation.json b/blueprints/Hue and Saturation.jsonnew file mode 100644index 000000000..84d95df33--- /dev/null+++ b/blueprints/Hue and Saturation.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 11, "last_link_id": 0, "nodes": [{"id": 11, "type": "c64f83e9-aa5d-4031-89f1-0704e39299fe", "pos": [870, -220], "size": [250, 178], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "title": "Hue and Saturation", "properties": {"proxyWidgets": [["2", "choice"], ["4", "value"], ["5", "value"], ["6", "value"], ["7", "value"], ["3", "choice"]]}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "c64f83e9-aa5d-4031-89f1-0704e39299fe", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 10, "lastLinkId": 11, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Hue and Saturation", "inputNode": {"id": -10, "bounding": [360, -176, 120, 60]}, "outputNode": {"id": -20, "bounding": [1410, -176, 120, 60]}, "inputs": [{"id": "a5aae7ea-b511-4045-b5da-94101e269cd7", "name": "images.image0", "type": "IMAGE", "linkIds": [10], "localized_name": "images.image0", "label": "image", "pos": [460, -156]}], "outputs": [{"id": "30b72604-69b3-4944-b253-a9099bbd73a9", "name": "IMAGE0", "type": "IMAGE", "linkIds": [8], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [1430, -156]}], "widgets": [], "nodes": [{"id": 3, "type": "CustomCombo", "pos": [540, -240], "size": [270, 150], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "color_space", "localized_name": "choice", "name": "choice", "type": "COMBO", "widget": {"name": "choice"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": null}, {"localized_name": "INDEX", "name": "INDEX", "type": "INT", "links": [2]}], "properties": {"Node name for S&R": "CustomCombo"}, "widgets_values": ["HSL", 0, "HSL", "HSB/HSV", ""]}, {"id": 2, "type": "CustomCombo", "pos": [540, -580], "size": [270, 294], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "mode", "localized_name": "choice", "name": "choice", "type": "COMBO", "widget": {"name": "choice"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": null}, {"localized_name": "INDEX", "name": "INDEX", "type": "INT", "links": [1]}], "properties": {"Node name for S&R": "CustomCombo"}, "widgets_values": ["Master", 0, "Master", "Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas", "Colorize", ""]}, {"id": 7, "type": "PrimitiveFloat", "pos": [540, 260], "size": [270, 58], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "overlap", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [6]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 100, "precision": 1, "step": 1}, "widgets_values": [50]}, {"id": 6, "type": "PrimitiveFloat", "pos": [540, 160], "size": [270, 58], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "brightness", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [5]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": -100, "max": 100, "precision": 1, "step": 1}, "widgets_values": [0]}, {"id": 5, "type": "PrimitiveFloat", "pos": [540, 60], "size": [270, 58], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "saturation", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [4]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": -100, "max": 100, "precision": 1, "step": 1}, "widgets_values": [0]}, {"id": 4, "type": "PrimitiveFloat", "pos": [540, -40], "size": [270, 58], "flags": {}, "order": 5, "mode": 0, "inputs": [{"label": "hue", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [3]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": -180, "max": 180, "precision": 1, "step": 1}, "widgets_values": [0]}, {"id": 1, "type": "GLSLShader", "pos": [880, -300], "size": [470, 292], "flags": {}, "order": 6, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 10}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 3}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": 4}, {"label": "u_float2", "localized_name": "floats.u_float2", "name": "floats.u_float2", "shape": 7, "type": "FLOAT", "link": 5}, {"label": "u_float3", "localized_name": "floats.u_float3", "name": "floats.u_float3", "shape": 7, "type": "FLOAT", "link": 6}, {"label": "u_float4", "localized_name": "floats.u_float4", "name": "floats.u_float4", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": 1}, {"label": "u_int1", "localized_name": "ints.u_int1", "name": "ints.u_int1", "shape": 7, "type": "INT", "link": 2}, {"label": "u_int2", "localized_name": "ints.u_int2", "name": "ints.u_int2", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [8]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform int u_int0; // Mode: 0=Master, 1=Reds, 2=Yellows, 3=Greens, 4=Cyans, 5=Blues, 6=Magentas, 7=Colorize\nuniform int u_int1; // Color Space: 0=HSL, 1=HSB/HSV\nuniform float u_float0; // Hue (-180 to 180)\nuniform float u_float1; // Saturation (-100 to 100)\nuniform float u_float2; // Lightness/Brightness (-100 to 100)\nuniform float u_float3; // Overlap (0 to 100) - feathering between adjacent color ranges\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\n// Color range modes\nconst int MODE_MASTER = 0;\nconst int MODE_RED = 1;\nconst int MODE_YELLOW = 2;\nconst int MODE_GREEN = 3;\nconst int MODE_CYAN = 4;\nconst int MODE_BLUE = 5;\nconst int MODE_MAGENTA = 6;\nconst int MODE_COLORIZE = 7;\n\n// Color space modes\nconst int COLORSPACE_HSL = 0;\nconst int COLORSPACE_HSB = 1;\n\nconst float EPSILON = 0.0001;\n\n//=============================================================================\n// RGB <-> HSL Conversions\n//=============================================================================\n\nvec3 rgb2hsl(vec3 c) {\n float maxC = max(max(c.r, c.g), c.b);\n float minC = min(min(c.r, c.g), c.b);\n float delta = maxC - minC;\n\n float h = 0.0;\n float s = 0.0;\n float l = (maxC + minC) * 0.5;\n\n if (delta > EPSILON) {\n s = l < 0.5\n ? delta / (maxC + minC)\n : delta / (2.0 - maxC - minC);\n\n if (maxC == c.r) {\n h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);\n } else if (maxC == c.g) {\n h = (c.b - c.r) / delta + 2.0;\n } else {\n h = (c.r - c.g) / delta + 4.0;\n }\n h /= 6.0;\n }\n\n return vec3(h, s, l);\n}\n\nfloat hue2rgb(float p, float q, float t) {\n t = fract(t);\n if (t < 1.0/6.0) return p + (q - p) * 6.0 * t;\n if (t < 0.5) return q;\n if (t < 2.0/3.0) return p + (q - p) * (2.0/3.0 - t) * 6.0;\n return p;\n}\n\nvec3 hsl2rgb(vec3 hsl) {\n if (hsl.y < EPSILON) return vec3(hsl.z);\n\n float q = hsl.z < 0.5\n ? hsl.z * (1.0 + hsl.y)\n : hsl.z + hsl.y - hsl.z * hsl.y;\n float p = 2.0 * hsl.z - q;\n\n return vec3(\n hue2rgb(p, q, hsl.x + 1.0/3.0),\n hue2rgb(p, q, hsl.x),\n hue2rgb(p, q, hsl.x - 1.0/3.0)\n );\n}\n\nvec3 rgb2hsb(vec3 c) {\n float maxC = max(max(c.r, c.g), c.b);\n float minC = min(min(c.r, c.g), c.b);\n float delta = maxC - minC;\n\n float h = 0.0;\n float s = (maxC > EPSILON) ? delta / maxC : 0.0;\n float b = maxC;\n\n if (delta > EPSILON) {\n if (maxC == c.r) {\n h = (c.g - c.b) / delta + (c.g < c.b ? 6.0 : 0.0);\n } else if (maxC == c.g) {\n h = (c.b - c.r) / delta + 2.0;\n } else {\n h = (c.r - c.g) / delta + 4.0;\n }\n h /= 6.0;\n }\n\n return vec3(h, s, b);\n}\n\nvec3 hsb2rgb(vec3 hsb) {\n vec3 rgb = clamp(abs(mod(hsb.x * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);\n return hsb.z * mix(vec3(1.0), rgb, hsb.y);\n}\n\n//=============================================================================\n// Color Range Weight Calculation\n//=============================================================================\n\nfloat hueDistance(float a, float b) {\n float d = abs(a - b);\n return min(d, 1.0 - d);\n}\n\nfloat getHueWeight(float hue, float center, float overlap) {\n float baseWidth = 1.0 / 6.0;\n float feather = baseWidth * overlap;\n\n float d = hueDistance(hue, center);\n\n float inner = baseWidth * 0.5;\n float outer = inner + feather;\n\n return 1.0 - smoothstep(inner, outer, d);\n}\n\nfloat getModeWeight(float hue, int mode, float overlap) {\n if (mode == MODE_MASTER || mode == MODE_COLORIZE) return 1.0;\n\n if (mode == MODE_RED) {\n return max(\n getHueWeight(hue, 0.0, overlap),\n getHueWeight(hue, 1.0, overlap)\n );\n }\n\n float center = float(mode - 1) / 6.0;\n return getHueWeight(hue, center, overlap);\n}\n\n//=============================================================================\n// Adjustment Functions\n//=============================================================================\n\nfloat adjustLightness(float l, float amount) {\n return amount > 0.0\n ? l + (1.0 - l) * amount\n : l + l * amount;\n}\n\nfloat adjustBrightness(float b, float amount) {\n return clamp(b + amount, 0.0, 1.0);\n}\n\nfloat adjustSaturation(float s, float amount) {\n return amount > 0.0\n ? s + (1.0 - s) * amount\n : s + s * amount;\n}\n\nvec3 colorize(vec3 rgb, float hue, float sat, float light) {\n float lum = dot(rgb, vec3(0.299, 0.587, 0.114));\n float l = adjustLightness(lum, light);\n\n vec3 hsl = vec3(fract(hue), clamp(sat, 0.0, 1.0), clamp(l, 0.0, 1.0));\n return hsl2rgb(hsl);\n}\n\n//=============================================================================\n// Main\n//=============================================================================\n\nvoid main() {\n vec4 original = texture(u_image0, v_texCoord);\n\n float hueShift = u_float0 / 360.0; // -180..180 -> -0.5..0.5\n float satAmount = u_float1 / 100.0; // -100..100 -> -1..1\n float lightAmount= u_float2 / 100.0; // -100..100 -> -1..1\n float overlap = u_float3 / 100.0; // 0..100 -> 0..1\n\n vec3 result;\n\n if (u_int0 == MODE_COLORIZE) {\n result = colorize(original.rgb, hueShift, satAmount, lightAmount);\n fragColor = vec4(result, original.a);\n return;\n }\n\n vec3 hsx = (u_int1 == COLORSPACE_HSL)\n ? rgb2hsl(original.rgb)\n : rgb2hsb(original.rgb);\n\n float weight = getModeWeight(hsx.x, u_int0, overlap);\n\n if (u_int0 != MODE_MASTER && hsx.y < EPSILON) {\n weight = 0.0;\n }\n\n if (weight > EPSILON) {\n float h = fract(hsx.x + hueShift * weight);\n float s = clamp(adjustSaturation(hsx.y, satAmount * weight), 0.0, 1.0);\n float v = (u_int1 == COLORSPACE_HSL)\n ? clamp(adjustLightness(hsx.z, lightAmount * weight), 0.0, 1.0)\n : clamp(adjustBrightness(hsx.z, lightAmount * weight), 0.0, 1.0);\n\n vec3 adjusted = vec3(h, s, v);\n result = (u_int1 == COLORSPACE_HSL)\n ? hsl2rgb(adjusted)\n : hsb2rgb(adjusted);\n } else {\n result = original.rgb;\n }\n\n fragColor = vec4(result, original.a);\n}\n", "from_input"]}], "groups": [], "links": [{"id": 3, "origin_id": 4, "origin_slot": 0, "target_id": 1, "target_slot": 2, "type": "FLOAT"}, {"id": 4, "origin_id": 5, "origin_slot": 0, "target_id": 1, "target_slot": 3, "type": "FLOAT"}, {"id": 5, "origin_id": 6, "origin_slot": 0, "target_id": 1, "target_slot": 4, "type": "FLOAT"}, {"id": 6, "origin_id": 7, "origin_slot": 0, "target_id": 1, "target_slot": 5, "type": "FLOAT"}, {"id": 1, "origin_id": 2, "origin_slot": 1, "target_id": 1, "target_slot": 7, "type": "INT"}, {"id": 2, "origin_id": 3, "origin_slot": 1, "target_id": 1, "target_slot": 8, "type": "INT"}, {"id": 10, "origin_id": -10, "origin_slot": 0, "target_id": 1, "target_slot": 0, "type": "IMAGE"}, {"id": 8, "origin_id": 1, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Image Blur.json b/blueprints/Image Blur.jsonnew file mode 100644index 000000000..c03f31902--- /dev/null+++ b/blueprints/Image Blur.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 8, "last_link_id": 0, "nodes": [{"id": 8, "type": "198632a3-ee76-4aab-9ce7-a69c624eaff9", "pos": [4470, -1840], "size": [210, 82], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "blurred_image", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "properties": {"proxyWidgets": [["12", "choice"], ["10", "value"]]}, "widgets_values": [], "title": "Image Blur"}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "198632a3-ee76-4aab-9ce7-a69c624eaff9", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 12, "lastLinkId": 11, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Image Blur", "inputNode": {"id": -10, "bounding": [3540, -2445, 120, 60]}, "outputNode": {"id": -20, "bounding": [4620, -2445, 121.11666870117188, 60]}, "inputs": [{"id": "7ff2a402-6b11-45e8-a92a-7158d216520a", "name": "images.image0", "type": "IMAGE", "linkIds": [9], "localized_name": "images.image0", "label": "image", "pos": [3640, -2425]}], "outputs": [{"id": "80a8e19e-ffd9-44a5-90f2-710815a5b063", "name": "IMAGE0", "type": "IMAGE", "linkIds": [3], "localized_name": "IMAGE0", "label": "blurred_image", "pos": [4640, -2425]}], "widgets": [], "nodes": [{"id": 12, "type": "CustomCombo", "pos": [3720, -2620], "size": [270, 174], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "blur_type", "localized_name": "choice", "name": "choice", "type": "COMBO", "widget": {"name": "choice"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": null}, {"localized_name": "INDEX", "name": "INDEX", "type": "INT", "links": [11]}], "properties": {"Node name for S&R": "CustomCombo"}, "widgets_values": ["Gaussian", 0, "Gaussian", "Box", "Radial", ""]}, {"id": 10, "type": "PrimitiveFloat", "pos": [4020, -2780], "size": [270, 58], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "strength", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [10]}], "properties": {"Node name for S&R": "PrimitiveFloat", "max": 100, "min": 0}, "widgets_values": [20]}, {"id": 1, "type": "GLSLShader", "pos": [4020, -2670], "size": [430, 212], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 9}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 10}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": 11}, {"label": "u_int1", "localized_name": "ints.u_int1", "name": "ints.u_int1", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [3]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": []}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": []}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": []}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\n#pragma passes 2\nprecision highp float;\n\n// Blur type constants\nconst int BLUR_GAUSSIAN = 0;\nconst int BLUR_BOX = 1;\nconst int BLUR_RADIAL = 2;\n\n// Radial blur config\nconst int RADIAL_SAMPLES = 12;\nconst float RADIAL_STRENGTH = 0.0003;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform int u_int0; // Blur type (BLUR_GAUSSIAN, BLUR_BOX, BLUR_RADIAL)\nuniform float u_float0; // Blur radius/amount\nuniform int u_pass; // Pass index (0 = horizontal, 1 = vertical)\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nfloat gaussian(float x, float sigma) {\n return exp(-(x * x) / (2.0 * sigma * sigma));\n}\n\nvoid main() {\n vec2 texelSize = 1.0 / u_resolution;\n float radius = max(u_float0, 0.0);\n\n // Radial (angular) blur - single pass, doesn't use separable\n if (u_int0 == BLUR_RADIAL) {\n // Only execute on first pass\n if (u_pass > 0) {\n fragColor0 = texture(u_image0, v_texCoord);\n return;\n }\n\n vec2 center = vec2(0.5);\n vec2 dir = v_texCoord - center;\n float dist = length(dir);\n\n if (dist < 1e-4) {\n fragColor0 = texture(u_image0, v_texCoord);\n return;\n }\n\n vec4 sum = vec4(0.0);\n float totalWeight = 0.0;\n float angleStep = radius * RADIAL_STRENGTH;\n\n dir /= dist;\n\n float cosStep = cos(angleStep);\n float sinStep = sin(angleStep);\n\n float negAngle = -float(RADIAL_SAMPLES) * angleStep;\n vec2 rotDir = vec2(\n dir.x * cos(negAngle) - dir.y * sin(negAngle),\n dir.x * sin(negAngle) + dir.y * cos(negAngle)\n );\n\n for (int i = -RADIAL_SAMPLES; i <= RADIAL_SAMPLES; i++) {\n vec2 uv = center + rotDir * dist;\n float w = 1.0 - abs(float(i)) / float(RADIAL_SAMPLES);\n sum += texture(u_image0, uv) * w;\n totalWeight += w;\n\n rotDir = vec2(\n rotDir.x * cosStep - rotDir.y * sinStep,\n rotDir.x * sinStep + rotDir.y * cosStep\n );\n }\n\n fragColor0 = sum / max(totalWeight, 0.001);\n return;\n }\n\n // Separable Gaussian / Box blur\n int samples = int(ceil(radius));\n\n if (samples == 0) {\n fragColor0 = texture(u_image0, v_texCoord);\n return;\n }\n\n // Direction: pass 0 = horizontal, pass 1 = vertical\n vec2 dir = (u_pass == 0) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n vec4 color = vec4(0.0);\n float totalWeight = 0.0;\n float sigma = radius / 2.0;\n\n for (int i = -samples; i <= samples; i++) {\n vec2 offset = dir * float(i) * texelSize;\n vec4 sample_color = texture(u_image0, v_texCoord + offset);\n\n float weight;\n if (u_int0 == BLUR_GAUSSIAN) {\n weight = gaussian(float(i), sigma);\n } else {\n // BLUR_BOX\n weight = 1.0;\n }\n\n color += sample_color * weight;\n totalWeight += weight;\n }\n\n fragColor0 = color / totalWeight;\n}\n", "from_input"]}], "groups": [], "links": [{"id": 10, "origin_id": 10, "origin_slot": 0, "target_id": 1, "target_slot": 2, "type": "FLOAT"}, {"id": 11, "origin_id": 12, "origin_slot": 1, "target_id": 1, "target_slot": 4, "type": "INT"}, {"id": 9, "origin_id": -10, "origin_slot": 0, "target_id": 1, "target_slot": 0, "type": "IMAGE"}, {"id": 3, "origin_id": 1, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Image Channels.json b/blueprints/Image Channels.jsonnew file mode 100644index 000000000..56a565d30--- /dev/null+++ b/blueprints/Image Channels.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 29, "last_link_id": 0, "nodes": [{"id": 29, "type": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "pos": [1970, -230], "size": [180, 86], "flags": {}, "order": 5, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": []}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": []}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": []}], "title": "Image Channels", "properties": {"proxyWidgets": []}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 28, "lastLinkId": 39, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Image Channels", "inputNode": {"id": -10, "bounding": [1820, -185, 120, 60]}, "outputNode": {"id": -20, "bounding": [2460, -215, 120, 120]}, "inputs": [{"id": "3522932b-2d86-4a1f-a02a-cb29f3a9d7fe", "name": "images.image0", "type": "IMAGE", "linkIds": [39], "localized_name": "images.image0", "label": "image", "pos": [1920, -165]}], "outputs": [{"id": "605cb9c3-b065-4d9b-81d2-3ec331889b2b", "name": "IMAGE0", "type": "IMAGE", "linkIds": [26], "localized_name": "IMAGE0", "label": "R", "pos": [2480, -195]}, {"id": "fb44a77e-0522-43e9-9527-82e7465b3596", "name": "IMAGE1", "type": "IMAGE", "linkIds": [27], "localized_name": "IMAGE1", "label": "G", "pos": [2480, -175]}, {"id": "81460ee6-0131-402a-874f-6bf3001fc4ff", "name": "IMAGE2", "type": "IMAGE", "linkIds": [28], "localized_name": "IMAGE2", "label": "B", "pos": [2480, -155]}, {"id": "ae690246-80d4-4951-b1d9-9306d8a77417", "name": "IMAGE3", "type": "IMAGE", "linkIds": [29], "localized_name": "IMAGE3", "label": "A", "pos": [2480, -135]}], "widgets": [], "nodes": [{"id": 23, "type": "GLSLShader", "pos": [2000, -330], "size": [400, 172], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 39}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [26]}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": [27]}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": [28]}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": [29]}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\nlayout(location = 1) out vec4 fragColor1;\nlayout(location = 2) out vec4 fragColor2;\nlayout(location = 3) out vec4 fragColor3;\n\nvoid main() {\n vec4 color = texture(u_image0, v_texCoord);\n // Output each channel as grayscale to separate render targets\n fragColor0 = vec4(vec3(color.r), 1.0); // Red channel\n fragColor1 = vec4(vec3(color.g), 1.0); // Green channel\n fragColor2 = vec4(vec3(color.b), 1.0); // Blue channel\n fragColor3 = vec4(vec3(color.a), 1.0); // Alpha channel\n}\n", "from_input"]}], "groups": [], "links": [{"id": 39, "origin_id": -10, "origin_slot": 0, "target_id": 23, "target_slot": 0, "type": "IMAGE"}, {"id": 26, "origin_id": 23, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}, {"id": 27, "origin_id": 23, "origin_slot": 1, "target_id": -20, "target_slot": 1, "type": "IMAGE"}, {"id": 28, "origin_id": 23, "origin_slot": 2, "target_id": -20, "target_slot": 2, "type": "IMAGE"}, {"id": 29, "origin_id": 23, "origin_slot": 3, "target_id": -20, "target_slot": 3, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/blueprints/Image Levels.json b/blueprints/Image Levels.jsonnew file mode 100644index 000000000..26f7a0dc1--- /dev/null+++ b/blueprints/Image Levels.json@@ -0,0 +1 @@+{"revision":0,"last_node_id":139,"last_link_id":0,"nodes":[{"id":139,"type":"75bf8a72-aad8-4f3e-83ee-380e70248240","pos":[620,900],"size":[240,178],"flags":{},"order":1,"mode":0,"inputs":[{"label":"image","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":null}],"outputs":[{"label":"IMAGE","localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[]}],"properties":{"proxyWidgets":[["5","choice"],["3","value"],["6","value"],["7","value"],["8","value"],["9","value"]]},"widgets_values":[],"title":"Image Levels"}],"links":[],"version":0.4,"definitions":{"subgraphs":[{"id":"75bf8a72-aad8-4f3e-83ee-380e70248240","version":1,"state":{"lastGroupId":0,"lastNodeId":144,"lastLinkId":118,"lastRerouteId":0},"revision":0,"config":{},"name":"Image Levels","inputNode":{"id":-10,"bounding":[3840,-3430,120,60]},"outputNode":{"id":-20,"bounding":[4950,-3430,120,60]},"inputs":[{"id":"b53e5012-fa47-400f-a324-28c74854ccae","name":"images.image0","type":"IMAGE","linkIds":[1],"localized_name":"images.image0","label":"image","pos":[3940,-3410]}],"outputs":[{"id":"de7f2ffa-155f-41fd-b054-aa4d91ef49ca","name":"IMAGE0","type":"IMAGE","linkIds":[8],"localized_name":"IMAGE0","label":"IMAGE","pos":[4970,-3410]}],"widgets":[],"nodes":[{"id":5,"type":"CustomCombo","pos":[4020,-3350],"size":[270,198],"flags":{},"order":0,"mode":0,"inputs":[{"label":"channel","localized_name":"choice","name":"choice","type":"COMBO","widget":{"name":"choice"},"link":null}],"outputs":[{"localized_name":"STRING","name":"STRING","type":"STRING","links":null},{"localized_name":"INDEX","name":"INDEX","type":"INT","links":[3]}],"title":"Channel","properties":{"Node name for S&R":"CustomCombo"},"widgets_values":["RGB",0,"RGB","R","G","B",""]},{"id":8,"type":"PrimitiveFloat","pos":[4020,-3550],"size":[270,58],"flags":{},"order":1,"mode":0,"inputs":[{"label":"output_black","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[6]}],"title":"Output Black","properties":{"Node name for S&R":"PrimitiveFloat","max":255,"min":0,"step":1},"widgets_values":[0]},{"id":3,"type":"PrimitiveFloat","pos":[4020,-3850],"size":[270,58],"flags":{},"order":2,"mode":0,"inputs":[{"label":"input_black","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[2]}],"title":"Input Black","properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":255,"step":1},"widgets_values":[0]},{"id":6,"type":"PrimitiveFloat","pos":[4020,-3750],"size":[270,58],"flags":{},"order":3,"mode":0,"inputs":[{"label":"input_white","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[4]}],"title":"Input White","properties":{"Node name for S&R":"PrimitiveFloat","max":255,"min":0,"step":1},"widgets_values":[255]},{"id":7,"type":"PrimitiveFloat","pos":[4020,-3650],"size":[270,58],"flags":{},"order":4,"mode":0,"inputs":[{"label":"gamma","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[5]}],"title":"Gamma","properties":{"Node name for S&R":"PrimitiveFloat","max":10,"min":0,"step":0.01,"precision":2},"widgets_values":[1]},{"id":9,"type":"PrimitiveFloat","pos":[4020,-3450],"size":[270,58],"flags":{},"order":5,"mode":0,"inputs":[{"label":"output_white","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[7]}],"title":"Output White","properties":{"Node name for S&R":"PrimitiveFloat","max":255,"min":0,"step":1},"widgets_values":[255]},{"id":1,"type":"GLSLShader","pos":[4310,-3850],"size":[580,272],"flags":{},"order":6,"mode":0,"inputs":[{"label":"image0","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":1},{"label":"image1","localized_name":"images.image1","name":"images.image1","shape":7,"type":"IMAGE","link":null},{"label":"u_float0","localized_name":"floats.u_float0","name":"floats.u_float0","shape":7,"type":"FLOAT","link":2},{"label":"u_float1","localized_name":"floats.u_float1","name":"floats.u_float1","shape":7,"type":"FLOAT","link":4},{"label":"u_float2","localized_name":"floats.u_float2","name":"floats.u_float2","shape":7,"type":"FLOAT","link":5},{"label":"u_float3","localized_name":"floats.u_float3","name":"floats.u_float3","shape":7,"type":"FLOAT","link":6},{"label":"u_float4","localized_name":"floats.u_float4","name":"floats.u_float4","shape":7,"type":"FLOAT","link":7},{"label":"u_int0","localized_name":"ints.u_int0","name":"ints.u_int0","shape":7,"type":"INT","link":3},{"label":"u_int1","localized_name":"ints.u_int1","name":"ints.u_int1","shape":7,"type":"INT","link":null},{"localized_name":"fragment_shader","name":"fragment_shader","type":"STRING","widget":{"name":"fragment_shader"},"link":null},{"localized_name":"size_mode","name":"size_mode","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"size_mode"},"link":null}],"outputs":[{"localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[8]},{"localized_name":"IMAGE1","name":"IMAGE1","type":"IMAGE","links":null},{"localized_name":"IMAGE2","name":"IMAGE2","type":"IMAGE","links":null},{"localized_name":"IMAGE3","name":"IMAGE3","type":"IMAGE","links":null}],"properties":{"Node name for S&R":"GLSLShader"},"widgets_values":["#version 300 es\nprecision highp float;\n\n// Levels Adjustment\n// u_int0: channel (0=RGB, 1=R, 2=G, 3=B) default: 0\n// u_float0: input black (0-255) default: 0\n// u_float1: input white (0-255) default: 255\n// u_float2: gamma (0.01-9.99) default: 1.0\n// u_float3: output black (0-255) default: 0\n// u_float4: output white (0-255) default: 255\n\nuniform sampler2D u_image0;\nuniform int u_int0;\nuniform float u_float0;\nuniform float u_float1;\nuniform float u_float2;\nuniform float u_float3;\nuniform float u_float4;\n\nin vec2 v_texCoord;\nout vec4 fragColor;\n\nvec3 applyLevels(vec3 color, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {\n float inRange = max(inWhite - inBlack, 0.0001);\n vec3 result = clamp((color - inBlack) / inRange, 0.0, 1.0);\n result = pow(result, vec3(1.0 / gamma));\n result = mix(vec3(outBlack), vec3(outWhite), result);\n return result;\n}\n\nfloat applySingleChannel(float value, float inBlack, float inWhite, float gamma, float outBlack, float outWhite) {\n float inRange = max(inWhite - inBlack, 0.0001);\n float result = clamp((value - inBlack) / inRange, 0.0, 1.0);\n result = pow(result, 1.0 / gamma);\n result = mix(outBlack, outWhite, result);\n return result;\n}\n\nvoid main() {\n vec4 texColor = texture(u_image0, v_texCoord);\n vec3 color = texColor.rgb;\n \n float inBlack = u_float0 / 255.0;\n float inWhite = u_float1 / 255.0;\n float gamma = u_float2;\n float outBlack = u_float3 / 255.0;\n float outWhite = u_float4 / 255.0;\n \n vec3 result;\n \n if (u_int0 == 0) {\n result = applyLevels(color, inBlack, inWhite, gamma, outBlack, outWhite);\n }\n else if (u_int0 == 1) {\n result = color;\n result.r = applySingleChannel(color.r, inBlack, inWhite, gamma, outBlack, outWhite);\n }\n else if (u_int0 == 2) {\n result = color;\n result.g = applySingleChannel(color.g, inBlack, inWhite, gamma, outBlack, outWhite);\n }\n else if (u_int0 == 3) {\n result = color;\n result.b = applySingleChannel(color.b, inBlack, inWhite, gamma, outBlack, outWhite);\n }\n else {\n result = color;\n }\n \n fragColor = vec4(result, texColor.a);\n}","from_input"]}],"groups":[],"links":[{"id":2,"origin_id":3,"origin_slot":0,"target_id":1,"target_slot":2,"type":"FLOAT"},{"id":4,"origin_id":6,"origin_slot":0,"target_id":1,"target_slot":3,"type":"FLOAT"},{"id":5,"origin_id":7,"origin_slot":0,"target_id":1,"target_slot":4,"type":"FLOAT"},{"id":6,"origin_id":8,"origin_slot":0,"target_id":1,"target_slot":5,"type":"FLOAT"},{"id":7,"origin_id":9,"origin_slot":0,"target_id":1,"target_slot":6,"type":"FLOAT"},{"id":3,"origin_id":5,"origin_slot":1,"target_id":1,"target_slot":7,"type":"INT"},{"id":1,"origin_id":-10,"origin_slot":0,"target_id":1,"target_slot":0,"type":"IMAGE"},{"id":8,"origin_id":1,"origin_slot":0,"target_id":-20,"target_slot":0,"type":"IMAGE"}],"extra":{"workflowRendererVersion":"LG"}}]},"extra":{}}\ No newline at end of filediff --git a/blueprints/Sharpen.json b/blueprints/Sharpen.jsonnew file mode 100644index 000000000..49a164eca--- /dev/null+++ b/blueprints/Sharpen.json@@ -0,0 +1 @@+{"revision":0,"last_node_id":25,"last_link_id":0,"nodes":[{"id":25,"type":"621ba4e2-22a8-482d-a369-023753198b7b","pos":[4610,-790],"size":[230,58],"flags":{},"order":4,"mode":0,"inputs":[{"label":"image","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":null}],"outputs":[{"label":"IMAGE","localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[]}],"title":"Sharpen","properties":{"proxyWidgets":[["24","value"]]},"widgets_values":[]}],"links":[],"version":0.4,"definitions":{"subgraphs":[{"id":"621ba4e2-22a8-482d-a369-023753198b7b","version":1,"state":{"lastGroupId":0,"lastNodeId":24,"lastLinkId":36,"lastRerouteId":0},"revision":0,"config":{},"name":"Sharpen","inputNode":{"id":-10,"bounding":[4090,-825,120,60]},"outputNode":{"id":-20,"bounding":[5150,-825,120,60]},"inputs":[{"id":"37011fb7-14b7-4e0e-b1a0-6a02e8da1fd7","name":"images.image0","type":"IMAGE","linkIds":[34],"localized_name":"images.image0","label":"image","pos":[4190,-805]}],"outputs":[{"id":"e9182b3f-635c-4cd4-a152-4b4be17ae4b9","name":"IMAGE0","type":"IMAGE","linkIds":[35],"localized_name":"IMAGE0","label":"IMAGE","pos":[5170,-805]}],"widgets":[],"nodes":[{"id":24,"type":"PrimitiveFloat","pos":[4280,-1240],"size":[270,58],"flags":{},"order":0,"mode":0,"inputs":[{"label":"strength","localized_name":"value","name":"value","type":"FLOAT","widget":{"name":"value"},"link":null}],"outputs":[{"localized_name":"FLOAT","name":"FLOAT","type":"FLOAT","links":[36]}],"properties":{"Node name for S&R":"PrimitiveFloat","min":0,"max":3,"precision":2,"step":0.05},"widgets_values":[0.5]},{"id":23,"type":"GLSLShader","pos":[4570,-1240],"size":[370,192],"flags":{},"order":1,"mode":0,"inputs":[{"label":"image0","localized_name":"images.image0","name":"images.image0","type":"IMAGE","link":34},{"label":"image1","localized_name":"images.image1","name":"images.image1","shape":7,"type":"IMAGE","link":null},{"label":"u_float0","localized_name":"floats.u_float0","name":"floats.u_float0","shape":7,"type":"FLOAT","link":36},{"label":"u_float1","localized_name":"floats.u_float1","name":"floats.u_float1","shape":7,"type":"FLOAT","link":null},{"label":"u_int0","localized_name":"ints.u_int0","name":"ints.u_int0","shape":7,"type":"INT","link":null},{"localized_name":"fragment_shader","name":"fragment_shader","type":"STRING","widget":{"name":"fragment_shader"},"link":null},{"localized_name":"size_mode","name":"size_mode","type":"COMFY_DYNAMICCOMBO_V3","widget":{"name":"size_mode"},"link":null}],"outputs":[{"localized_name":"IMAGE0","name":"IMAGE0","type":"IMAGE","links":[35]},{"localized_name":"IMAGE1","name":"IMAGE1","type":"IMAGE","links":null},{"localized_name":"IMAGE2","name":"IMAGE2","type":"IMAGE","links":null},{"localized_name":"IMAGE3","name":"IMAGE3","type":"IMAGE","links":null}],"properties":{"Node name for S&R":"GLSLShader"},"widgets_values":["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform float u_float0; // strength [0.0 – 2.0] typical: 0.3–1.0\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nvoid main() {\n vec2 texel = 1.0 / u_resolution;\n \n // Sample center and neighbors\n vec4 center = texture(u_image0, v_texCoord);\n vec4 top = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));\n vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0, texel.y));\n vec4 left = texture(u_image0, v_texCoord + vec2(-texel.x, 0.0));\n vec4 right = texture(u_image0, v_texCoord + vec2( texel.x, 0.0));\n \n // Edge enhancement (Laplacian)\n vec4 edges = center * 4.0 - top - bottom - left - right;\n \n // Add edges back scaled by strength\n vec4 sharpened = center + edges * u_float0;\n \n fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);\n}","from_input"]}],"groups":[],"links":[{"id":36,"origin_id":24,"origin_slot":0,"target_id":23,"target_slot":2,"type":"FLOAT"},{"id":34,"origin_id":-10,"origin_slot":0,"target_id":23,"target_slot":0,"type":"IMAGE"},{"id":35,"origin_id":23,"origin_slot":0,"target_id":-20,"target_slot":0,"type":"IMAGE"}],"extra":{"workflowRendererVersion":"LG"}}]}}\ No newline at end of filediff --git a/blueprints/Unsharp Mask.json b/blueprints/Unsharp Mask.jsonnew file mode 100644index 000000000..d282a023b--- /dev/null+++ b/blueprints/Unsharp Mask.json@@ -0,0 +1 @@+{"revision": 0, "last_node_id": 30, "last_link_id": 0, "nodes": [{"id": 30, "type": "d99ba3f5-8a56-4365-8e45-3f3ea7c572a1", "pos": [4420, -370], "size": [210, 106], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "title": "Unsharp Mask", "properties": {"proxyWidgets": [["27", "value"], ["28", "value"], ["29", "value"]]}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "d99ba3f5-8a56-4365-8e45-3f3ea7c572a1", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 29, "lastLinkId": 43, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Unsharp Mask", "inputNode": {"id": -10, "bounding": [3920, -405, 120, 60]}, "outputNode": {"id": -20, "bounding": [4930, -405, 120, 60]}, "inputs": [{"id": "75354555-d2f3-46b9-a3dd-b076dcfca561", "name": "images.image0", "type": "IMAGE", "linkIds": [39], "localized_name": "images.image0", "label": "image0", "pos": [4020, -385]}], "outputs": [{"id": "04368b94-2a96-46ff-8c07-d0ce3235b40d", "name": "IMAGE0", "type": "IMAGE", "linkIds": [40], "localized_name": "IMAGE0", "pos": [4950, -385]}], "widgets": [], "nodes": [{"id": 27, "type": "PrimitiveFloat", "pos": [4100, -540], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "amount", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [41]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 3, "precision": 2, "step": 0.05}, "widgets_values": [1]}, {"id": 28, "type": "PrimitiveFloat", "pos": [4100, -430], "size": [270, 58], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "radius", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [42]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 10, "precision": 1, "step": 0.5}, "widgets_values": [3]}, {"id": 29, "type": "PrimitiveFloat", "pos": [4100, -320], "size": [270, 58], "flags": {}, "order": 2, "mode": 0, "inputs": [{"label": "threshold", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [43]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 1, "precision": 2, "step": 0.05}, "widgets_values": [0]}, {"id": 26, "type": "GLSLShader", "pos": [4470, -580], "size": [400, 232], "flags": {}, "order": 3, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 39}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 41}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": 42}, {"label": "u_float2", "localized_name": "floats.u_float2", "name": "floats.u_float2", "shape": 7, "type": "FLOAT", "link": 43}, {"label": "u_float3", "localized_name": "floats.u_float3", "name": "floats.u_float3", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [40]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform float u_float0; // amount [0.0 - 3.0] typical: 0.5-1.5\nuniform float u_float1; // radius [0.5 - 10.0] blur radius in pixels\nuniform float u_float2; // threshold [0.0 - 0.1] min difference to sharpen\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nfloat gaussian(float x, float sigma) {\n return exp(-(x * x) / (2.0 * sigma * sigma));\n}\n\nfloat getLuminance(vec3 color) {\n return dot(color, vec3(0.2126, 0.7152, 0.0722));\n}\n\nvoid main() {\n vec2 texel = 1.0 / u_resolution;\n float radius = max(u_float1, 0.5);\n float amount = u_float0;\n float threshold = u_float2;\n\n vec4 original = texture(u_image0, v_texCoord);\n\n // Gaussian blur for the \"unsharp\" mask\n int samples = int(ceil(radius));\n float sigma = radius / 2.0;\n\n vec4 blurred = vec4(0.0);\n float totalWeight = 0.0;\n\n for (int x = -samples; x <= samples; x++) {\n for (int y = -samples; y <= samples; y++) {\n vec2 offset = vec2(float(x), float(y)) * texel;\n vec4 sample_color = texture(u_image0, v_texCoord + offset);\n\n float dist = length(vec2(float(x), float(y)));\n float weight = gaussian(dist, sigma);\n blurred += sample_color * weight;\n totalWeight += weight;\n }\n }\n blurred /= totalWeight;\n\n // Unsharp mask = original - blurred\n vec3 mask = original.rgb - blurred.rgb;\n\n // Luminance-based threshold with smooth falloff\n float lumaDelta = abs(getLuminance(original.rgb) - getLuminance(blurred.rgb));\n float thresholdScale = smoothstep(0.0, threshold, lumaDelta);\n mask *= thresholdScale;\n\n // Sharpen: original + mask * amount\n vec3 sharpened = original.rgb + mask * amount;\n\n fragColor0 = vec4(clamp(sharpened, 0.0, 1.0), original.a);\n}\n", "from_input"]}], "groups": [], "links": [{"id": 41, "origin_id": 27, "origin_slot": 0, "target_id": 26, "target_slot": 2, "type": "FLOAT"}, {"id": 42, "origin_id": 28, "origin_slot": 0, "target_id": 26, "target_slot": 3, "type": "FLOAT"}, {"id": 43, "origin_id": 29, "origin_slot": 0, "target_id": 26, "target_slot": 4, "type": "FLOAT"}, {"id": 39, "origin_id": -10, "origin_slot": 0, "target_id": 26, "target_slot": 0, "type": "IMAGE"}, {"id": 40, "origin_id": 26, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}}]}}\ No newline at end of filediff --git a/comfy_extras/nodes_glsl.py b/comfy_extras/nodes_glsl.pynew file mode 100644index 000000000..18a35d846--- /dev/null+++ b/comfy_extras/nodes_glsl.py@@ -0,0 +1,895 @@+import os+import sys+import re+import logging+import ctypes.util+import importlib.util+from typing import TypedDict++import numpy as np+import torch++import nodes+from comfy_api.latest import ComfyExtension, io, ui+from typing_extensions import override+from utils.install_util import get_missing_requirements_message++logger = logging.getLogger(__name__)+++def _check_opengl_availability():+ """Early check for OpenGL availability. Raises RuntimeError if unlikely to work."""+ logger.debug("_check_opengl_availability: starting")+ missing = []++ # Check Python packages (using find_spec to avoid importing)+ logger.debug("_check_opengl_availability: checking for glfw package")+ if importlib.util.find_spec("glfw") is None:+ missing.append("glfw")++ logger.debug("_check_opengl_availability: checking for OpenGL package")+ if importlib.util.find_spec("OpenGL") is None:+ missing.append("PyOpenGL")++ if missing:+ raise RuntimeError(+ f"OpenGL dependencies not available.\n{get_missing_requirements_message()}\n"+ )++ # On Linux without display, check if headless backends are available+ logger.debug(f"_check_opengl_availability: platform={sys.platform}")+ if sys.platform.startswith("linux"):+ has_display = os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")+ logger.debug(f"_check_opengl_availability: has_display={bool(has_display)}")+ if not has_display:+ # Check for EGL or OSMesa libraries+ logger.debug("_check_opengl_availability: checking for EGL library")+ has_egl = ctypes.util.find_library("EGL")+ logger.debug("_check_opengl_availability: checking for OSMesa library")+ has_osmesa = ctypes.util.find_library("OSMesa")++ # Error disabled for CI as it fails this check+ # if not has_egl and not has_osmesa:+ # raise RuntimeError(+ # "GLSL Shader node: No display and no headless backend (EGL/OSMesa) found.\n"+ # "See error below for installation instructions."+ # )+ logger.debug(f"Headless mode: EGL={'yes' if has_egl else 'no'}, OSMesa={'yes' if has_osmesa else 'no'}")++ logger.debug("_check_opengl_availability: completed")+++# Run early check at import time+logger.debug("nodes_glsl: running _check_opengl_availability at import time")+_check_opengl_availability()++# OpenGL modules - initialized lazily when context is created+gl = None+glfw = None+EGL = None+++def _import_opengl():+ """Import OpenGL module. Called after context is created."""+ global gl+ if gl is None:+ logger.debug("_import_opengl: importing OpenGL.GL")+ import OpenGL.GL as _gl+ gl = _gl+ logger.debug("_import_opengl: import completed")+ return gl+++class SizeModeInput(TypedDict):+ size_mode: str+ width: int+ height: int+++MAX_IMAGES = 5 # u_image0-4+MAX_UNIFORMS = 5 # u_float0-4, u_int0-4+MAX_OUTPUTS = 4 # fragColor0-3 (MRT)++# Vertex shader using gl_VertexID trick - no VBO needed.+# Draws a single triangle that covers the entire screen:+#+# (-1,3)+# /|+# / | <- visible area is the unit square from (-1,-1) to (1,1)+# / | parts outside get clipped away+# (-1,-1)---(3,-1)+#+# v_texCoord is computed from clip space: * 0.5 + 0.5 maps (-1,1) -> (0,1)+VERTEX_SHADER = """#version 330 core+out vec2 v_texCoord;+void main() {+ vec2 verts[3] = vec2[](vec2(-1, -1), vec2(3, -1), vec2(-1, 3));+ v_texCoord = verts[gl_VertexID] * 0.5 + 0.5;+ gl_Position = vec4(verts[gl_VertexID], 0, 1);+}+"""++DEFAULT_FRAGMENT_SHADER = """#version 300 es+precision highp float;++uniform sampler2D u_image0;+uniform vec2 u_resolution;++in vec2 v_texCoord;+layout(location = 0) out vec4 fragColor0;++void main() {+ fragColor0 = texture(u_image0, v_texCoord);+}+"""+++def _convert_es_to_desktop(source: str) -> str:+ """Convert GLSL ES (WebGL) shader source to desktop GLSL 330 core."""+ # Remove any existing #version directive+ source = re.sub(r"#version\s+\d+(\s+es)?\s*\n?", "", source, flags=re.IGNORECASE)+ # Remove precision qualifiers (not needed in desktop GLSL)+ source = re.sub(r"precision\s+(lowp|mediump|highp)\s+\w+\s*;\s*\n?", "", source)+ # Prepend desktop GLSL version+ return "#version 330 core\n" + source+++def _detect_output_count(source: str) -> int:+ """Detect how many fragColor outputs are used in the shader.++ Returns the count of outputs needed (1 to MAX_OUTPUTS).+ """+ matches = re.findall(r"fragColor(\d+)", source)+ if not matches:+ return 1 # Default to 1 output if none found+ max_index = max(int(m) for m in matches)+ return min(max_index + 1, MAX_OUTPUTS)+++def _detect_pass_count(source: str) -> int:+ """Detect multi-pass rendering from #pragma passes N directive.++ Returns the number of passes (1 if not specified).+ """+ match = re.search(r'#pragma\s+passes\s+(\d+)', source)+ if match:+ return max(1, int(match.group(1)))+ return 1+++def _init_glfw():+ """Initialize GLFW. Returns (window, glfw_module). Raises RuntimeError on failure."""+ logger.debug("_init_glfw: starting")+ # On macOS, glfw.init() must be called from main thread or it hangs forever+ if sys.platform == "darwin":+ logger.debug("_init_glfw: skipping on macOS")+ raise RuntimeError("GLFW backend not supported on macOS")++ logger.debug("_init_glfw: importing glfw module")+ import glfw as _glfw++ logger.debug("_init_glfw: calling glfw.init()")+ if not _glfw.init():+ raise RuntimeError("glfw.init() failed")++ try:+ logger.debug("_init_glfw: setting window hints")+ _glfw.window_hint(_glfw.VISIBLE, _glfw.FALSE)+ _glfw.window_hint(_glfw.CONTEXT_VERSION_MAJOR, 3)+ _glfw.window_hint(_glfw.CONTEXT_VERSION_MINOR, 3)+ _glfw.window_hint(_glfw.OPENGL_PROFILE, _glfw.OPENGL_CORE_PROFILE)++ logger.debug("_init_glfw: calling create_window()")+ window = _glfw.create_window(64, 64, "ComfyUI GLSL", None, None)+ if not window:+ raise RuntimeError("glfw.create_window() failed")++ logger.debug("_init_glfw: calling make_context_current()")+ _glfw.make_context_current(window)+ logger.debug("_init_glfw: completed successfully")+ return window, _glfw+ except Exception:+ logger.debug("_init_glfw: failed, terminating glfw")+ _glfw.terminate()+ raise+++def _init_egl():+ """Initialize EGL for headless rendering. Returns (display, context, surface, EGL_module). Raises RuntimeError on failure."""+ logger.debug("_init_egl: starting")+ from OpenGL import EGL as _EGL+ from OpenGL.EGL import (+ eglGetDisplay, eglInitialize, eglChooseConfig, eglCreateContext,+ eglMakeCurrent, eglCreatePbufferSurface, eglBindAPI,+ eglTerminate, eglDestroyContext, eglDestroySurface,+ EGL_DEFAULT_DISPLAY, EGL_NO_CONTEXT, EGL_NONE,+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,+ EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, EGL_ALPHA_SIZE, EGL_DEPTH_SIZE,+ EGL_WIDTH, EGL_HEIGHT, EGL_OPENGL_API,+ )+ logger.debug("_init_egl: imports completed")++ display = None+ context = None+ surface = None++ try:+ logger.debug("_init_egl: calling eglGetDisplay()")+ display = eglGetDisplay(EGL_DEFAULT_DISPLAY)+ if display == _EGL.EGL_NO_DISPLAY:+ raise RuntimeError("eglGetDisplay() failed")++ logger.debug("_init_egl: calling eglInitialize()")+ major, minor = _EGL.EGLint(), _EGL.EGLint()+ if not eglInitialize(display, major, minor):+ display = None # Not initialized, don't terminate+ raise RuntimeError("eglInitialize() failed")+ logger.debug(f"_init_egl: EGL version {major.value}.{minor.value}")++ config_attribs = [+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,+ EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,+ EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8,+ EGL_DEPTH_SIZE, 0, EGL_NONE+ ]+ configs = (_EGL.EGLConfig * 1)()+ num_configs = _EGL.EGLint()+ if not eglChooseConfig(display, config_attribs, configs, 1, num_configs) or num_configs.value == 0:+ raise RuntimeError("eglChooseConfig() failed")+ config = configs[0]+ logger.debug(f"_init_egl: config chosen, num_configs={num_configs.value}")++ if not eglBindAPI(EGL_OPENGL_API):+ raise RuntimeError("eglBindAPI() failed")++ logger.debug("_init_egl: calling eglCreateContext()")+ context_attribs = [+ _EGL.EGL_CONTEXT_MAJOR_VERSION, 3,+ _EGL.EGL_CONTEXT_MINOR_VERSION, 3,+ _EGL.EGL_CONTEXT_OPENGL_PROFILE_MASK, _EGL.EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,+ EGL_NONE+ ]+ context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribs)+ if context == EGL_NO_CONTEXT:+ raise RuntimeError("eglCreateContext() failed")++ logger.debug("_init_egl: calling eglCreatePbufferSurface()")+ pbuffer_attribs = [EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE]+ surface = eglCreatePbufferSurface(display, config, pbuffer_attribs)+ if surface == _EGL.EGL_NO_SURFACE:+ raise RuntimeError("eglCreatePbufferSurface() failed")++ logger.debug("_init_egl: calling eglMakeCurrent()")+ if not eglMakeCurrent(display, surface, surface, context):+ raise RuntimeError("eglMakeCurrent() failed")++ logger.debug("_init_egl: completed successfully")+ return display, context, surface, _EGL++ except Exception:+ logger.debug("_init_egl: failed, cleaning up")+ # Clean up any resources on failure+ if surface is not None:+ eglDestroySurface(display, surface)+ if context is not None:+ eglDestroyContext(display, context)+ if display is not None:+ eglTerminate(display)+ raise+++def _init_osmesa():+ """Initialize OSMesa for software rendering. Returns (context, buffer). Raises RuntimeError on failure."""+ import ctypes++ logger.debug("_init_osmesa: starting")+ os.environ["PYOPENGL_PLATFORM"] = "osmesa"++ logger.debug("_init_osmesa: importing OpenGL.osmesa")+ from OpenGL import GL as _gl+ from OpenGL.osmesa import (+ OSMesaCreateContextExt, OSMesaMakeCurrent, OSMesaDestroyContext,+ OSMESA_RGBA,+ )+ logger.debug("_init_osmesa: imports completed")++ ctx = OSMesaCreateContextExt(OSMESA_RGBA, 24, 0, 0, None)+ if not ctx:+ raise RuntimeError("OSMesaCreateContextExt() failed")++ width, height = 64, 64+ buffer = (ctypes.c_ubyte * (width * height * 4))()++ logger.debug("_init_osmesa: calling OSMesaMakeCurrent()")+ if not OSMesaMakeCurrent(ctx, buffer, _gl.GL_UNSIGNED_BYTE, width, height):+ OSMesaDestroyContext(ctx)+ raise RuntimeError("OSMesaMakeCurrent() failed")++ logger.debug("_init_osmesa: completed successfully")+ return ctx, buffer+++class GLContext:+ """Manages OpenGL context and resources for shader execution.++ Tries backends in order: GLFW (desktop) → EGL (headless GPU) → OSMesa (software).+ """++ _instance = None+ _initialized = False++ def __new__(cls):+ if cls._instance is None:+ cls._instance = super().__new__(cls)+ return cls._instance++ def __init__(self):+ if GLContext._initialized:+ logger.debug("GLContext.__init__: already initialized, skipping")+ return++ logger.debug("GLContext.__init__: starting initialization")++ global glfw, EGL++ import time+ start = time.perf_counter()++ self._backend = None+ self._window = None+ self._egl_display = None+ self._egl_context = None+ self._egl_surface = None+ self._osmesa_ctx = None+ self._osmesa_buffer = None+ self._vao = None++ # Try backends in order: GLFW → EGL → OSMesa+ errors = []++ logger.debug("GLContext.__init__: trying GLFW backend")+ try:+ self._window, glfw = _init_glfw()+ self._backend = "glfw"+ logger.debug("GLContext.__init__: GLFW backend succeeded")+ except Exception as e:+ logger.debug(f"GLContext.__init__: GLFW backend failed: {e}")+ errors.append(("GLFW", e))++ if self._backend is None:+ logger.debug("GLContext.__init__: trying EGL backend")+ try:+ self._egl_display, self._egl_context, self._egl_surface, EGL = _init_egl()+ self._backend = "egl"+ logger.debug("GLContext.__init__: EGL backend succeeded")+ except Exception as e:+ logger.debug(f"GLContext.__init__: EGL backend failed: {e}")+ errors.append(("EGL", e))++ if self._backend is None:+ logger.debug("GLContext.__init__: trying OSMesa backend")+ try:+ self._osmesa_ctx, self._osmesa_buffer = _init_osmesa()+ self._backend = "osmesa"+ logger.debug("GLContext.__init__: OSMesa backend succeeded")+ except Exception as e:+ logger.debug(f"GLContext.__init__: OSMesa backend failed: {e}")+ errors.append(("OSMesa", e))++ if self._backend is None:+ if sys.platform == "win32":+ platform_help = (+ "Windows: Ensure GPU drivers are installed and display is available.\n"+ " CPU-only/headless mode is not supported on Windows."+ )+ elif sys.platform == "darwin":+ platform_help = (+ "macOS: GLFW is not supported.\n"+ " Install OSMesa via Homebrew: brew install mesa\n"+ " Then: pip install PyOpenGL PyOpenGL-accelerate"+ )+ else:+ platform_help = (+ "Linux: Install one of these backends:\n"+ " Desktop: sudo apt install libgl1-mesa-glx libglfw3\n"+ " Headless with GPU: sudo apt install libegl1-mesa libgl1-mesa-dri\n"+ " Headless (CPU): sudo apt install libosmesa6"+ )++ error_details = "\n".join(f" {name}: {err}" for name, err in errors)+ raise RuntimeError(+ f"Failed to create OpenGL context.\n\n"+ f"Backend errors:\n{error_details}\n\n"+ f"{platform_help}"+ )++ # Now import OpenGL.GL (after context is current)+ logger.debug("GLContext.__init__: importing OpenGL.GL")+ _import_opengl()++ # Create VAO (required for core profile, but OSMesa may use compat profile)+ logger.debug("GLContext.__init__: creating VAO")+ try:+ vao = gl.glGenVertexArrays(1)+ gl.glBindVertexArray(vao)+ self._vao = vao # Only store after successful bind+ logger.debug("GLContext.__init__: VAO created successfully")+ except Exception as e:+ logger.debug(f"GLContext.__init__: VAO creation failed (may be expected for OSMesa): {e}")+ # OSMesa with older Mesa may not support VAOs+ # Clean up if we created but couldn't bind+ if vao:+ try:+ gl.glDeleteVertexArrays(1, [vao])+ except Exception:+ pass++ elapsed = (time.perf_counter() - start) * 1000++ # Log device info+ renderer = gl.glGetString(gl.GL_RENDERER)+ vendor = gl.glGetString(gl.GL_VENDOR)+ version = gl.glGetString(gl.GL_VERSION)+ renderer = renderer.decode() if renderer else "Unknown"+ vendor = vendor.decode() if vendor else "Unknown"+ version = version.decode() if version else "Unknown"++ GLContext._initialized = True+ logger.info(f"GLSL context initialized in {elapsed:.1f}ms ({self._backend}) - {renderer} ({vendor}), GL {version}")++ def make_current(self):+ if self._backend == "glfw":+ glfw.make_context_current(self._window)+ elif self._backend == "egl":+ from OpenGL.EGL import eglMakeCurrent+ eglMakeCurrent(self._egl_display, self._egl_surface, self._egl_surface, self._egl_context)+ elif self._backend == "osmesa":+ from OpenGL.osmesa import OSMesaMakeCurrent+ OSMesaMakeCurrent(self._osmesa_ctx, self._osmesa_buffer, gl.GL_UNSIGNED_BYTE, 64, 64)++ if self._vao is not None:+ gl.glBindVertexArray(self._vao)+++def _compile_shader(source: str, shader_type: int) -> int:+ """Compile a shader and return its ID."""+ shader = gl.glCreateShader(shader_type)+ gl.glShaderSource(shader, source)+ gl.glCompileShader(shader)++ if gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) != gl.GL_TRUE:+ error = gl.glGetShaderInfoLog(shader).decode()+ gl.glDeleteShader(shader)+ raise RuntimeError(f"Shader compilation failed:\n{error}")++ return shader+++def _create_program(vertex_source: str, fragment_source: str) -> int:+ """Create and link a shader program."""+ vertex_shader = _compile_shader(vertex_source, gl.GL_VERTEX_SHADER)+ try:+ fragment_shader = _compile_shader(fragment_source, gl.GL_FRAGMENT_SHADER)+ except RuntimeError:+ gl.glDeleteShader(vertex_shader)+ raise++ program = gl.glCreateProgram()+ gl.glAttachShader(program, vertex_shader)+ gl.glAttachShader(program, fragment_shader)+ gl.glLinkProgram(program)++ gl.glDeleteShader(vertex_shader)+ gl.glDeleteShader(fragment_shader)++ if gl.glGetProgramiv(program, gl.GL_LINK_STATUS) != gl.GL_TRUE:+ error = gl.glGetProgramInfoLog(program).decode()+ gl.glDeleteProgram(program)+ raise RuntimeError(f"Program linking failed:\n{error}")++ return program+++def _render_shader_batch(+ fragment_code: str,+ width: int,+ height: int,+ image_batches: list[list[np.ndarray]],+ floats: list[float],+ ints: list[int],+) -> list[list[np.ndarray]]:+ """+ Render a fragment shader for multiple batches efficiently.++ Compiles shader once, reuses framebuffer/textures across batches.+ Supports multi-pass rendering via #pragma passes N directive.++ Args:+ fragment_code: User's fragment shader code+ width: Output width+ height: Output height+ image_batches: List of batches, each batch is a list of input images (H, W, C) float32 [0,1]+ floats: List of float uniforms+ ints: List of int uniforms++ Returns:+ List of batch outputs, each is a list of output images (H, W, 4) float32 [0,1]+ """+ import time+ start_time = time.perf_counter()++ if not image_batches:+ return []++ ctx = GLContext()+ ctx.make_current()++ # Convert from GLSL ES to desktop GLSL 330+ fragment_source = _convert_es_to_desktop(fragment_code)++ # Detect how many outputs the shader actually uses+ num_outputs = _detect_output_count(fragment_code)++ # Detect multi-pass rendering+ num_passes = _detect_pass_count(fragment_code)++ # Track resources for cleanup+ program = None+ fbo = None+ output_textures = []+ input_textures = []+ ping_pong_textures = []+ ping_pong_fbos = []++ num_inputs = len(image_batches[0])++ try:+ # Compile shaders (once for all batches)+ try:+ program = _create_program(VERTEX_SHADER, fragment_source)+ except RuntimeError:+ logger.error(f"Fragment shader:\n{fragment_source}")+ raise++ gl.glUseProgram(program)++ # Create framebuffer with only the needed color attachments+ fbo = gl.glGenFramebuffers(1)+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)++ draw_buffers = []+ for i in range(num_outputs):+ tex = gl.glGenTextures(1)+ output_textures.append(tex)+ gl.glBindTexture(gl.GL_TEXTURE_2D, tex)+ gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, width, height, 0, gl.GL_RGBA, gl.GL_FLOAT, None)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)+ gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0 + i, gl.GL_TEXTURE_2D, tex, 0)+ draw_buffers.append(gl.GL_COLOR_ATTACHMENT0 + i)++ gl.glDrawBuffers(num_outputs, draw_buffers)++ if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:+ raise RuntimeError("Framebuffer is not complete")++ # Create ping-pong resources for multi-pass rendering+ if num_passes > 1:+ for _ in range(2):+ pp_tex = gl.glGenTextures(1)+ ping_pong_textures.append(pp_tex)+ gl.glBindTexture(gl.GL_TEXTURE_2D, pp_tex)+ gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, width, height, 0, gl.GL_RGBA, gl.GL_FLOAT, None)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)++ pp_fbo = gl.glGenFramebuffers(1)+ ping_pong_fbos.append(pp_fbo)+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, pp_fbo)+ gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, pp_tex, 0)+ gl.glDrawBuffers(1, [gl.GL_COLOR_ATTACHMENT0])++ if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE:+ raise RuntimeError("Ping-pong framebuffer is not complete")++ # Create input textures (reused for all batches)+ for i in range(num_inputs):+ tex = gl.glGenTextures(1)+ input_textures.append(tex)+ gl.glActiveTexture(gl.GL_TEXTURE0 + i)+ gl.glBindTexture(gl.GL_TEXTURE_2D, tex)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)+ gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)++ loc = gl.glGetUniformLocation(program, f"u_image{i}")+ if loc >= 0:+ gl.glUniform1i(loc, i)++ # Set static uniforms (once for all batches)+ loc = gl.glGetUniformLocation(program, "u_resolution")+ if loc >= 0:+ gl.glUniform2f(loc, float(width), float(height))++ for i, v in enumerate(floats):+ loc = gl.glGetUniformLocation(program, f"u_float{i}")+ if loc >= 0:+ gl.glUniform1f(loc, v)++ for i, v in enumerate(ints):+ loc = gl.glGetUniformLocation(program, f"u_int{i}")+ if loc >= 0:+ gl.glUniform1i(loc, v)++ # Get u_pass uniform location for multi-pass+ pass_loc = gl.glGetUniformLocation(program, "u_pass")++ gl.glViewport(0, 0, width, height)+ gl.glDisable(gl.GL_BLEND) # Ensure no alpha blending - write output directly++ # Process each batch+ all_batch_outputs = []+ for images in image_batches:+ # Update input textures with this batch's images+ for i, img in enumerate(images):+ gl.glActiveTexture(gl.GL_TEXTURE0 + i)+ gl.glBindTexture(gl.GL_TEXTURE_2D, input_textures[i])++ # Flip vertically for GL coordinates, ensure RGBA+ h, w, c = img.shape+ if c == 3:+ img_upload = np.empty((h, w, 4), dtype=np.float32)+ img_upload[:, :, :3] = img[::-1, :, :]+ img_upload[:, :, 3] = 1.0+ else:+ img_upload = np.ascontiguousarray(img[::-1, :, :])++ gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA32F, w, h, 0, gl.GL_RGBA, gl.GL_FLOAT, img_upload)++ if num_passes == 1:+ # Single pass - render directly to output FBO+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)+ if pass_loc >= 0:+ gl.glUniform1i(pass_loc, 0)+ gl.glClearColor(0, 0, 0, 0)+ gl.glClear(gl.GL_COLOR_BUFFER_BIT)+ gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)+ else:+ # Multi-pass rendering with ping-pong+ for p in range(num_passes):+ is_last_pass = (p == num_passes - 1)++ # Set pass uniform+ if pass_loc >= 0:+ gl.glUniform1i(pass_loc, p)++ if is_last_pass:+ # Last pass renders to the main output FBO+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)+ else:+ # Intermediate passes render to ping-pong FBO+ target_fbo = ping_pong_fbos[p % 2]+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, target_fbo)++ # Set input texture for this pass+ gl.glActiveTexture(gl.GL_TEXTURE0)+ if p == 0:+ # First pass reads from original input+ gl.glBindTexture(gl.GL_TEXTURE_2D, input_textures[0])+ else:+ # Subsequent passes read from previous pass output+ source_tex = ping_pong_textures[(p - 1) % 2]+ gl.glBindTexture(gl.GL_TEXTURE_2D, source_tex)++ gl.glClearColor(0, 0, 0, 0)+ gl.glClear(gl.GL_COLOR_BUFFER_BIT)+ gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)++ # Read back outputs for this batch+ # (glGetTexImage is synchronous, implicitly waits for rendering)+ batch_outputs = []+ for tex in output_textures:+ gl.glBindTexture(gl.GL_TEXTURE_2D, tex)+ data = gl.glGetTexImage(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, gl.GL_FLOAT)+ img = np.frombuffer(data, dtype=np.float32).reshape(height, width, 4)+ batch_outputs.append(img[::-1, :, :].copy())++ # Pad with black images for unused outputs+ black_img = np.zeros((height, width, 4), dtype=np.float32)+ for _ in range(num_outputs, MAX_OUTPUTS):+ batch_outputs.append(black_img)++ all_batch_outputs.append(batch_outputs)++ elapsed = (time.perf_counter() - start_time) * 1000+ num_batches = len(image_batches)+ pass_info = f", {num_passes} passes" if num_passes > 1 else ""+ logger.info(f"GLSL shader executed in {elapsed:.1f}ms ({num_batches} batch{'es' if num_batches != 1 else ''}, {width}x{height}{pass_info})")++ return all_batch_outputs++ finally:+ # Unbind before deleting+ gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)+ gl.glUseProgram(0)++ if input_textures:+ gl.glDeleteTextures(len(input_textures), input_textures)+ if output_textures:+ gl.glDeleteTextures(len(output_textures), output_textures)+ if ping_pong_textures:+ gl.glDeleteTextures(len(ping_pong_textures), ping_pong_textures)+ if fbo is not None:+ gl.glDeleteFramebuffers(1, [fbo])+ for pp_fbo in ping_pong_fbos:+ gl.glDeleteFramebuffers(1, [pp_fbo])+ if program is not None:+ gl.glDeleteProgram(program)++class GLSLShader(io.ComfyNode):++ @classmethod+ def define_schema(cls) -> io.Schema:+ image_template = io.Autogrow.TemplatePrefix(+ io.Image.Input("image"),+ prefix="image",+ min=1,+ max=MAX_IMAGES,+ )++ float_template = io.Autogrow.TemplatePrefix(+ io.Float.Input("float", default=0.0),+ prefix="u_float",+ min=0,+ max=MAX_UNIFORMS,+ )++ int_template = io.Autogrow.TemplatePrefix(+ io.Int.Input("int", default=0),+ prefix="u_int",+ min=0,+ max=MAX_UNIFORMS,+ )++ return io.Schema(+ node_id="GLSLShader",+ display_name="GLSL Shader",+ category="image/shader",+ description=(+ "Apply GLSL ES fragment shaders to images. "+ "u_resolution (vec2) is always available."+ ),+ inputs=[+ io.String.Input(+ "fragment_shader",+ default=DEFAULT_FRAGMENT_SHADER,+ multiline=True,+ tooltip="GLSL fragment shader source code (GLSL ES 3.00 / WebGL 2.0 compatible)",+ ),+ io.DynamicCombo.Input(+ "size_mode",+ options=[+ io.DynamicCombo.Option("from_input", []),+ io.DynamicCombo.Option(+ "custom",+ [+ io.Int.Input(+ "width",+ default=512,+ min=1,+ max=nodes.MAX_RESOLUTION,+ ),+ io.Int.Input(+ "height",+ default=512,+ min=1,+ max=nodes.MAX_RESOLUTION,+ ),+ ],+ ),+ ],+ tooltip="Output size: 'from_input' uses first input image dimensions, 'custom' allows manual size",+ ),+ io.Autogrow.Input("images", template=image_template, tooltip=f"Images are available as u_image0-{MAX_IMAGES-1} (sampler2D) in the shader code"),+ io.Autogrow.Input("floats", template=float_template, tooltip=f"Floats are available as u_float0-{MAX_UNIFORMS-1} in the shader code"),+ io.Autogrow.Input("ints", template=int_template, tooltip=f"Ints are available as u_int0-{MAX_UNIFORMS-1} in the shader code"),+ ],+ outputs=[+ io.Image.Output(display_name="IMAGE0", tooltip="Available via layout(location = 0) out vec4 fragColor0 in the shader code"),+ io.Image.Output(display_name="IMAGE1", tooltip="Available via layout(location = 1) out vec4 fragColor1 in the shader code"),+ io.Image.Output(display_name="IMAGE2", tooltip="Available via layout(location = 2) out vec4 fragColor2 in the shader code"),+ io.Image.Output(display_name="IMAGE3", tooltip="Available via layout(location = 3) out vec4 fragColor3 in the shader code"),+ ],+ )++ @classmethod+ def execute(+ cls,+ fragment_shader: str,+ size_mode: SizeModeInput,+ images: io.Autogrow.Type,+ floats: io.Autogrow.Type = None,+ ints: io.Autogrow.Type = None,+ **kwargs,+ ) -> io.NodeOutput:+ image_list = [v for v in images.values() if v is not None]+ float_list = (+ [v if v is not None else 0.0 for v in floats.values()] if floats else []+ )+ int_list = [v if v is not None else 0 for v in ints.values()] if ints else []++ if not image_list:+ raise ValueError("At least one input image is required")++ # Determine output dimensions+ if size_mode["size_mode"] == "custom":+ out_width = size_mode["width"]+ out_height = size_mode["height"]+ else:+ out_height, out_width = image_list[0].shape[1:3]++ batch_size = image_list[0].shape[0]++ # Prepare batches+ image_batches = []+ for batch_idx in range(batch_size):+ batch_images = [img_tensor[batch_idx].cpu().numpy().astype(np.float32) for img_tensor in image_list]+ image_batches.append(batch_images)++ all_batch_outputs = _render_shader_batch(+ fragment_shader,+ out_width,+ out_height,+ image_batches,+ float_list,+ int_list,+ )++ # Collect outputs into tensors+ all_outputs = [[] for _ in range(MAX_OUTPUTS)]+ for batch_outputs in all_batch_outputs:+ for i, out_img in enumerate(batch_outputs):+ all_outputs[i].append(torch.from_numpy(out_img))++ output_tensors = [torch.stack(all_outputs[i], dim=0) for i in range(MAX_OUTPUTS)]+ return io.NodeOutput(+ *output_tensors,+ ui=cls._build_ui_output(image_list, output_tensors[0]),+ )++ @classmethod+ def _build_ui_output(+ cls, image_list: list[torch.Tensor], output_batch: torch.Tensor+ ) -> dict[str, list]:+ """Build UI output with input and output images for client-side shader execution."""+ combined_inputs = torch.cat(image_list, dim=0)+ input_images_ui = ui.ImageSaveHelper.save_images(+ combined_inputs,+ filename_prefix="GLSLShader_input",+ folder_type=io.FolderType.temp,+ cls=None,+ compress_level=1,+ )++ output_images_ui = ui.ImageSaveHelper.save_images(+ output_batch,+ filename_prefix="GLSLShader_output",+ folder_type=io.FolderType.temp,+ cls=None,+ compress_level=1,+ )++ return {"input_images": input_images_ui, "images": output_images_ui}+++class GLSLExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[io.ComfyNode]]:+ return [GLSLShader]+++async def comfy_entrypoint() -> GLSLExtension:+ return GLSLExtension()diff --git a/nodes.py b/nodes.pyindex 160a30928..500d53213 100644--- a/nodes.py+++ b/nodes.py@@ -2442,6 +2442,7 @@ async def init_builtin_extra_nodes():"nodes_wanmove.py","nodes_image_compare.py","nodes_zimage.py",+ "nodes_glsl.py","nodes_lora_debug.py","nodes_textgen.py","nodes_color.py",diff --git a/requirements.txt b/requirements.txtindex 807fea5e0..3a9bfde46 100644--- a/requirements.txt+++ b/requirements.txt@@ -30,3 +30,6 @@ kornia>=0.7.1spandrelpydantic~=2.0pydantic-settings~=2.0+PyOpenGL+PyOpenGL-accelerate+glfw