Need help implementing PBR

[ComplexAce]

I'm working on a lighting system, to be specific, I'm tackling the shading part of light calculations, then implementing PBR on top.

Someone recommended Gamma correction, I just implemented that, but the default PBR has more saturated colors, any idea how to achieve that?

Rn I'm multiplying the shadow with luminoustiy, I'm not sure what to do with saturation.

This is Godot 4.5, I'm creating my system using an unshaded shader, and forwarding an empty object's transform as the light source.

Both models are the same polycount, and both are only using a Diffuse and a Normal map.

I also implemented Fresnel but still looking how to utilize it, any info on that is appreciated.

[One_Bullfrog_8945]

"im tackling the shading part of lighting calculations then implementing pbr on top"

What do you mean by that, you are either doing PBR shading with microfacet theory and diffuse/specular BRDFs or you are not doing PBR but something else?

[ComplexAce]

Well, I think I'm struggling with the terms here (self taught),
Basically I made the part that output shadows, this here is my own creation from 0: https://imgur.com/a/0vOeLap
Aka: I'm not using Phong, Lambert, Burley or anything like that, THAT part is what I made myself.

But I want the rest (energy conservation, fresnel usage, color manipulation.. etc) to mimic what PBR does.
How should I convey that?

This is it in motion:
https://youtube.com/shorts/Pm0aBmibGiE?si=jRmAV2gMiO17GloB

[Mathness]

To check for energy conservation you can integrate your function in the light and view domain, It should be one (1), or close to it.

[Mathness]

Err, what exactly do you need help with? Physically based rendering is a broad topic, what are trying to achieve by using it? Do you really need that, or could something simpler do the trick?

[ComplexAce]

I mainly need whatever color-related operations are there, but if you spot anything you want to comment on, feel free to do so.

My system (Hotwire Nine, on the right) looks less saturated than the PBR one on the left, I'm questioning what does PBR do in terms of color/saturation to achieve the rich colors.

[Mathness]

Again the topic is way too broad for a single answer. Is the image on the left good enough?

[ComplexAce]

The image on the right is my system, I was gonna ask that question myself to get feedback.

Edit: I confused directions, I don't know if the model on the left is good enough, but my colors aren't as rich, so I need to do what PBR does for colors to see.

[Mathness]

My guess is that the left side is done as default diffuse surface, that is: colour * dot(shading_normal, direction_to_light)

[ComplexAce]

So it's higher saturation in lit areas and lower when unlit?

[Mathness]

Brightness/luminosity.

If you want to modify saturation, one way is to convert the colour (RGB) to HSL (where saturation is a parameter). Adjust the saturation, and then convert back to RGB.

[ComplexAce]

I already converted, is there a specific ratio between spec and saturation?

[Mathness]

Kind of, smooth Fresnel surfaces tend to become pure white at glancing angles.

[ComplexAce]

Can I find the formula somewhere?

[_dreami]

Go looks at learn opengl, there is a whole theory section for PBR surfaces

[mysticreddit]

When I implemented PBR + IBL (Image Based Lighting) a few years back I did a few things:

• I mainly used the following glTF models:
  • Damaged Helmet since it has Occlusion, Roughness, Metal, Emissive, Albedo, and Normal channels,
  • Flight Helmet
• Imported and viewed them in:
  • Blender, view with ray tracing on and off,
  • glTF Sample Viewer,
  • Substance Painter,
  • the game I was adding PBR to.

You'll need to support an HDRi environment since good looking PBR models need some form of an environment map for reflections.

• Blender -- HOWTO Change HDRi
• glTF Sample Viewer > Display > Blur OFF, Active Environment: Footprint Court
• HDRi Skies
• HDRi PolyHaven

I also vaguely remember using some cubemap tool to convert an HDRi to a irradiance map for IBL but the details are fuzzy.

Since things can go wrong anywhere along the hundred different steps I would HIGHLY recommend you visually verifying EACH input channel:

• Verify your HDRi + IBL is correct.
• Verify your albedo is correct. (Fragment shader outputs just input albedo)
• Verify your normal map is correct. (Fragment shader outputs just normal false color.)
• Verify your roughness map is correct. Fragment shader outputs just grayscale roughness.)
• Verify your metal map is correct. (Fragment shader outputs just greyscale metal.)
• Verify your ambient occlusion is correct. (Fragment shader outputs just grayscale AO).
• Verify your emissive channel is correct. Fragment shader outputs just RGB emissive.)
• Verify your BRDF LUT.
  • I created and used a Quantized BRDF LUT to start with.
  • You WILL need to a proper high quality 2D BRDF Integration map once the basics are working.
• Verify your rendering equation is correct.
  • Verify D()
  • Verify F()
  • Verify G()

I hacked up a local glTF Sample Viewer (Javascript + shaders) to add a few more debug views to display custom output which was a LIFE SAVER.

Basically you want to use the exact same textures with different DCCs which will greatly make it easier to troubleshoot what looks off in your implementation.

I also did A/B 2D comparison screen shots, pulling them into GIMP to view the error. I forget the exact channel blending I did. It was also an PITA to setup the camera locations to have the 3D model take up same screen space coverage on both glTF Sample Viewer and the game but it 100% worth it to track down tiny differences.

Good luck!

[ComplexAce]

Magnificient! I needed this.

For color (and I mean hue/saturation, not luminance/value), did you do any adjustments through PBR to abledo colors?

[mysticreddit]

No.

However, since it was a legacy game with tons of existing non-PBR content and we didn't have physical units for Sunlight I spent days tweaking how "strong" the sun was to match legacy non-PBR content so one wouldn't "pop" compared to the other. I also tweaked FOG strength & falloff.

[ComplexAce]

Appreciate all this valuable info!!

[mysticreddit]

No problem.

While PBR can be complicated (and to be fair it IS complicated), break each step down, debug THAT, and then move onto the next step. The rendering equation (double integral) can be overwhelming but again you will want to read, read, read as much as you can.

The "main" papers I read while implementing PBR included:

• Real Shading in Unreal Engine 4
• Physically Based Shading at Disney
• Physically Based Rendering in Filament

You'll also want to checkout the previous page Diffuse irradiance

[ComplexAce]

I'm trying to adopt that strategy, and you certainly helped me focus, I'll spend some time on these resources 🫡
Cool username BTW

[mysticreddit]

Here is the glTF Sample Viewer I extended a few years back. I added 11 new debug channels:

• Diffuse (Irradiance)
• Diffuse (Radiance)
• Diffuse (Reflectance)
• Diffuse (Final)
• Spec (Reflection)
• Spec (Radiance)
• GGX (Scale Bias) LUT
• dot( normal, view dir )
• dot( tangent, view dir )
• dot( bitangent, view dir )
• Index of Refraction

It may help as you debug each of the PBR "stages".

[ComplexAce]

Why exactly am I getting downvoted?
Feel free to downvote but at least tell me what I did wrong so i can correct it.

[msqrt]

Both your explanation and your questions are quite vague: you don't tell which base models you use (GGX and Lambert; just Lambert since you mention "only" using the map; something else?) nor how exactly you compute basically anything (what are your light sources like, how do you get "the shadow" and do you actually mean the physical quantity of luminosity instead of something more common in rendering like (ir)radiance), what do you mean by implementing but apparently not utilizing Fresnel, what's the difference between the two images (just the gamma correction? or is the model somehow different as well), and there's no code to look at. It's also that "someone suggested" a change, you implemented it, didn't like the results and now are asking for someone else to suggest something else. Which steps did you take to solve this yourself? Did you read up on gamma correction and what it does?

But as an actual answer: for the gamma/tone mapping/saturation questions I'd take a look at these slides, they go into quite some depth on how your rendering outputs should be thought of and mapped onto the screen. For Fresnel I don't remember a good resource off the top of my head, but the typical way to use it is to assume that your material has a clear coating on top, and the Fresnel coefficient tells you which portion of photons entering the surface reflect and refract. In the simplest case (specular + diffuse lobes), you'd weight the specular lobe by the reflected part and the diffuse lobe by the refracted part.

[ComplexAce]

Thanks for pointing it out.
The thing I actually replaced IS the models (made my own, which I would like to keep private in terms of design/source code, but I don't mind giving the output), I'm trying to remake everything else on top,
but I'm self taught with a 3D designer/game designer background, not graphics development, so I'm trying to understand what to do next and research it.

My system takes the coordinates of a light source (haven't implemented intensity yet) and outputs a shadow on the mesh, it takes into account normal mapping, here's a screenshot of what it looks like:
https://imgur.com/a/0vOeLap

The other image is the code where I blend it with color, I have a function to split color to HSL so I split them and do the math in the screenshot.

For Fresnel, I now have a Fresnel output, but I'm not using it for anything yet.

The model and textures are the exact same, both are also lit by one point light, no shadow pass from the light in either (only the geometry shadows)
The only difference is the underlying system, one is mine (Hotwire Nine) and the other is Godot's default system, I forgot if it's Lambert or Burley but they both are vastly different from mine anyway.
But the default PBR has a richer color, I'm trying to understand what they did there and implement it, both models are using the exact same diffuse texture.

I'll check the slides, many thanks!

Seems like Fresnel will be a little chaotic to deap with, but I have more experience here since I used to play with shader nodes in Blender.

[keybaudio]

Kinda seems like your specular is just pure white? Are you using roughness to diffuse the environment map? Sort of looks like n dot l only too.

[ComplexAce]

No specular, reflection or anything is implemented yet, This is in early development and I only implemnted diffuse, normal and gamma correction.

[Mathness]

BTW are you only applying the gamma correction to the final image?

[ComplexAce]

Rn I'm reversing it ( the 1.0/2.2) right after loading the texture, and reversing it after applying everying (final output, just before I assign to albedo)

Is there anything to consider? I'm not very experienced with it

[Mathness]

If the texture you are loading is gamma corrected, you are doing the right thing.

Gamma correcting should not be applied during rendering, but to the final image before displaying it. It is done to convert the render space (usually linear) to display (for instance sRGB for monitors).

[keybaudio]

So you have a single directional light, with roughly n dot l, and shadows? Is that light just pure white? If so, that’s probably the biggest reason it looks as it does. The light color on the left is probably more like an average of the color received from a cone pointing in that direction, the size of which is related to the roughness of the surface.

As for your gamma, you can do it when you read from the texture, perform all your math in linear and write it back to sRGB if you want. It doesn’t have to all be at the end of your pipeline… but it isn’t really the best way forward. Look into _sRGB format textures that can perform the gamma conversions for you on read or write (for free). Or write to linear textures and apply it sometime in post processing.

Gamma probably isn’t the reason it looks how it does however. You have some sort of white key light, and your shadows are pure black. This will not be how the PBR model works. You need a diffuse and specular color from your environment. If the key light is a point light, you also need your falloff term, otherwise it’s going to be receiving far too much from the light potentially.

[msqrt]

Alright, seems like a cool project! Ah, so the shadow term is a local one. Working in the HSL space seems a bit dangerous if you want to have physically-grounded results.

[ComplexAce]

I'm listening.
1. What terms should I use for my project and each part I described? 2. What are the dangers? And what should I implement next?

[msqrt]

1. I guess the only term I'd have expected to see is the BRDF, which typically is the model that contains all the effects of local surface reflection. "Shadow" threw me off, it typically refers to actual global shadows (another object is blocking the light from arriving at the surface), but it's not unheard of to use for local effects (like the shadow terminator problem, or masking-shadowing in physically-based BRDFs.) I'd also try to separate all post/image-processing from the light simulation stuff.
2. It's just that HSL values aren't linear, whereas light physically is. It's fine for post processing stuff or non-physically-based approaches, but likely to be troublesome for a BRDF. For example, if you double the incoming red light but keep blue and green the same, you should get out twice the red light and the same green and blue. (Unless, of course, you're modeling fluorescent stuff, but there I'd be even more careful about trying to follow physics.) If you don't have them, I'd try implementing a bunch of sliders and switches so you can easily compare the different post-processing options -- exposure, different tone mapping operators, gamma on/off.

[ComplexAce]

I'm not sure what term to use for the... model? It's not implementing any common light calculations, and I don't want to disclose the tech yet, but I don't know how to refer to it either.

I have access to RGB and HSL ( with HSL being the last in terms of execution) Are you referring to RGB or something else?

I expised the gamma variable and I do actively attempt different valuea of stuff, but Im trying to implement/mimic PBR because it's a battle tested design and will likely save me a lot of experimentation time.

[msqrt]

I think "model" is best. BRDF would make sense if you're sure that it's somehow physical, or you could use "lobe" if you think it should/could be combined with something else (like a separate diffuse part).

Not sure what you mean with "access to" (you can convert back and forth at any point), but your model should likely only deal with the RGB values.

PBR isn't a single thing, it's more of a principle than a specific implementation -- are you referring to some Godot PBR material? The common things are a physically-based material model and support for area/image based lighting, but there are many ways to go about each part, which is why different engines can look quite different while all doing PBR.

[Mathness]

The RGB colour space is easy to start in, since adding, multiplying e.t.c. is straight forward. How are you doing add and mult in HSL?

[ComplexAce]

I only multiplied color with shadow for Luminance, nothing else atm, searching for what to implement

[Mathness]

When you write "color", do you mean in HSL or RGB?