512x512 Textur verursacht großen GPU Stress auf iPhone, trotz Fliesen

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

Frage

ich meine einfache OpenGL ES Implementierung Testen (ein 2D-Spiel) auf dem iPhone und Ich stelle fest, eine hohe Render Nutzung , während der Profiler. Das sind die Fakten:

  • Ich bin die Anzeige nur eine vorgespannte große Textur ( 512x512 Pixel ) bei 60fps und der Render-Auslastung ist um 40%.
  • Meine Textur gemischt wird mit GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, der einzigen GL Funktion Ich bin mit .
  • Ich habe versucht, die Textur kleine und Fliesen zu machen, die machte keinen Unterschied .
  • Ich bin ein PNG Texturatlas von 1024x1024 Pixel mit

Ich finde es sehr seltsam, dass diese eine Textur ist eine so intensive GPU Nutzung verursacht.

Ist das zu erwarten? Was mache ich falsch?

EDIT: Mein 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: Ich habe ein paar Verbesserungen vorgenommen, aber keiner es geschafft, die Render Nutzung zu senken. Ich habe die Textur in Teilen von 32x32 geteilt, veränderte die Art der Koordinaten und Textur von GLfloat zu GLshort koordiniert und hinzugefügt zusätzlichen Scheitelpunkten für degenerative Dreiecken.

Die Updates sind:

Initstate:     (Vertex und Textur Zeiger sind jetzt 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)
War es hilfreich?

Lösung

diesen Beitrag lesen.

512x512 ist wahrscheinlich ein wenig mehr als optimistisch für das iPhone zu behandeln.

EDIT:

Ich nehme an, Sie haben diese schon gelesen, aber wenn nicht, überprüfen Führung OpenGl ES Leistung auf dem iPhone.

, um eine optimale

Andere Tipps

Ich schreibe eine App, die in einer 2D-Umgebung voneinander fünf 512x512 Texturen über zeigt mit GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, und ich kann über 14fps bekommen. Benötigen Sie wirklich 60fps? Für ein Spiel, würde ich denken, 24-30 wäre in Ordnung. Verwenden Sie auch PVR-Texturkomprimierung, wenn überhaupt möglich. Es gibt ein Beispiel, das tut es mit dem SDK enthalten.

  1. Ich hoffe, dass Sie nicht vergessen GL_BLEND zu deaktivieren, wenn Sie es nicht schon brauchen.
  2. Sie können einen Versuch machen, bei der Speicherbandbreitenoptimierung - verwenden 16 bpp-Formate oder PVRTC. IMHO mit Texturgröße Textur-Cache gar nicht helfen.
  3. Vergessen Sie nicht, dass Ihr Framebuffer wird von iPhone UI als Textur verwendet wird. Wenn es als 32-Bit-RGBA erstellt wird, wird es Alpha-gemischt ein weiteres Mal sein. Für eine optimale Leistung ist 16-Bit-565-Framebuffer der beste (aber Grafikqualität leidet).

Ich weiß nicht, alle Details, wie Cache-Größe, aber, glaube ich, sind Texturen Pixel bereits umgestellt, wenn sie in Videospeicher hochgeladen und Dreiecke werden durch PVR Fliese Motor aufgeteilt. Deshalb ist ihre eigene Spaltung scheint überflüssig zu sein.

Und schließlich. Dies ist nur ein mobiler Low-Power-GPU, nicht für große Bildschirme und hohe fillrates gestaltet. Alpha-Blending ist teuer, vielleicht 3-4 mal Unterschied auf PowerVR-Chips.

Was genau ist das Problem?
Sie bekommen Ihre 60fps, die glatt seidig.

Wer kümmert sich, wenn machen Auslastung 40% ist?

Das Problem tritt aufgrund des Textur-Cache-Größe des iPhone sein könnte. Es kann einfach kommen, um wie viel der Textur ist auf jedem einzelnen Dreieck, Quad oder tristrip, je nachdem, wie Sie Zustand sind einstellen.

Versuchen Sie folgendes: Ihr Quad unterteilen und die Tests wiederholen. Also, wenn Sie ein Quad sind, macht es 4. Dann 16 und so weiter, und sehen, ob das hilft. Der Schlüssel ist, die tatsächliche Anzahl der Pixel, die jedes Grundelement Referenzen zu reduzieren.

Wenn die Textur-Cache geblasen wird, dann wird die Hardware Textur Lookups aus dem Hauptspeicher drischt in dem, was VRAM wird aufgehoben für die Texturpuffer für jedes Pixel . Dies kann die Leistung tötet mächtig schnell.

oder - Ich bin völlig falsch, weil ich wirklich das iPhone Hardware weiß es nicht, und ich weiß auch, dass der PVR-Chip ist ein seltsames Tier im Vergleich zu dem, was ich (PS2, PSP) verwendet werde. es ist immer noch ein einfacher Test, um zu versuchen, und ich bin gespannt, ob es hilft.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top