Great post Alex, the gradients are lovely, I'm just starting to play around with webgl so the timing is perfect ...
mwkaufma 9 hours ago [-]
>> The mix function is an interpolation function that linearly interpolates between the two input colors using a blend factor between and ( in our case).
>> A mix function for two colors works the same way, except we mix the color components. To mix two RGB colors, for example, we’d mix the red, green, and blue channels.
Colorspace alert! mix != lerp in sRGB
rikroots 7 minutes ago [-]
I agree with the colorspace alert. Lerping red and blue in OKLAB or OKLCH colorspace produces a much nicer effect. Also, the article details linear interpolation, but I think there's a lot of fun to be had by introducing some easing functionality into the interpolation[1] - it's not difficult to achieve in code, even in shader code?
I do disagree with the article about the need to do such work in the WebGL space. Modern CPUs are insanely fast nowadays, and browsers have put in a lot of work over the past few years to make the Canvas 2D API as performant as possible - including moving as much work as possible into the GPU behind the scenes. With a bit of effort, gradients can be animated in 2D canvases in many interesting ways![2][3]
Quite right! I think if the values were linearized (~gamma 0.5) lerp might be mostly ok though, right?
And what about doing rgb->hsv, then lerp, then hsv->rgb? I'm unclear whether that also needs linearization, or whether the gamma can maybe just be done to the 'v' component before lerping?
Color is a surprisingly deep and fascinating topic, that's for sure! :)
mwkaufma 4 hours ago [-]
Perceptual colors -- both sRGB and HSB -- are nonlinear, so you can't expect linear combinations to produce meaningful results (they often "interpolate through mud").
If you just want optical phenomena, you can just convert to luminescence -- WegGL and other modern graphics APIs actually does this internally when you load or render textures, so all shaders are handling optically-linear data, which is why the shader-produced images in the post look better than the javascript gradients.
pornel 6 hours ago [-]
Mixing of colors in an "objective" way like blur (lens focus) is a physical phenomenon, and should be done in linear color space.
Subjective things, like color similarity and perception of brightness should be evaluated in perceptual color spaces. This includes sRGB (it's not very good at it, but it's trying).
Gradients are weirdly in the middle. Smoothness and matching of colors are very subjective, but color interpolation is mathematically dubious in most perceptual color spaces, because √(avg(a+b)) ≠ avg(√(a) + √(b))
itishappy 8 hours ago [-]
To be fair, lerp still mixes colors, it just mixes ugly colors.
sly010 8 hours ago [-]
Very cool, but by css-rotating (skewY(-6deg)) the canvas at the last moment, you introduced aliasing on the border between the canvas and the rest of the page which kills the vibe. The browser can't automatically blend the canvas with the rest of the page. It's noticeable even on a brand new retina display. Maybe you could keep your canvas square and introduce the skew in the shader.
danwills 8 hours ago [-]
Guess it depends on the browser as it looks sharp and free of aliasing for me, including when zooming in (Opera on Android)
herpdyderp 8 hours ago [-]
- Safari: decent but still obviously present
- Chrome: quite bad looking
- Firefox: something in between
(tested on macOS)
andrewmcwatters 6 hours ago [-]
The funny thing is, as far as I know, skewY is a virtual draw command in the WebKit family of rendering engines.
It's "in the shader" already. For whatever reason, your browser's compositor is failing to anti-alias the rendering bounds of the canvas.
I don't know why, though. I don't see the issue in Safari on my system.
mrmagoo17 3 hours ago [-]
We need more articles as polished as this one. WebGL is a topic I wanted to get into for a while now but it's really difficult to find good content about it. Please keep sharing more experiments!
FlashBlaze 37 minutes ago [-]
Could not agree more. Heard good things about https://webgl2fundamentals.org/, but I think it directly jumps into code without any background as such. At least that is what I felt. Not sure whether this is the only way to go about teaching WebGL.
ikesau 6 hours ago [-]
Jesus christ, this is such a polished article. Writing it must have taken at least 5 times as long as the shader!
Have reblogged it and will refer back to it if ever I have some time to learn how to write them :)
herpdyderp 8 hours ago [-]
The linked source code [0] doesn't seem to have any license attached to it. So how could I actually use this? Is it published as a package somewhere, like npm?
This looks very smooth. Would this be in 10 bit colour if the display supports it? I can't see any banding even when zoomed in Safari or Brave on a MBP with HDR display.
polygot 5 hours ago [-]
Reminds me of the JetBrains installer--not a bad reminder, I like the animations.
Rendered at 07:54:08 GMT+0000 (Coordinated Universal Time) with Vercel.
>> A mix function for two colors works the same way, except we mix the color components. To mix two RGB colors, for example, we’d mix the red, green, and blue channels.
Colorspace alert! mix != lerp in sRGB
I do disagree with the article about the need to do such work in the WebGL space. Modern CPUs are insanely fast nowadays, and browsers have put in a lot of work over the past few years to make the Canvas 2D API as performant as possible - including moving as much work as possible into the GPU behind the scenes. With a bit of effort, gradients can be animated in 2D canvases in many interesting ways![2][3]
[1] - Easing a linear gradient in different color spaces: https://scrawl-v8.rikweb.org.uk/demo/canvas-003.html
[2] - Animated gradient effect: https://codepen.io/kaliedarik/pen/poRLBLp
[3] - Animating a gradient over a live video feed: https://codepen.io/kaliedarik/pen/MWMQyJZ
And what about doing rgb->hsv, then lerp, then hsv->rgb? I'm unclear whether that also needs linearization, or whether the gamma can maybe just be done to the 'v' component before lerping?
Color is a surprisingly deep and fascinating topic, that's for sure! :)
If you just want optical phenomena, you can just convert to luminescence -- WegGL and other modern graphics APIs actually does this internally when you load or render textures, so all shaders are handling optically-linear data, which is why the shader-produced images in the post look better than the javascript gradients.
Subjective things, like color similarity and perception of brightness should be evaluated in perceptual color spaces. This includes sRGB (it's not very good at it, but it's trying).
Gradients are weirdly in the middle. Smoothness and matching of colors are very subjective, but color interpolation is mathematically dubious in most perceptual color spaces, because √(avg(a+b)) ≠ avg(√(a) + √(b))
It's "in the shader" already. For whatever reason, your browser's compositor is failing to anti-alias the rendering bounds of the canvas.
I don't know why, though. I don't see the issue in Safari on my system.
Have reblogged it and will refer back to it if ever I have some time to learn how to write them :)
0. https://github.com/alexharri/website/blob/eb9551dd7312685704...