[Resolvido] Dúvida em OpenGL/GLSL

[ProgramadorEstúpido]

🙂 Boa noite. Aqui vai a minha primeira dúvida:

Eu costumava utilizar a linguagem shader Nvídia Cg para programar com VBOs em C++/OpenGL. Mas, infelizmente, o Nvídia Cg já passou à história. O próprio site da Nvídia dedicado ao Cg toolkit ( https://developer.nvidia.com/cg-toolkit ) já deixou bem claro que não haverá mais actualizações do Cg, e recomenda a utilização do GLSL para o OpenGL, e do HLSL para o DirectX.

Posto isto não tive alternativa senão começar a utilizar o GLSL. Tenho que concordar que o GLSL é de mais fácil utilização do que o Cg. Mas quando converti os exemplos de Cg para GLSL, reparei que houve uma diminuição significativa do desempenho. Por exemplo, num dado exemplo, em Cg, a velocidade de desempenho era de 120 frames por segundo. Quando passei o mesmo exemplo para GLSL, a velocidade de desempenho baixou para 82 frames por segundo!

Mas não é tudo... Se eu dividir um VBO em vários sub-VBOs mais pequenos, a velocidade de desempenho aumenta em GLSL e diminui em Cg!

E se eu utilizar "GL_UNSIGNED_SHORT" em vez de "GL_UNSIGNED_INT" em "glDrawElements()", a velocidade de desempenho aumenta em GLSL, enquanto que em Cg não há alterações!

Pensei que isto acontecia devido a eu utilizar a versão 1.2 do GLSL (versão standard). Como tenho o OpenGL 3.3, experimentei a versão 3.3 do GLSL, mas sucedeu exactamente a mesma coisa!

há um pormenor que tenho que referir: A minha GPU é uma GeForce 315M da Nvídia. E a minha versão GLSL é a 3.30 Nvídia via compilador de Cg. VIA COMPILADOR DE Cg??? Quer dizer que na minha GPU é o compilador de Cg que faz a compilação do GLSL??? Será esta a causa das discrepâncias que eu noto entre o GLSL e o Cg??

Agradecia muito que esclarecessem esta minha dúvida... 😞

Edited April 14, 2014 at 09:40 PM by ProgramadorEstúpido

[ProgramadorEstúpido]

Esqueci-me de dizer que o meu sistema operativo é o Windows 7 Home Premium.

Alguém que me esclareça esta dúvida por favor... 😞

[HappyHippyHippo]

eu não percebo é a admiração ...

são tecnologias que são diferentes (se bem com o mesmo intuito) onde uma não tem desenvolvimento pelo menos à um ano enquanto que a outra é suportada ainda hoje com novos drivers e afins ...

[ProgramadorEstúpido]

eu não percebo é a admiração ...

são tecnologias que são diferentes (se bem com o mesmo intuito) onde uma não tem desenvolvimento pelo menos à um ano enquanto que a outra é suportada ainda hoje com novos drivers e afins ...

Sim, é verdade. Mas é normal o que está a acontecer (a discrepância entre a velocidade de desempenho entre as duas, 128 fps para o Cg e 82 fps para o GLSL) ou então estarei a fazer alguma coisa errada? Essa é que é a minha dúvida. Aliás, se o GLSL continua a ser suportado com novos drivers e afins, porque é que tende a ter uma velocidade de desempenho menor do que o Cg? De qualquer maneira aqui vai o código dos meus shaders em GLSL:

vertex shader:

// skin.vert
#version 120
#ifndef MAX_BONES
#define MAX_BONES 100
#endif

struct light_t
{
vec3 position;
vec3 color;
};

struct material_t
{
vec3 Ke;
vec3 Ka;
vec3 Kd;
vec3 Ks;
float shininess;
};

// Input data
attribute vec4 position;
attribute vec3 color;
attribute vec2 texCoord;
attribute vec3 normal;// Output data
varying vec2 fragTexCoord;
varying vec4 fragColor;

// Constant data
uniform mat4	 boneMatrix[MAX_BONES];
uniform mat4	 modelViewProj;
uniform vec3	 globalAmbient;
uniform light_t light;
uniform vec3	 eyePosition;
uniform material_t material;
uniform int	 noColor;

void main()
{
vec3 weight = color,		 // 0.0078125 = 1.0 / 128.0
boneIndex = position.w * vec3(0.0078125, 1.0, 128.0);

boneIndex = (boneIndex - floor(boneIndex)) * 128.0;

mat4 matTransform = boneMatrix[int(boneIndex.x)] * weight.x +
				 boneMatrix[int(boneIndex.y)] * weight.y +
				 boneMatrix[int(boneIndex.z)] * weight.z;

vec4 objPos = matTransform * vec4(position.xyz, 1.0),

objNormal = matTransform * vec4(normal,	 0.0);

fragTexCoord = texCoord;
gl_Position = modelViewProj * objPos;

if (noColor == 1)
fragColor = vec4(0.25f, 0.25f, 0.25f, 1);
else
{
vec3 P = objPos.xyz,
 N = objNormal.xyz,
 // Compute the diffuse term
 L = normalize(light.position - P);
float diffuseLight = max(dot(N, L), 0);
vec3 diffuse = material.Kd * light.color * diffuseLight,
 // Compute the specular term
 V = normalize(eyePosition - P),
 H = normalize(L + V);
float specularLight = pow(max(dot(N, H), 0),
	 material.shininess);

if (diffuseLight <= 0)
specularLight = 0;

vec3 specular = material.Ks * light.color * specularLight; fragColor.xyz = material.Ke + material.Ka * globalAmbient +
		 diffuse + specular;
fragColor.w = 1;
}
}

fragment shader:

// skin.frag
#version 120

// Interpolated values from the vertex shaders
varying vec2 fragTexCoord;
varying vec4 fragColor;

// Constant data
uniform int	 texture;
uniform sampler2D decal;

void main()
{
gl_FragColor = (texture == 1) ?
		 fragColor * texture2D(decal, fragTexCoord):
		 fragColor;
}

Edited April 15, 2014 at 07:54 PM by ProgramadorEstúpido

[HappyHippyHippo]

estas a comparar um exemplo.

basta usar outros dois exemplos que tu próprio apresentaste no primeiro post para contrabalançar esse problema:

Se eu dividir um VBO em vários sub-VBOs mais pequenos, a velocidade de desempenho aumenta em GLSL e diminui em Cg!

E se eu utilizar "GL_UNSIGNED_SHORT" em vez de "GL_UNSIGNED_INT" em "glDrawElements()", a velocidade de desempenho aumenta em GLSL, enquanto que em Cg não há alterações!

como vez, optimização é sempre um problema muito complicado e é por isso que sempre que sai um novo jogo AAA, lá vem mais uns drivers da responsabilidade da gráfica e não do software ...

[ProgramadorEstúpido]

estas a comparar um exemplo.

basta usar outros dois exemplos que tu próprio apresentaste no primeiro post para contrabalançar esse problema:

como vez, optimização é sempre um problema muito complicado e é por isso que sempre que sai um novo jogo AAA, lá vem mais uns drivers da responsabilidade da gráfica e não do software ...

Ok. Já compreendi o que quiseste dizer. Estou esclarecido. Obrigado. 👍

Edited April 15, 2014 at 08:54 PM by ProgramadorEstúpido