Game-Rendering

[TheFabilicious]

Hey Leute, ich habe vor - bzw. bin dabei - ein Spiel zu programmieren. Ich habe allerdings bei einer Sache ein Problem und hoffe, dass ihr mir helfen könnt!

Und zwar ist es in meinem Programm so, dass alle Grafiken in je ein zweidimensionales Integer-Array in form von RBG-Werten gespeichert wird. Also natürlich eigentlich Integers, die die RGB-Werte repräsentieren. Diese Arrays werden dann "zusammengebastelt" so, dass ich ein großes Array habe. Dieses Array - bzw. die RGB-Werte - werden dann Pixel für Pixel auf ein BufferedImage gebracht und dieses wird am Ende ausgegeben.

Den wirklichen Erfolg in der Performance bringt das - wie in Videos und Texten beschworen - allerdings nicht. Mir ist klar, dass bei jedem Frame hunderttausende Schleifendurchläufe stattfinden müssen bei dieser Methode. Trotzdem wird einem dies immer wieder empfohlen.

Habe ich das Prinzip nicht wirklich verstanden oder mache ich einfach Programmtechnisch was falsch oder vielleicht auch beides?

Ich hoffe, dass ihr mir da helfen könnt!

 

[Gucky]

Wo wird das empfohlen? Ich habe das noch nirgendwo gesehen.

Intern wird die Grafik als WritableRaster dargestellt. Wenn du direkt ein Raster (Superklasse von WritableRaster) setzen kannst und nicht den Umweg über das Array machst, dann macht das schon Sinn.

 

[Major_Sauce]

Nabend,

macht auf jeden Fall Sinn, wenn man das richtig macht.
2-Dimensionale Arrays sind hierfür aber schon mal ein ganz falscher Ansatz, die dinger sind viel zu langsam.

Du kannst aber aus einem Eindimensionalen Array einen "Zweidimensionalen" machen, das geht so:

int[] pixels = new int[width * height];

//pixel an der position (10 | 25):
int pixel10_25 = pixels[10 + 25 * width];

Dadurch kannst du das auf einem schnelleren Weg machen.

Insgesamt bringt das Render-System durchaus Vorteile mit sich, die Performance hat sich bei mir um etwa 30% verbessert.
Trotzdem würde ich für Spiele eher JavaFX empfehlen.

So habe ich das ganze gelöst:
https://bitbucket.org/indieversestu...Major_Sauce/Game/ScreenManager.java?at=master

mfg Major

 

[Bananabert]

in java bringt dies kaum einen vorteil mit sich. sobald das raster per hand verändert wird, wird/kann gar nicht bis selten das image optimiert werden. somit liegt dies im ram und wird von der cpu gerendert.

falls du wirklich das rendern selber übernehmen möchtest, schau dir VolatileImages, DoubleBuffering und OpenGL-Based Pipeline mal an.

 

[Major_Sauce]

Würde ich gar nicht behaupten, man muss nur geschickt rendern.
Wichtig ist, dass man nur das rendert, was wirklich gerendert werden muss.
Ich kenne Leute, die Rendern 10 Objekt und malen danach noch fröhlich irgend welche Sachen davor.
Nehmen wir als Beißpiel ein Kinderzimmer.
Wenn du einfach sagst du renderst alle Spielzeuge die auf dem Boden liegen und dann malst du noch einen Schrank, welcher wohl 7 von 10 Spielzeugen verdeckt, dann ist dies nicht effizient.
Immer erst schauen was denn überhaupt gesehen werden kann, ist es überhaupt auf dem Bildschirm oder ist es drüber, drunter, links, rechts davon, wird es durch ein anderes Objekt verdeckt ect.
Es hört sich vielleicht falsch an, denn das sind schon ein paar abfragen und man könnte denken dass es schneller geht einfach zu rendern und fertig, doch dies ist fast nie der Fall.

 

[Finalspace]

Warum nicht direkt die Pixel über getRaster().getData() holen und diese Frame für Frame manipulieren?Kann man auch entsprechend mittels Multithreading optimieren (Tiled-Rendering) falls man Performanceprobleme hat.Eignet sich hervorragend für nen Subpixel-Software-Renderer ;-)