Is Linear lighting more CPU intensive than Gamma lighting on mobile?

If i switch to linear lighting in a project, is that a more intensive pipeline than gamma lighting? Or is it about the same?

Is there any kind of drawback (besides potential visual changes and shader recompilation) tio using linear light?

 

Zero difference in performance. Has no impact on the CPU or GPU perf.*

* Unless there's something really dumb going on and the GPU is lying about what it's capable of, like old Intel IGPs which would revert to software rendering when you asked for linear rendering! Yeah, really.

Colors may not look like you expect if you're using shaders or other rendering features that aren't color space aware (like older particle shaders applying a generic multiplier to the color in the shader, old particle systems w/o the "Apply Color Space" check box, or vertex colors on meshes). Also, some mobile hardware doesn't support linear rendering, in which case they'll revert to gamma space.

 

Thank you. This is basically exactly the kind of information i was hoping to get.

Im building for mobile but it is all OpenGL ES3 or Metal so i think im safe.

I think i prefer Gamma for the moment because ive built in it, but also because my games have a more painterly look. But i would like to experiment with linear. Especially if its the same then no harm in trying. For some reason i was under the impression that Linear was a really intensive process. I think because it was unavailable on earlier devices, so that led me to believe it was performance thing.

I don;t think its possible, but is there a way to switch between Linear and Gamma at Runtime?

 

No ... and yes.

It's a build time player setting that can't be changed at runtime from c#, though clearly Unity is capable of doing so internally if required. You can also technically override the camera's render buffer to use a gamma space render texture or linear space render texture, but any of Unity's built in systems that do respect the color space (several stuff related to setting colors on materials, that "apply color space" check box on particle systems, and a few other things) won't know to act differently in that case and then those will be wrong. Really there's a number of random texture import settings on assets that change, so the content may be subtly different between the two. If you're using linear on a device that doesn't support linear rendering, those settings are also likely not respected, but they'll look different than if the project were built with the appropriate color space.

 

That makes sense. Ill just run some linear tests, and when/if im ready to make the leap visually ill commit to it. And if Unity ever opens this up that could be really interesting. Thank you.

 

I'm getting quite a large performance drop switching to linear in my project (about 50% fps decrease on my old Samsung galaxy core). Had originally attributed this to the age of the phone (It should support OpenGLES3 though), but now testing on a newer HTC 10 I'm seeing huge drops as well.

The scene mainly use the buildin mobile shaders and a few custom, all lighting is baked. Forward rendering, no hdr, msaa etc. All at the very basic.

Remember testing this on new projects as well, seeing the same performance characteristics.

 

Then I suspect those mobile GPUs are cheating their support of linear frame buffers, or Unity's implementation of linear lighting on mobile is cheating. Unreal supported linear lighting on mobile long before mobile devices actually supported it by doing a ton of hacks (using in-shader gamma correction, and a post process to adjust back, which are all expensive). I think I read somewhere that mobile GPUs are essentially doing those same hacks, just internally, where as desktop GPUs have fixed function hardware doing all of it so there's essentially zero cost.

 

Interesting.

 

The Samsung galaxy core should support OpenGLES3.0, but if I switch to linear the game tanks so hard it will barely launch (single digit fps vs ~30 fps with gamma).

 

Interesting side note:

Oculus' performance analysis article for the Quests statest transparent sampling is more expensive in linear mode:

Will test this evening...

 

Just tested a simple scene with dense grass on:

- Oculus Quest (latest OS)
- URP 8.0.1
- Very lightweight custom billboard shader with AlphaToMask
- Heavy overdraw due to the grass

My results are, well... shocking.

In critical areas with screen-filling overdraw I get around 40 fps in Linear Space.
And rocksolid 72 fps with rare drops in Gamma Space.
Of course there is a downside: now lighting & colours look like crap :/

So there is a severe performance hit with transparency and linear colour space!
How can this be the case? Am I missing something?

 

Hi aleksandrk,

Display.displays[0].requiresSrgbBlitToBackbuffer returns false on my Quest.
Right now I'm in Gamma Space, but doesn't make a difference, right?

 

Assumed its some driver capabilities flag passed through Will test tonight...

 

Hi aleksandrk,

In Linear Space Display.displays[0].requiresSrgbBlitToBackbuffer returns true.
And is significantly slower...

 

Which consequentially means, all Oculus Quest headsets suffer from this issue, right?

So, sadly, I'll have to stay in gamma space on the Quest, as every small performance increase is desperately needed on this device.

Thanks for your help and responsiveness, though, much appreciated!

 

I have just tested it and Display.displays[0].requiresSrgbBlitToBackbuffer returns FALSE for me on Unity 2019.3.8f1 Built-In Forward renderer + use 32bit display buffer DISABLED + Disable Depth and Stencil + GLES 3 + require ES 3.1 + require ES 3.1 AEP + require ES 3.2 (player settings)
EDIT: using 4xMSAA and it's on an Oculus Quest, of course.
@DonPaol0 I read on another thread you are using URP. Maybe that's an URP bug?

 

It is an Adreno 540, so it does support sRGB buffers and targets though as far as I can see. Could it mean erroneous check?

 

It does on my Quest with built-in forward. Could be an URP thing.
Benchmarking Gamma vs Linear again right now.

 

Well it's just the device is fully certified for ES 3.1 in hardware, so the chances of it being a bug on Unity's side is possible. Also that Oculus article mentioned elsewhere is for Built-in on 2018.

Can anyone take a look at Adreno 540 on Quest properly? I know this VR device was pretty much ignored up until recently.

 

By "properly" do you mean?

 

That Unity devote more time to the Quest because up until a few months ago it wasn't in any of their testing.

 

Hahaha! yes. The Oculus Quest success has taken everyone by surprise. Even Oculus themselves.
The Quest sales literally exploded the last Christmas. Seems like everyone and their dog were waiting for Black Friday to get one!

 

Finished benchmarking.
Linear color space is FASTER than Gamma color space on the Oculus Quest with built-in forward render and it doesn't have to blit from linear.
Details on the other thread.

 

Android Blit Type was in AUTO.
Setting it to NEVER, changes Display.displays[0].requiresSrgbBlitToBackbuffer to TRUE.
FPS stays exactly the same though.
Does this mean we can expect faster performance if Oculus updates their Android version?
And how much would it be?

 

Now I'll have to recheck Gamma Color Space with Android Blit Type set to NEVER to really know which is faster, Gamma or Linear Color Space.
Ok, here we go again...

 

GLES3 with Linear Color Space and Android Blit Type set to AUTO: 66 fps
GLES3 with Gamma Color Space and Android Blit Type set to NEVER: 64 fps (Display.displays[0].requiresSrgbBlitToBackbuffer = FALSE)

So Gamma is still slower than Linear no matter the Blit is ON or OFF.

 

It's actually consistent. Even if it doesn't matter after all
The thing is: Linear is at least as fast as Gamma, blit or no blit.

I'm pretty sure that's what's happening here: the Quest will do it's head-tracking motion compensation anyway, so it will have to do some blits no matter what.

 

What was the consensus here? Did anyone ever figure out why it seems that linear is running slower on mobile?

 

^^ @Ng0ns ?

 

There is no consensus, only personal experiences:

On some mobile GPUs, Linear is a lot slower. On others, Linear is actually a tiny little faster.
This seems to happen because some GPUs and Android versions can't handle sRGB backbuffers and need the rendered image to be converted, adding a full framebuffer copy at the end of the render.
If you want to play it safe for all GPUs out there, use Gamma.

On the Quest specifically, Linear is a tiny little faster than Gamma using the Built-In Forward Renderer with MSAAx4 because it bypasses some internal shader operations. (my experience)
Using URP however, Ng0ns found Linear to be much slower than Gamma on the same Quest.
Why is that, we don't know.

Conclusion:
Gamma mode is the safest bet in general. If you are developping for compatibility, use Gamma mode.
If you are targeting specific hardware however, Linear can be an option but you will have to test it to be sure.

 

I seem to be having similar results when messing with Oculus quest.
Linear slows down the fps while looking through a transparent mesh used for sun rays.
Looking through water it was still at 72fps.

While on gamma its at 72 fps constantly.

 

Interesting.
Built-in render pipeline or URP?
Also, GLES3 or Vulkan?

 

Looking through a transparent mesh will drop frames regardless due to overdraw, but maybe linear is pushing it over the edge?

 

I have just rechecked: on the Quest with the built-in render pipeline, Gamma mode is 1% slower than Linear mode, even on overdraw heavy zones with fullscreen transparencies.
GLES3.2 without HDR frame buffer. (Vulkan is extremely slow on the Quest. Use GLES)
Maybe it's an URP thing.

 

The problem is the setting on player for "Blit Type". If you use Linear, your device may be forced to "always" do blit, so whatever you gained from switching to linear, you made it slower with the blit.

 

Linear is still at least as fast as gamma anyway.

 

No. If you are forced to turn the "always blit" on, it's impossible linear is faster than gamma with "blit none". It's just impossible. Your case works only if the device supports the same Blit Type for both. This is the case for modern devices but not for older ones. Quoting from a previous post from Unity team in this thread... these are the requirements for it to work.

"Linear rendering on Android requires two things - sRGB sampling and sRGB backbuffer. sRGB sampling is supported on OpenGL ES 3.0 and higher, as mentioned earlier. The latter is provided by a EGL extension (EGL_KHR_gl_colorspace). If your device runs Android 8.1, this extension is broken and Unity reverts to conversion using a full-screen blit, which can affect performance."

 

Stop talking and benchmark it.

 

That's exactly what I did before posting. Why so rude?
I tested both scenarios. If my phone supports the specs I choose linear. Otherwise it drops around 20% on performance because of the blit type. And you can't deactivate that if you use linear on certain phones. Just get an old phone and benchmark instead of talking. What kind of comment is that?

 

Sorry I didn't want to upset you
It's just that plenty of people talk theoretically without actually measuring it.
My tests were done on the Oculus Quest, and there linear is actually a little bit faster.
What phone is it and what GPU does it have?

 

On the Quest, it blits and it's faster. So much for it being impossible.
Theory is just speculation. There are so many things that can and will impact the final result in practice that the only way to know for sure is to test and benchmark it, and that's what I did on this whole thread.
I'm still interested in your results on your specific phone though, if you are still wanting to share them.

 

You are still failing to understand the post. Let me reinforce the important parts: Your case works only if the device supports the same Blit Type for both. This is the case for modern devices but not for older ones.

You are using as a comparison the Quest, which DOES SUPPORT THAT SETTING. I´m explaining that if your phone DOES NOT, I repeat, IF YOUR DEVICE DOES NOT support ¨blit none¨ on linear settings, it cannot be faster. You are basically saying that doing calculations is faster than doing absolutely nothing. It´s like saying that rendering water is faster than not rendering anything. And you just keep insisting.

You are using a Quest that supports the option on both gamma and linear, which then has the same settings and you compare the speed between gamma and linear and claim Linear is faster. It may well be. NOBODY is arguing that. But this thread is not ONLY about the specific case of Quest. If you get an older device that doesn't allow for the same blit settings for linear and gamma, it is IMPOSSIBLE, that "blit always" is faster than "blit none". IMPOSSIBLE. And the problem is that some old devices and Android 8.1 will FORCE YOU to set it to "blit always" if you set it to linear instead of gamma.

 

The Quest does Blit when using linear, as evidenced in this post. It does not when using gamma.