Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

SFML 2 - Optimierungen

  • 1
  • 2

Werbeanzeige

Geheim

Treue Seele

  • »Geheim« ist der Autor dieses Themas

Beiträge: 202

Wohnort: Salzburg

Beruf: Schüler

  • Private Nachricht senden

1

03.10.2012, 18:03

SFML 2 - Optimierungen

Hey liebe Community,
Ich habe eine isometrische Map (100x100 Tiles), die in 16 SuperChunks, zu je 25 Chunks, zu je 25 Tiles aufgeteilt ist, aber es läuft nicht so flüssig wie geplant!
Meine Frage also: Gibt es Möglichkeiten irgendetwas zu optimieren, damit es flüssiger geht? Ich dachte da vielleicht ans Rendern, weil das ja am meisten Ressourcen kostet? Also ob man da vielleicht mit OpenGL was machen kann, ich render nämlich ganz normal mit draw();

Ein anderer Vorschlag wäre ein Array von den Tiles zu haben und dann auszurechnen welches Tile innerhalb der Kamera ist, nur weiß ich nicht ob das schneller/besser ist?

MfG Geheim!

DeKugelschieber

Community-Fossil

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

2

03.10.2012, 18:31

Aus OpenGL Sicht könntest du die Daten deiner Tiles die wohl einzeln (?) gerendert werden in Buffern zusammen fassen... Und ansonsten halt nicht benötigte Chunks wegcullen.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Geheim

Treue Seele

  • »Geheim« ist der Autor dieses Themas

Beiträge: 202

Wohnort: Salzburg

Beruf: Schüler

  • Private Nachricht senden

3

03.10.2012, 18:41

Ja ich zeichne sie einzeln...
Sind das dann die VBO´s ? Wenn ja kennst du/ihr etwas, wo ich mir das gut ansehen kann?
Ich kenn mich ja noch nicht wirklich mit dem aus, ist culling etwas von OpenGL oder nennt man das so wenn man nicht-sichtbare Bereiche "abschneidet"?

Das tue ich zurzeit eh (also nicht-sichtbare Chunks werden nicht gezeichnet), nur kommt mir das so aufwendig vor, immer zu prüfen, ob ein Chunk gesehen wird oder nicht (im Sinne von Rechenaufwendig)... Mache ich sonst alles richtig damit?

eXpl0it3r

Treue Seele

Beiträge: 386

Wohnort: Schweiz

Beruf: Professional Software Engineer

  • Private Nachricht senden

4

03.10.2012, 19:32

  1. Profile deine Appliation, zum sehen wo am Meisten Zeit verloren wird.
  2. Verwende sf::VertexArray wenn du das nicht bereits machst.
  3. Für mehr Hilfe, gibt mehr Informationen wie du was im Moment machst. ;)
Blog: https://dev.my-gate.net/
—————————————————————————
SFML: https://www.sfml-dev.org/
Thor: http://www.bromeon.ch/libraries/thor/
SFGUI: https://github.com/TankOs/SFGUI/

Geheim

Treue Seele

  • »Geheim« ist der Autor dieses Themas

Beiträge: 202

Wohnort: Salzburg

Beruf: Schüler

  • Private Nachricht senden

5

03.10.2012, 19:45

Ich weiß leider nicht genau wo das Problem liegt, ich dachte das löst sich mit der Einteilung in die Chunks :/
Es wird denk ich viel Zeit benötigt um zu schauen, welcher Chunk denn überhaupt gesehen wird, aber das kann man doch nicht vermeiden?

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

for(std::list<Chunk>::iterator iChunk=chunkList.begin(); iChunk!=chunkList.end(); ++iChunk)
{
    //Wenn die Chunks innerhalb der Kamera sind, werden sie gezeichnet
    if((*iChunk).getPosition().x - (*iChunk).getchunkWidth() < camera.getCenter().x + camera.getSize().x &&
        (*iChunk).getPosition().x + (*iChunk).getchunkWidth() > camera.getCenter().x - camera.getSize().x &&
        (*iChunk).getPosition().y  - (*iChunk).getchunkWidth() < camera.getCenter().y + camera.getSize().y &&
        (*iChunk).getPosition().y + (*iChunk).getchunkHeight() > camera.getCenter().y - camera.getSize().y)
    (*iChunk).render();
}


Das zeichnen braucht halt so lange und da dachte ich gibt es bessere Methoden ;)

DeKugelschieber

Community-Fossil

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

6

03.10.2012, 19:55

Das sieht eigentlich nicht besonders rechenintensiv aus. Du hast in deiner Chunk Klasse eine render() Methode? Wie sieht die denn aus?
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

eXpl0it3r

Treue Seele

Beiträge: 386

Wohnort: Schweiz

Beruf: Professional Software Engineer

  • Private Nachricht senden

7

03.10.2012, 20:14

Ins blaue Raten ist nicht was man unter 'profilen' versteht... :rolleyes:
Google mal nach einem Profiler für dein OS/IDE und dann wirst du genau wissen wo die meiste Zeit verbracht wird und du wirst auch sehen, ob deine clipping 'Funktion' effizient ist oder nicht.

Meh mag das nicht übersetzen (von hier).

Zitat von »eXpl0it3r«

As far as I can see the 8 additions/subtractions and the 4 checks aren't really that time consumption. A time wasting part could be the iteration of a std::list, but if it's really the thing that slows down the application can't really be said...
Also you could optimize things a bit by calculating the camera Center -+ Size once and then check against a temporary variable. The camera should move in the meantime shouldn't it? So you'd get 4*n additions less and 8*(2)*n function calls less.
Blog: https://dev.my-gate.net/
—————————————————————————
SFML: https://www.sfml-dev.org/
Thor: http://www.bromeon.ch/libraries/thor/
SFGUI: https://github.com/TankOs/SFGUI/

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »eXpl0it3r« (03.10.2012, 20:20)

Geheim

Treue Seele

  • »Geheim« ist der Autor dieses Themas

Beiträge: 202

Wohnort: Salzburg

Beruf: Schüler

  • Private Nachricht senden

8

03.10.2012, 20:25

@DeKugelschieber:
(Objekte kann man mit der Maus auf den Tiles platzieren, aber auch wenn kein Objekt da ist, läuft es nicht flüssig genug)

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10

void Chunk::render()
{
    //Zeichnet alle Tiles
    for(std::list<Tile>::iterator iTile=tileMap.begin(); iTile!=tileMap.end(); ++iTile)
        (*iTile).render();

    //Zeichnet die Objekte
    for(std::list<Object>::iterator iObject=objectList.begin(); iObject!=objectList.end(); ++iObject)
        (*iObject).render();
}


@eXpl0it3r:
Ja da hast du wohl recht, werd ich machen! Die Kamera kann bewegt werden ;)

Nimelrian

Alter Hase

Beiträge: 1 216

Beruf: Softwareentwickler (aktuell Web/Node); Freiberuflicher Google Proxy

  • Private Nachricht senden

9

03.10.2012, 20:32

Darf ich die Übersetzung übernehmen?

Zitat


Soweit ich das sehe sind die 8 Additionen/Subtraktionen und die 4 Überprüfungen nicht wirklich zeitverschlingend. Ein zeitfressender Teil könnte der Durchgang der std::list sein, aber das kann man nicht genau sagen.
Du könntest das ganze insofern optimieren, als dass du CameraCenter +- Size jeweils einmal berechnest, diese in temp. Variablen speicherst und immer damit vergleichst. Die Kamera kann sich ja in der Zwischenzeit bewegen, oder nicht? Damit hättest du 4*n Additionen und 8*(2)*n Funktionsaufrüfe weniger.
Ich bin kein UserSideGoogleProxy. Und nein, dieses Forum ist kein UserSideGoogleProxyAbstractFactorySingleton.

DeKugelschieber

Community-Fossil

Beiträge: 2 641

Wohnort: Rheda-Wiedenbrück

Beruf: Software-Entwickler

  • Private Nachricht senden

10

03.10.2012, 22:03

Ok, ich kenn mich mit SFML nicht aus, aber das sieht so aus als würde für jedes Tile tatsächlich auch ein draw call OpenGL intern an die Graka gesendet werden. Das geht natürlich nicht für größere Karten. Ich weiß aber auch nicht was für Möglichkeiten du jetzt mit SFML hast deine Objekte als Buffer zusammenzufassen.
Grüße, Kugel

GitHub Meine Firma Pirsch Analytics

Werbeanzeige

  • 1
  • 2

Ähnliche Themen