Bloom parameters

I feel a bit silly, but well… I don’t understand the parameters for the bloom filter.

The reference give me this:

def setBloom 	( 	  	self,
		  	blend = (0.3,0.4,
		  	mintrigger = 0.6,
		  	maxtrigger = 1.0,
		  	desat = 0.6,
		  	intensity = 1.0,
		  	size = "medium" 

I suspect there’s something wrong with the blend parameter, but still the rest makes almost no sense to me.

How do I understand the bloom filter?

First you render the frame:

Then you change the brightness/contrast:

Then you blur it:

And finally combine (add) the processed image to the original scene:

So I would expect the parameters to be:

  1. Brightness
  2. Contrast
  3. Amount of blur
  4. How much much of the processed image gets added to the original scene.

Is the panda bloom done in a different way? What do the parameters really mean?

The Bloom filter is explained on the relevant manual page: … ge_Filters

Thanks, I somehow missed that page, but after reading it I don’t feel any smarter :frowning:

The default is (0.3,0.4,0.3,0.0) so that’s 0.3 for red, 0.4 for green, 0.3 for blue, 0 for alpha. Why is it 0.4 for green?
And what does it mean that the brightness is measured by weighting the R,G,B, and A components?

The name suggested that this is somehow used to adjust how much the the processed image is blend with the original image… but I think I got this all wrong. Does “blend” mean it blends all the colours into one value (brightness?) that is later used by mintrigger and maxtrigger?

What’s the expected effect of using smaller or bigger numbers?

This controls the halo…somehow. I was thinking the halo is just the effect of bluring.

Ok, this one I understand.

It’s a mystery. I don’t even know if 1.0 is the max value or the min value. Is this on a 0.0-1.0 scale or 1.0 - 100.0? It adjusts the brightness of the halo but didn’t mintrigger and maxtrigger adjust the rightness of the halo?

Is “small” the size of the buffer it is rendered to or is “small” the size of the resulting blur?

The brightness is the dot product of the colour and the blend value, like:

brightness = color.r * blend.r + color.g * blend.g + color.b * blend.b + color.a * blend.a

So “blend” contains the weights for each component, i.e. how much each component contributes to the resulting value.
For instance, if you specify (1, 0, 0, 0) then only red objects will glow, and the colour of the glow will be somewhere between red and white depending on the “desat” value. If you specify (0, 0, 0, 1) and enable the shader generator on the scene, then the glow maps entirely define how much the object glows.

Sounds about right. Bigger or smaller numbers would probably (try it out!) just create more bright or less bright bloom, but it’s probably best to let the weights add up to 1.0 to create a uniform range of 0.0-1.0 in brightness values, and use intensity to control the intensity of the glow.

If you set these to 0.0 and 1.0 respectively (assuming that the weights add up to 1.0), then everything will be blurred. That would wash out the details (like in your images). So you would want it to start blurring at a brightness value of, say, 0.8, and gradually increase the blur intensity as the value increases to 1.0. So these values give you fine control over the range of brightness values on which the bloom has effect.

mintrigger and maxtrigger control the range of pixel brightnesses that the bloom affects, while intensity controls the brightness of the final glow.

It’s a bit complex how these options behave, but try to think of it as a blur radius: a large bloom effect would create big halos around objects, while small would make the effect a bit more subtle.