Estoy bastante desconcertado con el pobre rendimiento que estoy viendo al dibujar un fondo de pantalla completa usando una malla de triángulo texturizado en OpenGL: dibujando solo el fondo y nada más se maximiza en 40 fps usando el sombreador más básico y 50 fps usando la tubería predeterminada.Textura de fondo de pantalla completa con problema de rendimiento OpenGL (iPad)
Mientras que 40 fps no parece tan malo, agregar algo más encima de eso hace que los fps caigan, y teniendo en cuenta que necesito dibujar 100-200 mallas adicionales encima de eso, termino con un miserable 15 fps eso simplemente no es utilizable
me han aislado el código correspondiente a un proyecto de XCode disponibles here, pero la esencia de la misma es el ejemplo de mapa de textura canónica:
static const GLfloat squareVertices[] = {
-1.0f, -1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
};
static const GLfloat texCoords[] = {
0.125, 1.0,
0.875, 1.0,
0.125, 0.0,
0.875, 0.0
};
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
if ([context API] == kEAGLRenderingAPIOpenGLES2) {
// Use shader program.
glUseProgram(program);
glActiveTexture(GL_TEXTURE0);
glUniform1i(uniforms[UNIFORM_TEXTURE], 0);
glBindTexture(GL_TEXTURE_2D, texture);
// Update attribute values.
glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices);
glEnableVertexAttribArray(ATTRIB_VERTEX);
glVertexAttribPointer(ATTRIB_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);
glEnableVertexAttribArray(ATTRIB_TEXCOORD);
} else {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glVertexPointer(2, GL_FLOAT, 0, squareVertices);
glEnableClientState(GL_VERTEX_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
El vertex shader:
attribute lowp vec4 position;
attribute lowp vec2 tex;
varying lowp vec2 texCoord;
uniform float translate;
void main()
{
gl_Position = position;
texCoord = tex;
}
El fragment shader :
varying lowp vec2 texCoord;
uniform sampler2D texture;
void main()
{
gl_FragColor = texture2D(texture, texCoord);
}
División del tamaño del rectángulo en dos duplica la velocidad de cuadros, por lo que el tiempo de renderización depende claramente de la propiedad inmobiliaria que el dibujo adopta en la pantalla. Esto tiene sentido, pero lo que no tiene sentido para mí es que no parece posible cubrir toda la pantalla con mallas con textura de OpenGL a más de 15 fps.
Sin embargo, hay cientos de juegos que lo hacen, por lo que es posible y debo estar haciendo algo mal, pero ¿qué es?
FWIW, ¿por qué está habilitando el estado del cliente después de realizar las llamadas pertinentes? (Por ejemplo, llamar al puntero vértice antes de habilitar matrices vert) –
En realidad, la mayor parte del código pertenece a la plantilla predeterminada para una aplicación para iPad OpenGL ES, lo que no significa que sea un buen código, pero siempre que funcionó, no me pregunté si tiene sentido hacerlo de esta manera u otra :-) –