How to improve this shader's performance?

Question

I have a scene with 150000 instances. I use glsl and opengl 4.0. Shader A is 2 times slower than shader B. I.e. with shader A I get 20fps, with shader B I get 40fps on average. What can I do to improve shader A?

Shader A:

#version 400

struct Light {
   vec3 position;
   vec3 intensities; //a.k.a the color of the light
   float ambientCoefficient;
   float attenuation;
};

uniform bool useLight;
uniform mat4 modelMatrix;
uniform bool useTex;
uniform sampler2D tex;
uniform Light light;
uniform vec4 diffuseColor;

in vec2 fragTexCoord;
in vec3 fragNormal;
in vec3 fragVert;

out vec4 finalColor;

void main() {
    vec3 normal = normalize(transpose(inverse(mat3(modelMatrix))) * fragNormal);
    vec3 surfacePos = vec3(modelMatrix * vec4(fragVert, 1));

    vec4 surfaceColor = vec4(0,0,0,1);

    if(useTex) {
        surfaceColor = texture(tex, fragTexCoord);
    }
    else {
        //surfaceColor = diffuseColor;
        surfaceColor = vec4(0,1,0,1);
    }

    if(useLight) {
        vec3 surfaceToLight = normalize(light.position - surfacePos);

        //ambient
        vec3 ambient = light.ambientCoefficient * surfaceColor.rgb * light.intensities;

        //diffuse
        float diffuseCoefficient = max(0.0, dot(normal, surfaceToLight));
        vec3 diffuse = diffuseCoefficient * surfaceColor.rgb * light.intensities;

        //attenuation
        float distanceToLight = length(light.position - surfacePos);
        float attenuation = 1.0 / (1.0 + light.attenuation * pow(distanceToLight, 2));

        //linear color (color before gamma correction)
        vec3 linearColor = ambient + attenuation*(diffuse);

        //final color (after gamma correction)
        vec3 gamma = vec3(1.0/2.2);
        finalColor = vec4(pow(linearColor, gamma), surfaceColor.a);
    }
    else {
        finalColor = surfaceColor;
    }
}

Shader B:

#version 400

struct Light {
   vec3 position;
   vec3 intensities; //a.k.a the color of the light
   float ambientCoefficient;
   float attenuation;
};

uniform bool useLight;
uniform mat4 modelMatrix;
uniform bool useTex;
uniform sampler2D tex;
uniform Light light;
uniform vec4 diffuseColor;

in vec2 fragTexCoord;
in vec3 fragNormal;
in vec3 fragVert;

out vec4 finalColor;

void main() {
    finalColor = vec4(0,0,0.7,1);
}

Answer 1

At first you should pre-compute as much data as you can and avoid computing the same values for every pixel.

You have such a fragment:

transpose(inverse(mat3(modelMatrix))

This inverts the matrix, which is not so trivial operation and despite the fact that input data are the same for each pixel (so the results will be the same) it's recomputing this for every pixel. Compute it once, before rendering and pass the result as another matrix, like you do with the modelMatrix.

Later, you're also normalizing the (light.position - surfacePos) vector but you're also computing the length of it, so it results in two sqrt operations instead of one.

Additionally, depending on your hardware you may find that using if's in a pixel shader may lower your performance. If that's the case you could prepare few distinct versions of your shader and batch your instances depending on the useLight and useTex properties.

EDIT:

You may also try to lower the OpenGL version defined in shaders, to be the lowest one supporting your features. In theory it shouldn't do much but depending on drivers and HW vendor the practice may differ... (i.e. if your GPU supports OGL 4.0 it often means that it's fast in OGL 3.0 but very slow in 4.0, but you need to test it on specific case).

Answer 2

Looking at this line in particular:

vec3 normal = normalize(transpose(inverse(mat3(modelMatrix))) * fragNormal);

working out the inverse of a matrix is very taxing, and should be precalculated by the cpu instead of forcing the gpu to waste time messing around with it.

Answer 3

There's not a whole lot you can do; the simple reality is that shader A does more work than shader B, so it's always going to run slower.

We can close the gap somewhat however. I can't give you definite figures for how much, it all depends on performance characteristics of the rest of your program, so treat these are general good practice.

transpose(inverse(mat3(modelMatrix)))

That's a lot of inversions and transpositions per frame. Do it on the CPU instead, one time only (or at least only when modelMatrix changes) and send the inverse/transpose matrix as an additional uniform. If ALU operations are a bottleneck for you, this should gice you the biggest increase.

if(useTex) {

Branching is not the death that it used to be, but you can still avoid it here (and save a uniform slot) by creating a 1x1 texture (of the appropriate colour) and binding that instead.

if(useLight) {

More branching. In this case there's no obvious alternative (such as the 1x1 texture) so I'd encourage you to split this condition off into a third shader and benchmark both (i.e. 2 shaders with a branch versus 3 shaders without). Depending how often you need to change shaders you may or may not see a performance difference when compared to branching.