512x512 Texture causant un stress énorme GPU sur iPhone, malgré carrelage

StackOverflow https://stackoverflow.com/questions/872560

Question

Je teste mon implémentation simple OpenGL ES (un jeu 2D) sur l'iPhone et Je remarque une forte utilisation rendre en utilisant le profileur. Ce sont les faits:

  • J'affichage une seule grande préchargé texture ( 512x512 pixels ) à 60fps et le rendu d'utilisation est d'environ 40%.
  • Ma texture est mélangé à l'aide GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, la seule fonction GL J'utilise .
  • J'ai essayé de faire la texture plus petit et le carrelage , ce qui fait aucune différence .
  • J'utilise un atlas de texture PNG de 1024x1024 pixels

Je trouve très étrange que cette une texture est à l'origine d'une telle utilisation du GPU intense.

Est-ce à attendre? Qu'est-ce que je fais mal?

EDIT: Mon code: 

// 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: Je l'ai fait quelques améliorations, mais aucun réussi à réduire le rendu d'utilisation. J'ai divisé la texture dans certaines parties de 32x32, changé le type des coordonnées et les coordonnées de texture de GLfloat à GLshort et a ajouté des sommets supplémentaires pour les triangles dégénératives.

Les mises à jour sont:

initstate:     (Sommet et pointeur de la texture sont maintenant 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)
Était-ce utile?

La solution

Lire la suite.

512x512 est probablement un peu plus optimiste pour l'iPhone à traiter.

EDIT:

Je suppose que vous avez déjà lu, mais sinon vérifier pommes guide pour une performance optimale ES sur iPhone OpenGl.

Autres conseils

J'écris une application qui affiche cinq 512x512 textures sur le dessus de l'autre dans un environnement 2D à l'aide GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, et je peux obtenir environ 14fps. Avez-vous vraiment besoin 60fps? Pour un jeu, je pense que 24-30 serait bien. En outre, utiliser la compression de texture PVR si possible. Il y a un exemple qui le fait inclus dans le SDK.

  1. J'espère que vous ne l'avez pas oublié de désactiver quand vous ne GL_BLEND pas besoin déjà.
  2. Vous pouvez faire une tentative d'optimisation de la bande passante mémoire - utiliser 16 formats de BPP ou PVRTC. À mon humble avis avec votre taille texture cache de texture ne permet pas du tout.
  3. Ne pas oublier que votre framebuffer est utilisé comme texture par l'iPhone interface utilisateur. Si elle est créée en 32 bits RGBA il sera alpha mélangé une fois de plus. Pour des performances optimales 16 bits 565 framebuffers sont les meilleurs (mais la qualité graphique souffre).

Je ne connais pas tous les détails, tels que la taille du cache, mais, je suppose, les pixels de textures sont déjà swizzled fois téléchargés dans la mémoire vidéo et triangles sont divisés par le moteur de tuiles PVR. Par conséquent, votre division semble être redondant.

Et enfin. Ceci est seulement un mobile GPU de faible puissance, ne sont pas conçus pour des écrans géants et hauts fillrates. Alpha-mélange est coûteux, peut-être 3-4 fois la différence sur les puces PowerVR.

Qu'est-ce est exactement le problème?
Vous obtenez votre 60fps, qui est douce et soyeuse.

Qui se soucie si l'utilisation est rendu 40%?

La question pourrait être à cause de la taille du cache de texture de l'iPhone. Il peut simplement venir à combien de la texture est sur chaque triangle individuel, quad ou tristrip, selon la façon dont vous définissez l'état.

Essayez ceci: lotir votre quad et répétez vos tests. Donc, si vous êtes 1 quad, rendre 4. Ensuite 16. et ainsi de suite, et voir si cela aide. La clé est de réduire le nombre réel de pixels que chaque références primitives.

Lorsque le cache de texture est soufflé, le matériel sera thrash texture de lookups mémoire principale dans tout ce que VRAM est mis de côté pour le tampon de texture pour chaque pixel . Cela peut tuer la performance puissante rapide.

OU - Je suis tout à fait tort parce que je ne sais vraiment pas le matériel de l'iPhone, et je sais aussi que la puce PVR est une bête étrange par rapport à ce que je suis habitué (PS2, PSP). il est toujours un test facile d'essayer et je suis curieux de savoir si ça aide.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top