I have created a small OpenGL 3.3 (Core) program using freeglut. The whole geometry is two boxes and one plane with some textures. I can move around like in an FPS and that's it. The problem is I face a big slow down of fps when I make my window large (i.e. above 1920x1080). I have monitors GPU usage when in full-screen and it shows GPU load of nearly 100% and Memory Controller load of ~85%. When at 600x600, these numbers are at about 45%, my CPU is also at full load. I use deferred rendering at the moment but even when forward rendering, the slow down was nearly as severe. I can't imagine my GPU is not powerful enough for something this simple when I play many games at 1080p (I have a GeForce GT 120M btw). Below are my shaders,
First Pass
#VS
#version 330 core
uniform mat4 ModelViewMatrix;
uniform mat3 NormalMatrix;
uniform mat4 MVPMatrix;
uniform float scale;
layout(location = 0) in vec3 in_Position;
layout(location = 1) in vec3 in_Normal;
layout(location = 2) in vec2 in_TexCoord;
smooth out vec3 pass_Normal;
smooth out vec3 pass_Position;
smooth out vec2 TexCoord;
void main(void){
pass_Position = (ModelViewMatrix * vec4(scale * in_Position, 1.0)).xyz;
pass_Normal = NormalMatrix * in_Normal;
TexCoord = in_TexCoord;
gl_Position = MVPMatrix * vec4(scale * in_Position, 1.0);
}
#FS
#version 330 core
uniform sampler2D inSampler;
smooth in vec3 pass_Normal;
smooth in vec3 pass_Position;
smooth in vec2 TexCoord;
layout(location = 0) out vec3 outPosition;
layout(location = 1) out vec3 outDiffuse;
layout(location = 2) out vec3 outNormal;
void main(void){
outPosition = pass_Position;
outDiffuse = texture(inSampler, TexCoord).xyz;
outNormal = pass_Normal;
}
Second Pass
#VS
#version 330 core
uniform float scale;
layout(location = 0) in vec3 in_Position;
void main(void){
gl_Position = mat4(1.0) * vec4(scale * in_Position, 1.0);
}
#FS
#version 330 core
struct Light{
vec3 direction;
};
uniform ivec2 ScreenSize;
uniform Light light;
uniform sampler2D PositionMap;
uniform sampler2D ColorMap;
uniform sampler2D NormalMap;
out vec4 out_Color;
vec2 CalcTexCoord(void){
return gl_FragCoord.xy / ScreenSize;
}
vec4 CalcLight(vec3 position, vec3 normal){
vec4 DiffuseColor = vec4(0.0);
vec4 SpecularColor = vec4(0.0);
vec3 light_Direction = -normalize(light.direction);
float diffuse = max(0.0, dot(normal, light_Direction));
if(diffuse 0.0){
DiffuseColor = diffuse * vec4(1.0);
vec3 camera_Direction = normalize(-position);
vec3 half_vector = normalize(camera_Direction + light_Direction);
float specular = max(0.0, dot(normal, half_vector));
float fspecular = pow(specular, 128.0);
SpecularColor = fspecular * vec4(1.0);
}
return DiffuseColor + SpecularColor + vec4(0.1);
}
void main(void){
vec2 TexCoord = CalcTexCoord();
vec3 Position = texture(PositionMap, TexCoord).xyz;
vec3 Color = texture(ColorMap, TexCoord).xyz;
vec3 Normal = normalize(texture(NormalMap, TexCoord).xyz);
out_Color = vec4(Color, 1.0) * CalcLight(Position, Normal);
}
Is it normal for the GPU to be used that much under the described circumstances? Is it due to poor performance of freeglut?
I understand that the problem could be specific to my code, but I can't paste the whole code here, if you need more info, please tell me.
