🎉 Celebrating 25 Years of GameDev.net! 🎉

Not many can claim 25 years on the Internet! Join us in celebrating this milestone. Learn more about our history, and thank you for being a part of our community!

Back to Graphics and GPU Programming

How to make blurry reflections without using LODs?

Shem_Namo · 2021-07-16T06:49:12

Hi everyone, how is it going? I'm working on a shader that uses Equirectangular reflection mapping to add reflections to a material. The shader is for a image compositing software, not a game so it doesn't need to be anywhere near real-time speeds. The shader uses an Equirectangular HDRI map to get the reflections by converting the reflection vector to UV coordinates and sampling the texture. The platform I'm using can only sample textures, but no LODs. I also can't use cubemaps, pre-filtering, multiple passes, uint datatypes, or bitwise operators like in the radical inverse function used everywhere. So I had to use a different method to blur the reflections(code attached below). It works something like this, for a number of samples(32-256). Create a random vec3 vector(range -0.5 to 0.5) and multiply it by the roughness value. Add the random vector to the reflection vector. Renormalize the vector, convert the new reflection vector to UVs and sample the texture, add the sample to the accumulator and after the loop, divide by the number of samples. This works very well since there are no seams and no distortion, but the result is still a little lackluster. Especially when the material is set to metallic and all you see is the specular reflection. Even though the image I'm using is an HDR and the textures are set to support HDR, the result is missing that nice hotspot falloff that you get with specular reflection convolutions. Is there any way that I can incorporate a nice falloff to this method. Attached is the code that I use for the reflection blur, and the result that I get and the result that I would like to get. Could someone please point me in the right direction? float random3(vec3 co) { return fract(sin(dot(co,vec3(12.9898, 78.233, 94.785))) * 43758.5453); } vec3 randomize3(vec3 r) { vec3 newR = fract(r * vec3(12.9898, 78.233, 56.458)); return fract(sqrt(newR.x + .001) * vec3(sin(newR.y * 6.283185), cos(newR.y * 6.283185), tan(newR.z * 6.283185))); } vec2 VectorToUV(vec3 vector) { vector = (RotationMatrix * vec4(vector, 1.0)).xyz; vector = normalize(vector); vec2 uv = vec2(0.0, 0.0); uv.x = atan(vector.x, -vector.z) * 0.159154 + 0.5; uv.y = asin(vector.y) * 0.318308 + 0.5; return uv; } vec3 convolve(vec3 vector, float radius, int samples) { vec3 rnd = vec3(random3(vector)); vec3 acc = vec3(0.0); for (int i = 0; i < samples; i++) { vec3 R = normalize(vector + ((randomize3(rnd + vec3(i)) - vec3(0.5))* vec3(radius))); vec2 uv = VectorToUV(R); acc += texture(EnvMap, uv).xyz; } vec3 final = acc / vec3(samples); return final; } Reference My Result Thanks in advanced, Shem Namo

Graphics and GPU Programming Programming lod pbr GLSL Blur HLSL mapping reflection convolution ibl

Started by Shem_Namo July 11, 2021 10:24 AM

14 comments, last by MJP 2 years, 11 months ago

Shem_Namo

Author

July 15, 2021 10:13 AM

Hi @JoeJ,

Yeah, so if I set the sample count to even 2000, it matches the reference pretty well.

But if the Environment Map is an HDR, I get a lot of fireflies in a very distinct spiral pattern(I think that's because of the Fibonacci Function).

Even if I bring the samples up to 6000, the fireflies are still there, but less noticeable.

But still 2000 samples is a bit expensive, is there any way to use less samples and still get a decent result?

I had an idea to multiple each sample by the inverted dot product between the original reflection vector and the one made with the new Normal.

And also create an accumulator to add all of the values of the non inverted dot product.

So then after the loop, and after I divide the color accumulator by the number of samples, I would then multiply the result with the dot weight accumulator.

That way the end result will have a weight of 1, I haven't tried this out yet, but I think it will work to reduce the fireflies.

I'll report how that goes ?

Thanks again!!

I really appreciate it!!

JoeJ

4,260

July 15, 2021 10:48 AM

Well, if you only you could add converstaion to mip mapped cube map. Then you could do what games do and trade for some better accuracy by doing some more samples than just one.

I guess the fireflies come from some small but very bright spots in the env. map, like the sun or other light sources. Some pixels hit it by luck, others don't. One way to address this is 'denoising' (blurring in image space, or identifying and removing outliers). The other way is to importance sample the env. map, as proposed by the paper (which may be out of date).

Shem_Namo

Author

July 15, 2021 11:18 AM

Yeah, I wish I could use mipmaps for this, it seems like a very good solution.

I am pretty sure that you're right about the bright spots causing fireflies.

I'll keep trying and see if there is a faster way to deal with this.

Thanks again!!

Tommato

240

July 15, 2021 02:06 PM

IBL (image-based lighting) is another story. It uses pre-calculated rays directions, environment image (typically HDRI) is first sub-divided into pieces with “same energy”. The result is an interested combination of directional and environment illumination There is no ovstacles to do this on GPU, but again, with only maps (no rays) the abilities are very limited, in fact no any shadow.

But it's “illimiation” that has no relation with “blurred reflections” ;-)

MJP

20,297

July 16, 2021 06:49 AM

“IBL” just means you're getting lighting from an image. Any method for sampling lighting from an image is IBL, what the OP is doing here definitely qualifies. There are of course many other options for implementing IBL, such as pre-filtered cubemaps and other related techniques.

If your image has small, bright spots it makes sense that it will cause fireflies. In simple terms your odds of a sample landing on a bright spot are low, and so they don't end up properly combining with rest of the result. You can improve this by using importance sampling the image itself, which roughly boils down to “take more samples at the brighter spots of the image and apply appropriate weighting”. If you then combined this with the BRDF sampling you already have by using multiple importance sampling, you can get better results in less samples. Any kind of traditional IBL importance sampling typically requires some kind of pre-processing of the image to find the important spots and compute weighting factors, although there is some good recent research into building up that kind of information on-the-fly as you're taking samples.

The Blog | The Book

🎉 Celebrating 25 Years of GameDev.net! 🎉

How to make blurry reflections without using LODs?

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

🎉 Celebrating 25 Years of GameDev.net! 🎉

How to make blurry reflections without using LODs?

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines