512x512 Textura causando estresse enorme GPU no iPhone, apesar de azulejos

Question

Eu estou testando minha implementação OpenGL ES simples (um jogo 2D) no iPhone e noto uma alta tornar utilização enquanto estiver usando o profiler. Estes são os fatos:

• Eu estou exibindo apenas um pré-carregado grande textura ( 512x512 pixels ) a 60fps e tornar a utilização é de cerca de 40%.
• Minha textura é misturado utilizando GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, a função só GL Estou usando .
• Eu tentei fazer a textura menor e azulejos , o que não fez diferença .
• Eu estou usando um PNG textura atlas de 1024x1024 pixels

Acho muito estranho que este uma textura é fazendo com que tal uso da GPU intensa.

É este de se esperar? O que estou fazendo de errado?

EDIT: Meu 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: Eu fiz um par de melhorias, mas nenhum conseguiu diminuir a utilização render. Eu dividi a textura em partes da 32x32, alterado o tipo das coordenadas e coordenadas de textura de GLfloat para GLshort e acrescentou vértices extras por triângulos degenerativas.

As atualizações são:

initState: (Vértice e ponteiro textura são agora 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

Leia esta postagem.

512x512 é provavelmente um pouco mais otimista para o iPhone para lidar com eles.

EDIT:

Eu suponho que você já leu isso, mas se não verificar Apples guia para óptimo desempenho OpenGL ES no iPhone.

Answer 2

Eu estou escrevendo um aplicativo que exibe cinco 512x512 texturas em cima uns dos outros em um ambiente 2D usando GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, e eu pode obter cerca de 14fps. Você realmente precisa de 60fps? Para um jogo, eu acho 24-30 seria ótimo. Além disso, use PVR compressão de textura, se possível. Há um exemplo que faz isso incluído com o SDK.

Answer 3

1. Eu espero que você não se esqueceu de desativar GL_BLEND quando você não precisa dele já.
2. Você pode fazer uma tentativa de otimização de largura de banda de memória - use 16 formatos bpp ou PVRTC. IMHO com sua textura de cache tamanho de textura não ajuda em tudo.
3. Não se esqueça que o seu framebuffer está sendo usado como a textura por iPhone UI. Se ele é criado como 32 bits rgba será alfa-misturada mais uma vez. Para um desempenho ideal de 16 bits 565 framebuffers são os melhores (mas gráficos sofre de qualidade).

Eu não sei todos os detalhes, tais como o tamanho do cache, mas, suponho, texturas pixels já estão swizzled quando carregado na memória de vídeo e triângulos são divididos por PVR motor de telha. Por conseguinte, sua própria divisão parece ser redundante.

E, finalmente. Este é apenas um móvel GPU baixo consumo de energia, não projetado para telas enormes e altas fillrates. Alpha-mistura é caro, talvez 3-4 vezes diferença em chips PowerVR.

Answer 4

O que é exatamente o problema?
Você está recebendo seus 60 fps, que é suave e sedosa.

Quem se importa se tornar de utilização é de 40%?

Answer 5

A questão poderia ser por causa do tamanho do cache textura do iPhone. Pode simplesmente descer para o quanto a textura é em cada indivíduo triângulo, quad ou tristrip, dependendo de como você está estado de ajuste.

Tente isto: subdividir o seu quad e repetir os testes. Então, se você é um quad, torná-lo 4. Em seguida, 16. e assim por diante, e ver se isso ajuda. A chave é reduzir o número real de pixels que cada referências primitivas.

Quando o cache de textura é soprado, então o hardware vai thrash textura pesquisas da memória principal em qualquer VRAM é retiradas para o buffer de textura para o cada pixel . Isso pode matar o desempenho poderoso rápido.

OR - Estou completamente errado, porque eu realmente não sei o hardware do iPhone, e também sei que o chip PVR é um bicho estranho em comparação com o que eu estou acostumado a (PS2, PSP). Ainda é um teste fácil para tentar e estou curioso se isso ajuda.