512x512 textura causando tensión enorme GPU en el iPhone, a pesar de alicatado

Question

Estoy probando mi sencilla aplicación OpenGL ES (un juego 2D) en el iPhone y Me he dado cuenta de una alta utilización de rendir mientras se utiliza el generador de perfiles. Estos son los hechos:

• Estoy mostrando sólo una precargado gran textura ( 512x512 píxeles ) a 60 fps y el render de utilización es de alrededor de 40%.
• Mi textura se mezcla usando GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, la única función GL estoy usando .
• He intentado hacer la textura más pequeños y alicatados , lo que no hizo ninguna diferencia .
• Estoy usando un PNG textura atlas de 1024x1024 píxeles

Me parece muy extraño que este una textura es provocando un uso tan intenso de la GPU.

¿Se trata de esperar? ¿Qué estoy haciendo mal?

EDIT: Mi código:

// OpenGL setup is identical to OpenGL ES template
// initState is called to setup
// timer is initialized, drawView is called by the timer

- (void) initState
{
    //usual init declarations have been omitted here        
    glEnable(GL_BLEND); 
    glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);     
    glEnableClientState (GL_VERTEX_ARRAY);
    glVertexPointer     (2,GL_FLOAT,sizeof(Vertex),&allVertices[0].x);          
    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer   (2,GL_FLOAT,sizeof(Vertex),&allVertices[0].tx);     
    glEnableClientState (GL_COLOR_ARRAY);
    glColorPointer      (4,GL_UNSIGNED_BYTE,sizeof(Vertex),&allVertices[0].r);    
}    
- (void) drawView
{       
    [EAGLContext setCurrentContext:context];
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer);

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity();

    GLfloat width  = backingWidth /2.f; 
    GLfloat height = backingHeight/2.f; 

    glOrthof(-width, width, -height, height, -1.f, 1.f);
    glMatrixMode(GL_MODELVIEW);
    glClearColor(0.f, 0.f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);       
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer);       
    [context presentRenderbuffer:GL_RENDERBUFFER_OES];      
    [self checkGLError];        
}

EDIT: He hecho un par de mejoras, pero ninguno logró bajar la utilización de render. He dividido la textura en partes de 32x32, ha cambiado el tipo de las coordenadas y coordenadas de textura de GLfloat a GLshort y ha añadido vértices adicionales para los triángulos degenerativas.

Los cambios son los siguientes:

initstate:     (Vértice y el puntero de la textura son ahora GL_SHORT)

glMatrixMode(GL_TEXTURE);
glScalef(1.f / 1024.f, 1.f / 1024.f, 1.f / 1024.f);
glMatrixMode(GL_MODELVIEW);
glScalef(1.f / 16.f, 1.f/ 16.f, 1.f/ 16.f);

drawView:

glDrawArrays(GL_TRIANGLE_STRIP, 0, 1536); //(16*16 parts * 6 vertices)  

Answer 1

leer este post.

512x512 es probablemente un poco más optimista para el iPhone de tratar.

EDIT:

Asumo que ya ha leído esto, pero si no, comprobar Manzanas guiar a un rendimiento óptimo de OpenGL ES en el iPhone.

Answer 2

Estoy escribiendo una aplicación que muestra cinco 512x512 texturas en uno encima del otro en un entorno 2D usando GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, y puedo obtener alrededor de 14fps. Lo que realmente necesita 60 fps? Para un juego, pensaría 24-30 estaría bien. Además, utilizar la compresión de texturas PVR, si es posible. Hay un ejemplo que hace que se incluye con el SDK.

Answer 3

1. espero que no se olvidó de desactivar GL_BLEND cuando no lo necesita ya.
2. Se puede hacer un intento de optimización de ancho de banda de memoria - 16 utilizar formatos bpp o PVRTC. En mi humilde opinión, con la textura de su tamaño de la textura caché no ayuda en absoluto.
3. No hay que olvidar que el uso de este dispositivo está siendo utilizado como textura por iPhone interfaz de usuario. Si se crea como RGBA de 32 bits que será alfa-mezclado una vez más. Para obtener un rendimiento óptimo de 16 bits 565 framebuffers son el mejor (pero sufre calidad de los gráficos).

No sé todos los detalles, como el tamaño de la caché, pero, supongo, texturas píxeles ya están swizzled cuando se cargan en memoria de vídeo y triángulos están divididos por el motor de baldosas PVR. Por lo tanto su propia división parece ser redundante.

Y, por último. Esto es sólo una GPU de bajo consumo móvil, no está diseñado para pantallas enormes y altos fillrates. Alfa-mezcla es costoso, tal vez 3-4 veces la diferencia en los chips PowerVR.

Answer 4

¿Qué es exactamente el problema?
Usted está recibiendo su 60fps, que es suave como la seda.

A quién le importa si la utilización es hacer que el 40%?

Answer 5

El problema podría ser debido al tamaño de la textura de la caché del iPhone. Simplemente puede bajar a la cantidad de la textura está en cada individuo triángulo, en cuadrante o tristrip, dependiendo de cómo se está configurando estado.

Prueba esto: subdividir el quad y repetir las pruebas. Así que si eres 1 quad, que sea 4. A continuación, 16. y así sucesivamente, y ver si eso ayuda. La clave es reducir el número real de píxeles que cada referencias primitivas.

Cuando la caché textura hace mamar, entonces el hardware thrash búsquedas de textura de la memoria principal en lo VRAM se reserva para la memoria intermedia de textura para cada píxel . Esto puede matar a un rendimiento poderoso rápida.

O - estoy completamente equivocado, porque realmente no sé el hardware del iPhone, y también sé que el chip PVR es un animal extraño en comparación con lo que estoy acostumbrado (PS2, PSP). Aún así es una prueba fácil de tratar y tengo curiosidad si ayuda.