One VAO takes more time than more than 40 put together despite being simpler

Question

I was running visual studio's CPU profiling tool when I noticed that of my RenderScene call, my skybox was taking up 30% of the frame time.

This is particularly weird, as as you can see the Object3D::draw call is much less, and I have just one Skybox and 35 Object3Ds.

I went in further and found that glBindVertexArray was taking all of the time. What could be causing this? The VAO in question is defined here:

    glGenVertexArrays(1, &thisVAO);
glBindVertexArray(thisVAO);

//Setup the Vertex buffer
glGenBuffers(1, &vertsVBO);
glBindBuffer(GL_ARRAY_BUFFER, vertsVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*36, skyboxVertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)0);
glEnableVertexAttribArray(0);

and the Skybox Draw call here:

//Shader uniform setting....
    glUseProgram(thisConfig.skyboxShaders->getProgramID());
// ... set view and projection matrix

thisConfig.skyboxShaders->setMats(rs->angle, thisConfig.currLighting->persp);

thisConfig.skyboxShaders->setClipPlane(rs->clipPlane, rs->useClipPlane);

//Actually draw the skybox
glBindVertexArray(thisVAO);

glActiveTexture(GL_TEXTURE0);

glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);

glDrawArrays(GL_TRIANGLES, 0, 36);

Here is visual studio's take on the draw call:

VAOs for Object3D have 5 VBOs and an elements buffer, as opposed to skybox's one VBO, and skyboxVerticies has 96 entries in it for 36 verticies. Most meshes for object3Ds are 1000+ verticies plus, and the Terrain has 48,000. Anything obvious I am missing? The vertex co-ordinates are very large, would that affect the call time for glBindVertexArray()?

Edit : skybox shader

#version 330 core
layout (location = 0) in vec3 aPos;

out of TexCoords;

uniform mat4 projection;
uniform mat4 view;
uniform vec4 clipPlane; // The Plane Clipping
uniform int usePlane; // PLane bool

void main ()
{
    TexCoords = aPos;
    gl_Position = view * vec4 (aPos, 1.0);
}  

Edit : Changing the order has changed things completely, It appears the first glBindVertexArray() per frame has significant overhead (30% of each frame), regardless of shader or vertex array size. Why is this? How can I fix it?

Answer 1

Could just be some flush that gets triggered.

What happens if you switch the order or drawing? First drawing sky then objects, versus first the objects and then the sky?

Also, what does the fragment shader look like for the sky? Maybe it takes a lot of texture samples? Are the objects textured as well?

Last, the skybox covers a lot of pixels, so the fragment shader will be busier than the fragment shader of an object that is small on screen.