/* * Iridium Shader Lab - GLSL Export * * Note: uPalette is a 1D canvas texture containing the color stops. * You will need to generate a 512x1 texture from these colors: * [#32f5e5, #8ea0f5, #ff8ace, #fff200] * * --- Uniform Values / Preset Settings --- * scale: 2 * speed: 0.5 * distortion: 1.5 * bevelSize: 0.005 * bevelSmoothness: 0.9 * lightIntensity: 1.5 * specular: 32 * backgroundColor: #ffffff * animate: true * meshScale: 0.7 * loop: false * loopDuration: 10 * shapeConfinement: false * confinementIntensity: 1 * overlayBlinds: false * blindsDensity: 20 * blindsAngle: 0 * overlayDrips: false * dripsIntensity: 0.5 * overlaySmear: false * smearIntensity: 0.5 * overlayPixelate: false * pixelateSize: 10 * overlayRipple: false * rippleIntensity: 0.5 * enableFramerStyle: false * enableHybridStyle: false * framerTurbAmp: 0.21 * framerTurbFreq: 1.15 * framerTurbIter: 5 * framerWaveFreq: 2.4 * framerBend: 0.24 * framerContour: 0.8 * framerAngle: 20 * enableCrystalStyle: true * crystalRefraction: 1 * crystalSeed: 6 * crystalSpeed: 2.1 * crystalMotion: sweep * crystalAngle: 20 * crystalScale: 0.64 * crystalAmplitude: 0.6 * crystalFrequency: 0.79 * crystalDefinition: 10 * crystalBands: 2.1 * crystalGloss: 0.36 * crystalSmoothing: 0.35 * crystalColorFlow: 1 * crystalWordmarkMode: true * crystalWordmarkBoost: 1 * prismaticBevelEnabled: false * prismaticBevelIntensity: 1 * frostedGlassEnabled: false * frostedGlassIntensity: 0.5 * noiseOverlayEnabled: false * noiseOverlayIntensity: 0.3 * bloomEnabled: false * bloomIntensity: 1.5 * bloomLuminanceThreshold: 0.2 * bloomLuminanceSmoothing: 0.9 */ // --- Vertex Shader --- // varying vec2 vUv; void main() { vec4 mvPosition = modelViewMatrix * vec4(position, 1.0); gl_Position = projectionMatrix * mvPosition; vUv = uv; } // --- Fragment Shader --- // uniform float uTime; uniform float uScale; uniform float uDistortion; uniform float uSpeed; uniform float uBevelSize; uniform float uBevelSmoothness; uniform float uLightIntensity; uniform float uSpecular; uniform sampler2D uPalette; uniform sampler2D uMask; uniform vec2 uTexResolution; // Width, Height uniform vec2 uObjectResolution; // Rendered preview width, height in CSS pixels // New Effect Uniforms uniform bool uPrismaticBevelEnabled; uniform float uPrismaticBevelIntensity; uniform bool uFrostedGlassEnabled; uniform float uFrostedGlassIntensity; uniform bool uNoiseOverlayEnabled; uniform float uNoiseOverlayIntensity; uniform bool uLoop; uniform float uLoopDuration; uniform bool uShapeConfinement; uniform float uConfinementIntensity; uniform bool uOverlayBlinds; uniform float uBlindsDensity; uniform float uBlindsAngle; uniform bool uOverlayDrips; uniform float uDripsIntensity; uniform bool uOverlaySmear; uniform float uSmearIntensity; uniform bool uOverlayPixelate; uniform float uPixelateSize; uniform bool uOverlayRipple; uniform float uRippleIntensity; uniform bool uEnableFramerStyle; uniform bool uEnableHybridStyle; uniform float uFramerTurbAmp; uniform float uFramerTurbFreq; uniform float uFramerTurbIter; uniform float uFramerWaveFreq; uniform float uFramerBend; uniform float uFramerContour; uniform float uFramerAngle; uniform bool uEnableCrystalStyle; uniform float uCrystalRefraction; uniform float uCrystalSeed; uniform float uCrystalSpeed; uniform float uCrystalMotion; uniform float uCrystalAngle; uniform float uCrystalScale; uniform float uCrystalAmplitude; uniform float uCrystalFrequency; uniform float uCrystalDefinition; uniform float uCrystalBands; uniform float uCrystalGloss; uniform float uCrystalSmoothing; uniform float uCrystalColorFlow; uniform bool uCrystalWordmarkMode; uniform float uCrystalWordmarkBoost; varying vec2 vUv; // Simplex 2D noise vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; } vec3 permute(vec3 x) { return mod289(((x*34.0)+10.0)*x); } float snoise(vec2 v) { const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); vec2 i = floor(v + dot(v, C.yy) ); vec2 x0 = v - i + dot(i, C.xx); vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); vec4 x12 = x0.xyxy + C.xxzz; x12.xy -= i1; i = mod289(i); vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0 )); vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); m = m*m; m = m*m; vec3 x = 2.0 * fract(p * C.www) - 1.0; vec3 h = abs(x) - 0.5; vec3 ox = floor(x + 0.5); vec3 a0 = x - ox; m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); vec3 g; g.x = a0.x * x0.x + h.x * x0.y; g.yz = a0.yz * x12.xz + h.yz * x12.yw; return 130.0 * dot(m, g); } // Distance estimator for Chiseled/Prismatic Bevel (Octagonal Raymarch) float getShapeDist(vec2 uv, float maxRadius) { vec4 centerMask = texture2D(uMask, uv); float centerEncoded = 1.0 - smoothstep(0.03, 0.18, abs(centerMask.g - (1.0 - centerMask.a))); float centerSolid = mix(centerMask.a, centerMask.b, centerEncoded); if (centerSolid < 0.5) return 0.0; float minDist = maxRadius; float aspect = uTexResolution.x / max(1.0, uTexResolution.y); for(int i = 0; i < 8; i++) { float angle = float(i) * 0.78539816; // PI / 4 vec2 dir = vec2(cos(angle), sin(angle)); dir.x /= aspect; // Correct for texture aspect ratio float dist = maxRadius; float prevA = centerSolid; for(int j = 1; j <= 20; j++) { float r = maxRadius * (float(j) / 20.0); vec4 sampleMask = texture2D(uMask, uv + dir * r); float sampleEncoded = 1.0 - smoothstep(0.03, 0.18, abs(sampleMask.g - (1.0 - sampleMask.a))); float a = mix(sampleMask.a, sampleMask.b, sampleEncoded); if(a < 0.5) { float prevR = maxRadius * (float(j - 1) / 20.0); float fraction = (0.5 - prevA) / (a - prevA + 0.00001); dist = mix(prevR, r, clamp(fraction, 0.0, 1.0)); break; } prevA = a; } minDist = min(minDist, dist); } return minDist; } // Edge detection for inner bevel float getBevelDist(vec2 uv, float spread) { if(spread <= 0.0) return 1.0; float count = texture2D(uMask, uv + vec2(spread, 0.0)).a; count += texture2D(uMask, uv + vec2(-spread, 0.0)).a; count += texture2D(uMask, uv + vec2(0.0, spread)).a; count += texture2D(uMask, uv + vec2(0.0, -spread)).a; count += texture2D(uMask, uv + vec2(spread, spread) * 0.707).a; count += texture2D(uMask, uv + vec2(-spread, spread) * 0.707).a; count += texture2D(uMask, uv + vec2(spread, -spread) * 0.707).a; count += texture2D(uMask, uv + vec2(-spread, -spread) * 0.707).a; return count / 8.0; } float maskEncoding(vec4 maskSample) { return 1.0 - smoothstep(0.03, 0.18, abs(maskSample.g - (1.0 - maskSample.a))); } float maskHardField(vec4 maskSample) { float encoded = maskEncoding(maskSample); return mix(maskSample.a, maskSample.b, encoded); } float maskOriginalAlpha(vec4 maskSample) { float encoded = maskEncoding(maskSample); return clamp(mix(maskSample.a, 1.0 - maskSample.g, encoded), 0.0, 1.0); } float maskOpacity(vec2 uv) { vec4 maskSample = texture2D(uMask, uv); float encoded = maskEncoding(maskSample); float originalAlpha = maskOriginalAlpha(maskSample); return mix(maskSample.a, originalAlpha, encoded); } float maskDepth(vec2 uv) { vec4 maskSample = texture2D(uMask, uv); float encoded = maskEncoding(maskSample); return clamp(mix(maskSample.a, maskSample.r, encoded), 0.0, 1.0); } float blurDepth3x3(vec2 uv, float radius) { vec2 texel = 1.0 / max(uTexResolution, vec2(1.0)); vec2 r = max(radius, 0.0) * texel; float sum = 4.0 * maskDepth(uv); sum += 2.0 * maskDepth(uv + vec2(0.0, -r.y)); sum += 2.0 * maskDepth(uv + vec2(0.0, r.y)); sum += 2.0 * maskDepth(uv + vec2(-r.x, 0.0)); sum += 2.0 * maskDepth(uv + vec2(r.x, 0.0)); sum += maskDepth(uv + vec2(-r.x, -r.y)); sum += maskDepth(uv + vec2(r.x, -r.y)); sum += maskDepth(uv + vec2(-r.x, r.y)); sum += maskDepth(uv + vec2(r.x, r.y)); return sum / 16.0; } float textureRadiusForScreen(float screenRadius) { vec2 texelsPerScreen = uTexResolution / max(uObjectResolution, vec2(1.0)); float ratio = max(1.0, min(texelsPerScreen.x, texelsPerScreen.y)); return clamp(screenRadius * ratio, 2.0, 48.0); } vec2 heightGrad(vec2 uv, float blurRadius, float sampleRadius) { vec2 texel = 1.0 / max(uTexResolution, vec2(1.0)); float eps = max(sampleRadius, 1.0); float dR = blurDepth3x3(uv + vec2(eps * texel.x, 0.0), blurRadius); float dL = blurDepth3x3(uv - vec2(eps * texel.x, 0.0), blurRadius); float dU = blurDepth3x3(uv + vec2(0.0, eps * texel.y), blurRadius); float dD = blurDepth3x3(uv - vec2(0.0, eps * texel.y), blurRadius); return vec2( (dR - dL) / max(2.0 * eps * texel.x, 0.00001), (dU - dD) / max(2.0 * eps * texel.y, 0.00001) ); } float wordmarkDepth(vec2 uv, float depth, vec2 inwardDir, float edgeBlurPixels, float strength) { if (strength <= 0.001 || length(inwardDir) < 0.5) return depth; vec2 texel = 1.0 / max(uTexResolution, vec2(1.0)); float probePixels = textureRadiusForScreen(mix(7.0, 13.0, clamp(uCrystalGloss, 0.0, 1.0))); vec2 probe = inwardDir * probePixels * texel; float localMax = depth; localMax = max(localMax, blurDepth3x3(uv + probe * 0.75, edgeBlurPixels)); localMax = max(localMax, blurDepth3x3(uv + probe * 1.5, edgeBlurPixels)); localMax = max(localMax, blurDepth3x3(uv + probe * 2.25, edgeBlurPixels)); float normalized = clamp(depth / max(localMax, 0.16), 0.0, 1.0); normalized = normalized * normalized * (3.0 - 2.0 * normalized); return mix(depth, normalized, strength); } float vesselWallInfluence(float depth, float gradientLength) { float wall = 1.0 - smoothstep(0.06, 0.52, depth); return wall * smoothstep(0.001, 0.04, gradientLength); } vec3 paletteColor(float value) { return texture2D(uPalette, vec2(fract(value), 0.5)).rgb; } vec3 paletteColorClamped(float value) { return texture2D(uPalette, vec2(clamp(value, 0.0, 1.0), 0.5)).rgb; } vec3 paletteColorAA(float value) { float width = clamp(fwidth(value) * 0.75, 0.0008, 0.055); vec3 color = paletteColor(value) * 0.5; color += paletteColor(value - width) * 0.25; color += paletteColor(value + width) * 0.25; return color; } vec3 palettePreservingBoost(vec3 color, float amount) { float peak = max(max(color.r, color.g), color.b); vec3 huePeak = color / max(peak, 0.001); return mix(color, huePeak, clamp(amount, 0.0, 1.0)); } vec3 palettePreservingShade(vec3 color, float shade, float boost) { color *= clamp(shade, 0.0, 2.0); return palettePreservingBoost(color, boost); } float crystalHash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); } float crystalValueNoise(vec2 p) { vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f); float a = crystalHash(i); float b = crystalHash(i + vec2(1.0, 0.0)); float c = crystalHash(i + vec2(0.0, 1.0)); float d = crystalHash(i + vec2(1.0, 1.0)); return mix(mix(a, b, f.x), mix(c, d, f.x), f.y); } float crystalAAStep(float edge, float value) { float smoothing = clamp(uCrystalSmoothing, 0.0, 1.0); float width = clamp(fwidth(value) * mix(1.35, 4.5, smoothing), 0.001, mix(0.08, 0.2, smoothing)); return smoothstep(edge - width, edge + width, value); } float crystalFbm(vec2 p, float t) { float gloss = clamp(uCrystalGloss, 0.0, 1.0); float value = 0.0; float weight = 0.5; float norm = 0.0; float freq = 1.0; vec2 seed = vec2(uCrystalSeed * 17.13, uCrystalSeed * 31.71); mat2 rot = mat2(0.8, 0.6, -0.6, 0.8); for (int i = 0; i < 10; i++) { if (float(i) >= uCrystalDefinition) break; vec2 drift = vec2(t * 0.07, -t * 0.053) * (1.0 + float(i) * 0.13); value += weight * crystalValueNoise(p * freq + seed + drift); norm += weight; p = rot * p; freq *= max(uCrystalFrequency, 1.001); weight *= mix(0.58, 0.48, gloss); } return value / max(norm, 0.0001); } vec2 crystalWarp(vec2 p, float t) { vec2 seed = vec2(uCrystalSeed * 9.7, uCrystalSeed * 14.3); float x = crystalValueNoise(p * 1.37 + seed + vec2(t * 0.10, 0.0)); x += 0.5 * crystalValueNoise(p * 2.71 + seed.yx + vec2(-t * 0.06, t * 0.04)); float y = crystalValueNoise(p * 1.23 + seed.yx + vec2(0.0, -t * 0.13)); y += 0.5 * crystalValueNoise(p * 2.43 + seed + vec2(t * 0.05, t * 0.08)); return vec2(x, y) / 1.5 - 0.5; } vec3 paletteColorFlow(float value, vec2 coord, float t) { float flow = clamp(uCrystalColorFlow, 0.0, 1.0); vec3 base = paletteColorAA(value); if (flow <= 0.001) return base; vec2 seed = vec2(uCrystalSeed * 5.91, uCrystalSeed * 11.17); float flowStrength = flow * flow * (3.0 - 2.0 * flow); float broad = snoise(coord * mix(1.7, 3.2, flow) + seed + vec2(t * 0.036, -t * 0.023)); float detail = snoise(coord * mix(4.4, 8.0, flow) + seed.yx + vec2(-t * 0.061, t * 0.042)); float softNoise = crystalValueNoise(coord * mix(2.1, 4.6, flow) + seed * 0.41 + vec2(t * 0.025, t * 0.018)); float drift = broad * 0.58 + detail * 0.24 + (softNoise - 0.5) * 0.36; float radius = mix(0.0, 0.34, flowStrength); float blurRadius = mix(0.0, 0.18, flowStrength); float flowedValue = value + drift * radius; vec3 displaced = paletteColorAA(flowedValue); vec3 softened = ( paletteColorAA(flowedValue - blurRadius) * 0.16 + paletteColorAA(flowedValue - blurRadius * 0.45) * 0.18 + displaced * 0.32 + paletteColorAA(flowedValue + blurRadius * 0.45) * 0.18 + paletteColorAA(flowedValue + blurRadius) * 0.16 ); vec3 lateral = mix( paletteColorAA(value + broad * radius * 0.62), paletteColorAA(value - detail * radius * 0.52), softNoise ); vec3 flowing = mix(displaced, softened, flowStrength * 0.55); flowing = mix(flowing, lateral, flowStrength * 0.34); return clamp(mix(base, flowing, flowStrength), 0.0, 1.0); } vec3 crystalField(vec2 uv, float t) { float gloss = clamp(uCrystalGloss, 0.0, 1.0); float smoothing = clamp(uCrystalSmoothing, 0.0, 1.0); float amplitude = clamp(uCrystalAmplitude, 0.0, 1.0); float angle = uCrystalAngle * 3.14159265 / 180.0; vec2 dir = vec2(cos(angle), sin(angle)); float motionTime = t * uCrystalSpeed; vec2 centered = uv - 0.5; float sweepPhase = (uCrystalMotion < 1.5 && uCrystalMotion > 0.5) ? motionTime * 0.05 : 0.0; float rotAngle = angle + sweepPhase; float cs = cos(rotAngle); float sn = sin(rotAngle); centered = mat2(cs, -sn, sn, cs) * centered; vec2 p = centered / max(uCrystalScale, 0.001) + 0.5; vec2 seed = vec2(uCrystalSeed * 13.7, uCrystalSeed * 29.3); vec2 warpCoord = p * max(uCrystalFrequency, 0.5) + seed; if (uCrystalMotion < 0.5) { p += crystalWarp(warpCoord, motionTime) * amplitude * mix(0.36, 0.24, smoothing); } else if (uCrystalMotion < 1.5) { p += dir * motionTime * 0.06; p += crystalWarp(warpCoord, motionTime) * amplitude * 0.18; } else if (uCrystalMotion < 2.5) { p += vec2(motionTime * 0.08, -motionTime * 0.055); p += crystalWarp(warpCoord, motionTime) * amplitude * 0.22; } else { p += crystalWarp(warpCoord, motionTime) * amplitude * 0.1; } float broad = crystalValueNoise(p * mix(0.85, 0.55, smoothing) + seed * 0.17); float cloud = crystalFbm(p * mix(1.05, 0.68, smoothing), motionTime); float sweep = 0.5 + 0.5 * sin(dot(p, dir) * max(uCrystalBands, 0.1) * mix(2.0, 1.25, smoothing) + cloud * 2.2 + motionTime * 0.22); float field = mix(broad, cloud, 0.42); field = mix(field, sweep, mix(0.26, 0.12, smoothing)); field += (crystalHash(gl_FragCoord.xy + seed) - 0.5) * gloss * smoothing * 0.006; field = smoothstep(mix(-0.08, -0.02, gloss), mix(1.08, 1.02, gloss), field); vec3 color = paletteColorFlow(field, p, motionTime); float localContrast = mix(0.92, mix(1.18, 1.05, smoothing), gloss); color = (color - 0.5) * localContrast + 0.5; color *= mix(0.9, 1.08, smoothstep(0.12, 1.0, field)); return clamp(color, 0.0, 1.0); } vec3 crystalRefract(vec2 uv, float t) { float gloss = clamp(uCrystalGloss, 0.0, 1.0); float smoothing = clamp(uCrystalSmoothing, 0.0, 1.0); float wordmark = uCrystalWordmarkMode ? clamp(uCrystalWordmarkBoost, 0.0, 1.0) : 0.0; float aspect = uTexResolution.x / max(1.0, uTexResolution.y); float fieldAspect = mix(1.0, min(max(aspect, 1.0), 1.75), 0.72); vec2 fieldUv = vec2((uv.x - 0.5) * fieldAspect + 0.5, 1.0 - uv.y); vec2 aspectComp = vec2(1.0 / max(fieldAspect, 0.0001), 1.0); float edgeBlurPixels = textureRadiusForScreen(mix(mix(3.5, 6.0, gloss), mix(1.8, 3.2, gloss), wordmark)); float gradBlurPixels = textureRadiusForScreen(mix(mix(5.5, 8.5, gloss), mix(3.0, 5.0, gloss), wordmark)); float gradSamplePixels = textureRadiusForScreen(mix(mix(7.0, 10.0, gloss), mix(4.5, 7.0, gloss), wordmark)); float sourceDepth = max(blurDepth3x3(uv, edgeBlurPixels), 0.001); vec2 grad = heightGrad(uv, gradBlurPixels, gradSamplePixels); float gradRaw = length(grad); float gradMag = min(gradRaw, 5.0); vec2 refractDir = gradRaw > 0.001 ? grad * min(1.0, 5.0 / gradRaw) : vec2(0.0); vec2 outwardDir = gradRaw > 0.001 ? -grad / gradRaw : vec2(0.0); vec2 inwardDir = gradRaw > 0.001 ? grad / gradRaw : vec2(0.0); float depth = wordmarkDepth(uv, sourceDepth, inwardDir, edgeBlurPixels, wordmark); gradMag *= mix(1.0, 1.38, wordmark); float boundaryFade = smoothstep(0.0, 0.05, depth); float lensExp = mix(mix(0.38, 2.35, gloss), mix(0.26, 1.35, gloss), wordmark); float lens = pow(clamp(depth, 0.0, 1.0), lensExp); float edgeShape = (1.0 - lens) * boundaryFade; float outerSoft = smoothstep(0.0, mix(mix(0.32, 0.12, gloss), mix(0.22, 0.08, gloss), wordmark), depth); edgeShape *= outerSoft; gradMag *= outerSoft; float contourMod = mix(0.028, 0.082, gloss) * boundaryFade * mix(1.0, 1.65, wordmark); float refraction = clamp(uCrystalRefraction, 0.0, 1.0); vec2 baseDelta = -refractDir * edgeShape * contourMod * 2.0 * mix(0.8, 2.4, refraction) * aspectComp; vec3 refracted = crystalField(fieldUv + baseDelta, t); vec3 caustic = crystalField(fieldUv + baseDelta * (1.0 + gloss * 0.75), t); refracted = mix(refracted, caustic, gloss * 0.24); float rim = smoothstep(0.2, 0.9, gradMag) * edgeShape; float rimStrength = mix(0.35, 2.25, gloss) * mix(1.0, 1.28, wordmark); vec3 color = palettePreservingShade(refracted, 1.0 + rim * rimStrength, rim * gloss * 0.42); float borderOuterFade = smoothstep(0.0, 0.15, depth); float innerIntensity = smoothstep(0.0, mix(mix(0.62, 0.48, gloss), mix(0.82, 0.62, gloss), wordmark), depth); float borderBand = pow(1.0 - innerIntensity, mix(mix(2.0, 1.28, gloss), mix(1.55, 0.98, gloss), wordmark)) * borderOuterFade; borderBand *= mix(1.0, 1.35, wordmark); vec3 borderSample = crystalField(fieldUv + outwardDir * mix(0.04, 0.06, gloss) * aspectComp, t); vec3 borderTint = palettePreservingShade(borderSample, mix(1.2, 2.65, gloss), mix(0.18, 0.58, gloss)); color = mix(color, borderTint, borderBand * mix(0.32, 0.92, gloss)); if (wordmark > 0.001) { vec2 tangent = vec2(-outwardDir.y, outwardDir.x); float edgeFlow = sin(depth * mix(9.0, 14.0, gloss) + dot(fieldUv, tangent) * 3.0 + t * 0.22); vec2 vesselDelta = (inwardDir * mix(0.018, 0.032, gloss) + tangent * edgeFlow * 0.012) * aspectComp * wordmark; vec3 vesselColor = crystalField(fieldUv + baseDelta + vesselDelta, t); vesselColor = palettePreservingShade(vesselColor, 1.0 + rim * mix(0.6, 1.5, gloss), rim * gloss * 0.35); float vesselBand = borderBand * smoothstep(0.02, 0.72, depth); color = mix(color, vesselColor, vesselBand * 0.48 * wordmark); float edgeContour = (1.0 - smoothstep(0.0, mix(0.72, 0.58, gloss), depth)) * borderOuterFade; float contourPhase = depth * mix(1.4, 2.25, gloss) + edgeFlow * 0.035 + dot(fieldUv, tangent) * 0.08 + uCrystalSeed * 0.017; vec3 contourColor = mix(paletteColorFlow(contourPhase, fieldUv + tangent * 0.11, t), vesselColor, 0.45); contourColor = palettePreservingShade(contourColor, 1.0 + rim * mix(0.45, 1.2, gloss), rim * gloss * 0.28); color = mix(color, contourColor, edgeContour * 0.26 * wordmark); } float crease = smoothstep(0.12, 0.95, gradMag) * borderOuterFade; crease *= 1.0 - smoothstep(mix(0.18, 0.28, gloss), mix(0.82, 0.92, gloss), depth); color *= 1.0 - crease * gloss * mix(0.38, 0.52, wordmark); color += paletteColorClamped(depth) * mix(0.045, 0.015, gloss) * smoothstep(0.05, 0.45, depth); float contrast = mix(1.0, mix(1.32, 1.12, smoothing), gloss); color = (color - 0.5) * contrast + 0.5; return clamp(color, 0.0, 1.0); } // Fluid dynamics core void getFluidCore(vec2 p, float t, float distortion, vec2 eNorm, float eProximity, float confInt, out float f, out float fx, out float fy, out float raw_t_norm) { vec2 q = vec2(0.0); q.x = snoise(p + vec2(t, 1.0)); q.y = snoise(p + vec2(-t, 3.0)); if (eProximity > 0.01) { vec2 eTan = vec2(-eNorm.y, eNorm.x); float mixF = eProximity * clamp(confInt * 0.8, 0.0, 1.0); float qDot = dot(q, eTan); q = mix(q, eTan * qDot, mixF); } vec2 r = vec2(0.0); r.x = snoise(p + distortion * q + vec2(1.7, 9.2) + 0.15*t); r.y = snoise(p + distortion * q + vec2(8.3, 2.8) + 0.126*t); if (eProximity > 0.01) { vec2 eTan = vec2(-eNorm.y, eNorm.x); float mixF = eProximity * clamp(confInt * 0.8, 0.0, 1.0); float rDot = dot(r, eTan); r = mix(r, eTan * rDot, mixF); r += eTan * snoise(p * 2.0 + vec2(t * 0.5, 0.0)) * 0.5 * mixF; } f = snoise(p + r); float eps = 0.001; fx = snoise(p + vec2(eps,0.0) + r) - f; fy = snoise(p + vec2(0.0,eps) + r) - f; raw_t_norm = f + r.x + t*0.5; } void getFrost(vec2 uv, float t, out float frostX, out float frostY) { frostX = snoise(uv * 200.0 + t); frostY = snoise(uv * 200.0 - t + vec2(10.0)); } void getTurbulence(vec2 p, vec2 uv, float t, out float turb, out float fineGrain) { turb = snoise(p * 3.0 + t); turb += 0.5 * snoise(p * 6.0 - t); turb += 0.25 * snoise(p * 12.0 + t); fineGrain = fract(sin(dot(uv + t*0.01, vec2(12.9898, 78.233))) * 43758.5453); } void main() { vec4 maskSample = texture2D(uMask, vUv); float alpha = maskOpacity(vUv); if (alpha <= 0.001) { gl_FragColor = vec4(0.0); return; } vec2 p = vUv; // Correct aspect ratio for noise so that shapes aren't stretched horizontally float aspect = uTexResolution.x / max(1.0, uTexResolution.y); p.x *= aspect; p *= uScale; vec2 eNorm = vec2(0.0); float eProximity = 0.0; if (uShapeConfinement) { float rStep = 0.02; float L = maskHardField(texture2D(uMask, vUv + vec2(-rStep, 0.0))); float R = maskHardField(texture2D(uMask, vUv + vec2(rStep, 0.0))); float D = maskHardField(texture2D(uMask, vUv + vec2(0.0, -rStep))); float U = maskHardField(texture2D(uMask, vUv + vec2(0.0, rStep))); eNorm = vec2(R - L, U - D); float alphaSum = L + R + U + D + maskHardField(maskSample); eProximity = smoothstep(4.8, 2.0, alphaSum); float glen = length(eNorm); if (glen > 0.0001) eNorm /= glen; p -= eNorm * eProximity * 0.5 * uConfinementIntensity; } float t = uTime * uSpeed; if (uEnableCrystalStyle) { vec3 crystalColor = crystalRefract(vUv, uTime); gl_FragColor = vec4(crystalColor, alpha); return; } // ----------- OVERLAYS ----------- if (uOverlayPixelate) { vec2 grid = vec2(max(2.0, uPixelateSize)); p = floor(p * grid) / grid; } if (uOverlayRipple) { vec2 centerUv = vec2(0.5); vec2 rp = vUv - centerUv; float d = length(rp); float r = sin(d * 30.0 - t * 3.0) * exp(-d * 3.0); p += rp * r * uRippleIntensity * 0.5; } if (uOverlayBlinds) { float angle = uBlindsAngle * 3.14159265 / 180.0; float s = sin(angle); float c = cos(angle); vec2 rotUv = vec2(vUv.x * c - vUv.y * s, vUv.x * s + vUv.y * c); float b = sin(rotUv.x * uBlindsDensity); vec2 disp = vec2(c, s) * sign(b) * pow(abs(b), 0.5) * 0.1; p += disp; float vDisp = floor(rotUv.x * uBlindsDensity) * 0.02; p += vec2(-s, c) * vDisp; } if (uOverlayDrips) { float df = snoise(vec2(p.x * 3.0, p.y * 0.5 - t * 0.5)); if (df > 0.0) { p.y += pow(df, 2.0) * uDripsIntensity * 0.5; } } if (uOverlaySmear) { float sf = snoise(vec2(p.y * 2.0 + t, p.x * 0.2)); p.x += sf * uSmearIntensity * 0.3; } // -------------------------------- float f, fx, fy, raw_t_norm; if (uEnableFramerStyle) { float fDepth = blurDepth3x3(vUv, 6.0); vec2 fDepthGrad = heightGrad(vUv, 6.0, 8.0); float gLen = length(fDepthGrad); float wallFlow = vesselWallInfluence(fDepth, gLen); if (gLen > 0.0001) fDepthGrad /= gLen; vec2 contourDir = vec2(-fDepthGrad.y, fDepthGrad.x); float ang = uFramerAngle * 3.14159265 / 180.0; float fs = sin(ang), fc = cos(ang); vec2 rp = vec2(p.x * fc - p.y * fs, p.x * fs + p.y * fc); rp += fDepthGrad * uFramerBend * wallFlow * 0.45; rp += contourDir * uFramerContour * (wallFlow * 0.45 + smoothstep(0.25, 0.85, fDepth) * 0.05); float turb = 0.0; vec2 tp = rp * uFramerWaveFreq; float fAmp = 1.0; for (int i = 0; i < 10; i++) { if (float(i) >= uFramerTurbIter) break; tp += vec2(sin(tp.y + t), cos(tp.x + t)) * uFramerTurbAmp; turb += sin(tp.x * 0.5) * fAmp; tp *= uFramerTurbFreq; fAmp *= 0.5; } raw_t_norm = turb * 0.5 + 0.5; f = raw_t_norm; fx = 0.0; fy = 0.0; } else if (uEnableHybridStyle) { float fDepth = blurDepth3x3(vUv, 6.0); vec2 fDepthGrad = heightGrad(vUv, 6.0, 8.0); float gLen = length(fDepthGrad); float wallFlow = vesselWallInfluence(fDepth, gLen); if (gLen > 0.0001) fDepthGrad /= gLen; vec2 contourDir = vec2(-fDepthGrad.y, fDepthGrad.x); float ang = uFramerAngle * 3.14159265 / 180.0; float fs = sin(ang), fc = cos(ang); vec2 rp = vec2(p.x * fc - p.y * fs, p.x * fs + p.y * fc); rp += fDepthGrad * uFramerBend * wallFlow * 0.35; rp += contourDir * uFramerContour * (wallFlow * 0.6 + smoothstep(0.25, 0.85, fDepth) * 0.05); rp *= uFramerWaveFreq; float vesselConfinement = clamp(1.0 + uFramerBend + uFramerContour * 0.5, 0.0, 2.5); if (uLoop) { float loopDur = max(uLoopDuration, 0.001); float t0 = mod(uTime, loopDur); float time1 = t0 * uSpeed; float time2 = (t0 - loopDur) * uSpeed; float blend = t0 / loopDur; float f1, fx1, fy1, rt1; float f2, fx2, fy2, rt2; getFluidCore(rp, time1, uDistortion, fDepthGrad, wallFlow, vesselConfinement, f1, fx1, fy1, rt1); getFluidCore(rp, time2, uDistortion, fDepthGrad, wallFlow, vesselConfinement, f2, fx2, fy2, rt2); f = mix(f1, f2, blend); fx = mix(fx1, fx2, blend); fy = mix(fy1, fy2, blend); raw_t_norm = mix(rt1, rt2, blend); } else { getFluidCore(rp, t, uDistortion, fDepthGrad, wallFlow, vesselConfinement, f, fx, fy, raw_t_norm); } } else { if (uLoop) { float loopDur = max(uLoopDuration, 0.001); float t0 = mod(uTime, loopDur); float time1 = t0 * uSpeed; float time2 = (t0 - loopDur) * uSpeed; float blend = t0 / loopDur; float f1, fx1, fy1, rt1; float f2, fx2, fy2, rt2; getFluidCore(p, time1, uDistortion, eNorm, eProximity, uConfinementIntensity, f1, fx1, fy1, rt1); getFluidCore(p, time2, uDistortion, eNorm, eProximity, uConfinementIntensity, f2, fx2, fy2, rt2); f = mix(f1, f2, blend); fx = mix(fx1, fx2, blend); fy = mix(fy1, fy2, blend); raw_t_norm = mix(rt1, rt2, blend); } else { getFluidCore(p, t, uDistortion, eNorm, eProximity, uConfinementIntensity, f, fx, fy, raw_t_norm); } } // Base color from the palette. The coordinate-bending modes get a tiny // derivative-aware filter so they do not posterize at high spatial frequencies. vec3 color = paletteColor(raw_t_norm); if (uEnableFramerStyle || uEnableHybridStyle) { color = paletteColorAA(raw_t_norm); } // Bevel normal mapping float eps = 0.001; // Mask shape beveling float bCenter = 0.0; float bevelCurve = 0.0; float bx, by; float maxR = max(0.005, uBevelSize * 4.0); // Prismatic evaluates deeper distances if (uPrismaticBevelEnabled) { bCenter = getShapeDist(vUv, maxR); bx = getShapeDist(vUv + vec2(eps, 0.0), maxR) - bCenter; by = getShapeDist(vUv + vec2(0.0, eps), maxR) - bCenter; // Normalize bCenter to 0-1 range for lighting falloff bCenter = clamp(bCenter / maxR, 0.0, 1.0); } else { float bevelPixels = clamp(uBevelSize * max(uTexResolution.x, uTexResolution.y) * 0.8, 3.0, 18.0); bCenter = blurDepth3x3(vUv, bevelPixels); vec2 depthGrad = heightGrad(vUv, bevelPixels, max(4.0, bevelPixels)); bx = depthGrad.x; by = depthGrad.y; } // Combine noise bumps with bevel heightmap if (uPrismaticBevelEnabled) { bevelCurve = 1.0 - bCenter; // Slope is linear, 1.0 at outer edge, 0.0 at ridge center } else { float bevelEdgeWidth = mix(0.06, 0.22, clamp(uBevelSmoothness, 0.0, 1.0)); bevelCurve = 1.0 - smoothstep(0.015, bevelEdgeWidth, bCenter); } float totalNx, totalNy; if (uPrismaticBevelEnabled) { // High steepness depending on intensity. Since bx/eps is ~1.0, a slope of 1.0 is ~45 degrees. float slope = 2.0 * max(0.1, uPrismaticBevelIntensity); totalNx = (bx / eps) * slope; totalNy = (by / eps) * slope; // Blend in minimal fluid distortion so you can still see noise moving on the facets totalNx += fx * 0.1; totalNy += fy * 0.1; } else { float slope = mix(0.018, 0.08, clamp(uBevelSize * 40.0, 0.0, 1.0)); totalNx = (fx * 0.15) + (bx * slope * bevelCurve); totalNy = (fy * 0.15) + (by * slope * bevelCurve); } vec3 normal = normalize(vec3(-totalNx, -totalNy, 1.0)); // Frosted Glass Modifies Normal before lighting and Base Color if (uFrostedGlassEnabled) { float frost, frost2; if (uLoop) { float loopDur = max(uLoopDuration, 0.001); float t0 = mod(uTime, loopDur); float time1 = t0 * uSpeed; float time2 = (t0 - loopDur) * uSpeed; float blend = t0 / loopDur; float fx1, fy1, fx2, fy2; getFrost(vUv, time1, fx1, fy1); getFrost(vUv, time2, fx2, fy2); frost = mix(fx1, fx2, blend); frost2 = mix(fy1, fy2, blend); } else { getFrost(vUv, t, frost, frost2); } normal = normalize(normal + vec3(frost, frost2, 0.0) * uFrostedGlassIntensity * 2.5); color = mix(color, vec3(0.85, 0.88, 0.92), uFrostedGlassIntensity * 0.4); } // Base color matches palette // Fake Lighting vec3 lightDir = normalize(vec3(1.0, 1.0, 1.0)); vec3 viewDir = vec3(0.0, 0.0, 1.0); // Diffuse float diff = max(dot(normal, lightDir), 0.0); // Specular (Blinn-Phong) vec3 halfDir = normalize(lightDir + viewDir); float specCenter = max(dot(normal, halfDir), 0.0); float spec = pow(specCenter, uSpecular); // Fresnel-ish reflection for edges float rim = 1.0 - max(dot(viewDir, normal), 0.0); rim = smoothstep(0.6, 1.0, rim); // Lighting composition vec3 finalColor = color * (0.3 + uLightIntensity * diff); // ambient + diffuse finalColor += spec * 1.5; // intense specular finalColor += rim * vec3(1.0); // white rim light // Keep edge shading tight; the bevel should read as a refractive wall, not a broad drop shadow. if (uPrismaticBevelEnabled) { finalColor = mix(finalColor, vec3(0.05), smoothstep(0.07, 0.0, bCenter) * 0.45); } else { finalColor = mix(finalColor, finalColor * 0.72, pow(bevelCurve, 2.0) * 0.18); finalColor += vec3(0.85, 0.94, 1.0) * rim * bevelCurve * 0.32; } // Turbulence / Noise layer overlay if (uNoiseOverlayEnabled) { float turb, fineGrain; if (uLoop) { float loopDur = max(uLoopDuration, 0.001); float t0 = mod(uTime, loopDur); float time1 = t0 * uSpeed; float time2 = (t0 - loopDur) * uSpeed; float blend = t0 / loopDur; float turb1, fineGrain1; float turb2, fineGrain2; getTurbulence(p, vUv, time1, turb1, fineGrain1); getTurbulence(p, vUv, time2, turb2, fineGrain2); turb = mix(turb1, turb2, blend); fineGrain = mix(fineGrain1, fineGrain2, blend); } else { getTurbulence(p, vUv, t, turb, fineGrain); } float noiseVal = clamp(turb * 0.5 + 0.5, 0.0, 1.0); vec3 turbulentColor = mix(finalColor, vec3(noiseVal), uNoiseOverlayIntensity * 0.4); finalColor = turbulentColor + (fineGrain - 0.5) * uNoiseOverlayIntensity * 0.15; } gl_FragColor = vec4(finalColor, alpha); }

Start Basic.