Double-Buffering zu langsam

[JeffChef]

Tach erstmal,

hab dieses Forum bei Google gefunden und hoffe ihr könnt mir helfen.

Es geht ums Double-Buffering bei Java. Funktioniert alles super, nur macht es mein Programm
extrem langsam.

Graphics bufferGraphics;
Image offscreen;

offscreen = createImage(800, 600);
bufferGraphics = offscreen.getGraphics();

public void paint(Graphics g){
	bufferGraphics.drawImage(nbg, 0, 0, this);
	..
	g.drawImage(offscreen, x, y, this);
	..

Das ist jetzt so langsam, das alle Animationen in Zeitlupe ablaufen.
Gibts nicht ne möglichkeit für Flackerfreie Animationen die auch
normal laufen?

Vielen Dank

Mfg

Jeff

 

[Ark]

Double Buffering allein wird wohl nie Schuld daran sein, dass etwas zu langsam ist. Soll heißen: Wir brauchen mehr Code, wenn wir dein Problem beheben wollen.

Außerdem ist die Art und Weise des Aufrufs von repaint-Methoden auch entscheidend. Auch die richtige Verwendung von Threads gibt viel her.

MfG
Ark

 

[Guest]

Nagut, ich werde mal versuchen das Problem zu beschreiben.
Es geht um einen Ball der in einer 2D-Umgebung umher springt.

Die Fläche ist 1024x768 groß. Es befinden sich noch andere Objekte in der Umgebung,
auf die der Ball treffen kann und so reflektiert wird.

Graphics bufferGraphics;
Image offscreen;
offscreen = createImage(programSizeX, programSizeY);
bufferGraphics = offscreen.getGraphics();
bufferGraphics.fillRect(0, 0, programSizeX, programSizeY);
repaint();

public void paint(Graphics g){
	// Lösche alte Position des Balles und des Reflektors
	bufferGraphics.setColor(new Color(0, 0, 0));
	bufferGraphics.fillRect((int)(nBall.getPunkt().getPosX()), 				
             (int)(nBall.getPunkt().getPosY()), nBall.getSize(), nBall.getSize());
	bufferGraphics.fillRect((int)(nReflekt.getPunkt().getPosX()), 
             (int)(nReflekt.getPunkt().getPosY()), 
	     (int)(nReflekt.getSizeX()), (int)(nReflekt.getSizeY()));
	    
	updatePositions();
	    
	bufferGraphics.setColor(new Color(255, 255, 255));
	bufferGraphics.fillRect((int)(nBall.getPunkt().getPosX()),
             (int)(nBall.getPunkt().getPosY()), nBall.getSize(), nBall.getSize());
	    
	// Zeichne den Reflektor
	bufferGraphics.setColor(new Color(255, 255, 255));
	bufferGraphics.fillRect((int)(nReflekt.getPunkt().getPosX()), 		
             (int)(nReflekt.getPunkt().getPosY()), 
	     (int)(nReflekt.getSizeX()), (int)(nReflekt.getSizeY()));
	    
        g.drawImage(offscreen, programStartPointX, programStartPointY, this); 
        repaint();
}

Das Problem liegt bei dem Double-Buffering. Ohne ist es so schnell, das ich
den Programmablauf mit thread.sleep verlangsamen musste, um überhaupt was zu erkennen.

Habe meinen Code schon "schneller" bekommen. Anstelle den ganzen Bildschirm zu überschreiben,
überschreibe ich jetzt nur noch die alten Positionen der geänderten Objekte.

Viel hilft es aber nicht. Ist immernoch Zeitlupe.. von der flimmernden Version ohne Double-Buffering ist es weit weit entfernt.

 

[Ark]

Meiner Ansicht nach sind paint- und paintComponent-Methoden gerade die Performanzkiller, wenn sie schlecht programmiert sind. Darum sollte man

a) das Rendering in einen Thread auslagern
b) nur das neu zeichnen, was wirklich notwendig ist (der Bereich muss natürlich leicht zu berechnen sein )
c) so viele Informationen wie möglich so weit wie möglich komplett berechnet puffern (d. h. auch so wenig Objekte erzeugen oder Methoden aufrufen wie möglich)
d) alle Farbinformationen bzw. Bilder so speichern, dass sie mit allen Farbräumen und Farbmodellen kompatibel sind
e) direkt auf Raster schreiben, wenn möglich
f) überhaupt nur so viel wie nötig und so wenig wie möglich zeichnen (d. h. auch nicht häufiger als unbedingt notwendig Bereiche mehrfach zeichnen)
g) setDoubleBuffered(boolean) und setIgnoreRepaint(boolean) so sinnvoll wie möglich einsetzen.

Gehe einfach mal alle genannten Punkte durch und entferne unbedingt den repaint()-Aufruf am Ende von paint()!!!

MfG
Ark

 

[L-ectron-X]

Das Ganze ist auch verkehrt aufgezogen.
Beim DoubleBuffering wird die Hauptarbeit in der update()-Methode gemacht, die ich bei dir nicht sehe.
In der update()-Methode werden die Grafik-Objekte in einem Offscreen-Speicherbereich (quasi im Hintergrund) vorbereitet und auf ein Offscreen-Immage gezeichnet. In der letzten Zeile der update()-Methode wird dann das Offscreen-Immage auf den Bildschirm kopiert.
Die paint()-Methode besteht hier selten aus mehr als 3 Zeilen. Die hat die Aufgabe nur zu zeichnen, es sollten dort keine vorbereitenden Berechnungen gemacht werden.

Zu diesem Thema gibts (auch von mir) reichlich (ausführbaren) Beispielcode.
Bitte dazu mal die Forumsuche benutzen.