Physik-Simulation: Bekomme Flackern nicht unter Kontrolle

[Jazzman_Marburg]

Hallo Gemeinde,
es ist zum Haareraufen. Ich vermute ich habe da wohl etwas missverstanden mit DoubleBuffered, BitBlt & Co. Vielleicht habt ihr eine Idee woran es liget.
Hierum geht es: Freier Fall einer Kugel.

Auf dem Panel1 liegt ein TImage (Image1) mit der selben Größe. Auf das Canvas des Image1 zeichne ich im OnPaint Event ein Gitter. Auf diesem Image1 liegt ein kleineres Image2. Darin möchte ich einen Kreis zeichnen und über das Gitter bewegen. Soweit so gut.

Ich habe eine Klase TBall der ich ich beide Images als Parameter übergebe. Ich erzeuge in der Klasse einen BackBuffer vom Typ TBitMap mit den selben Ausmaßen wie das Image2. Ich zeichne nun in den BackBuffer einen Kreis und kopiere mit BitBlt den BackBuffer in das Image2. Soweit auch ok. D.h. beim Start des Programm sieht man ein Gitter und im Vordergrund einen roten Kreis.

Auf der Hauptform liegt ein Timer (Intervall 50 ms). In der Timer Loop steht nur Ball.Move. Diese Methode der Klasse TBall berechnet nun die neuen Koordinaten des Image2, und kopiert wiederum den BackBuffer mit BitBlt in das Image2. (Dieser Kopier-Schrit ist z.Z. unnötig, da der Kreis z.Z. sein Aussehen noch nicht verändert, aber sei es drum)

Auf dem Screen sieht man nun wie die Kugel (Kreis) nach unten fällt -- aber es flackert! Man kann kaum hinsehen.

Dem Panel1 auf dem Image1 (Gitter-Bild) und Image2 (Kreis) liegt habe ich ein DoubleBuffer := TRUE spendiert. Folge: Keine - Flackern geht munter weiter.
Irgendwie habe ich das Gefühl, weder die Verwendung des BackBuffers noch des DoubleBuffer hat irgendeine Wirkung -- auch einzeln nicht. Selbst der Form1 habe ich eine DoubleBuffer spendiert -- Null Wirkung.

Ich steh auf'm Schlauch.

Vielleicht gibt es ja jemanden im Forum, der gerade kein Fußball schaut... und der Präsident ist auch schon gewählt und die Formel1, naja.

Vielen Dank
Jazzamn

[mkinzler]

Ich würde eine PaintBox statt Panel und Image verwenden

[Namenloser]

Visuelle Komponenten sind für solche Vorhaben ungeeignet. Zeichne deine Kugeln stattdessen selbst. Du nimmst, wie mkinzler sagt, eine Paintbox, und klatscht sie auf dein Form. Dann erzeugst du per Code in unsichtbares TBitmap, das die gleiche Größe wie die Paintbox haben sollte. Per Bitmap.Canvas kannst du auf dieses Bitmap deine Kugeln (oder was auch immer) zeichnen. Das Bitmap überträgst du dann mit BitBlt auf die Zeichenfläche deiner Paintbox.

[stoxx]

das was NamenLozer sagt, ist völlig korrekt.

Wenn Dich außerdem noch stört, dass die Paintbox beim vergrößern eines Fensters flackert, dann nimm

TWinPaintbox von der Seite ... (da wird das Neuzeichnen unterdrückt)

http://www.pjh2.de/delphi/units/index.php

Durchaus möglich, dass TWinPaintbox auch für Deine Anwendung schon gar nicht mehr flackert.
Bedenke aber, dass das wesentlich schneller ist wenn Du erst auf einem eigenem Hintergrundbitmap arbeitest, und dann auf das Canvas der Paintbox oder Image kopierst ...
so wie es Namenlozer vorgeschlagen hat ...

[Jazzman_Marburg]

Tach auch!

Was für ein Missverständnis! Das liegt sicher an meiner Beschreibung...

>Visuelle Komponenten sind für solche Vorhaben ungeeignet. Zeichne deine Kugeln stattdessen selbst.
Selbstzeichnen? Tu ich doch! Mit BackBuffer.Canvas.Ellipse(); Das ist doch der Sinn des BackBuffers.

>Dann erzeugst du per Code in unsichtbares TBitmap
Das BackBuffer wird doch in der Klasse TBall erzeugt und ist unsichtbar! Es übernimmt nur die Ausmaße des übergebenen TImages.

>das die gleiche Größe wie die Paintbox haben sollte.
Siehe oben.

>Per Bitmap.Canvas kannst du auf dieses Bitmap deine Kugeln(oder was auch immer) zeichnen.
Siehe oben.

>Das Bitmap überträgst du dann mit BitBlt auf die Zeichenfläche deiner Paintbox.
Siehe mein 1. Thread.

Das was Du vorschlägst ist genau mein Vorgehen - habs wahrschenlich dumm beschrieben.

Und trotzdem: Es flackert wie verrückt.

Aber, dass ihr mein Vorgehen so bestätigt macht die Sache nun einfacher.

Vielen Dank für eure Mühe -- vielleicht hat ja noch jemand eine Idee.

Gruss, Jazzamn

[jfheins]

Zitat von Jazzman_Marburg:

Auf diesem Image1 liegt ein kleineres Image2.

Das zeigt, dass du den Sinn hinter dem Offscreenbitmap nicht verstanden hast.

Du sollst alles auf ein Bitmap zeichnen und das dann erst auf ein Canvas kopieren (vorzugweise Paintbox) und nicht alle Einzelteile in seperate Images laden.

[Jazzman_Marburg]

>Das zeigt, dass du den Sinn hinter dem Offscreenbitmap nicht verstanden hast.

Ich dachte ich hätte die durch meine Anfangsfrage vorweggenommen.

>Du sollst alles auf ein Bitmap zeichnen und das dann erst auf ein Canvas kopieren (vorzugweise Paintbox) und nicht alle Einzelteile in seperate Images laden.

Meine Idee war es das Gitternetz unabhängig von den Grafik-Objekten, die sich darauf bewegen zu halten. Das Gitternetz auf Image1 sollte so eine "Folie" sein, auf der z.B. ein Achsenkreuz gezeichnet ist - das Image2 sollte eine Grafifobjekt (Kreis), wleches sich auf Image1 bewegt.

Vielen Dank
Jazzman

[jfheins]

Dann mach sowas:

Delphi-Quellcode:

var
MyBitmap: TBitmap;
Gitternetz: TGrid;
Ball: TBall;

// FormCreate oder so
begin
  MyBitmap := TBitmap.Create();
  Gitternetz := TGrid.Create(MyBitmap);
  Ball := TBall.Create(MyBitmap);
end;

// OnTimer oder so
begin
Ball.Step(deltaT);

MyBitmap.Clear();
Gitternetz.Paint();
Ball.Paint();
BitBlt({MyBitmap => Paintbox});
end;

Aber auf jeden Fall alle Sachen draufzeichnenj und dann erst ein einziges Bitmap anzeigen

[Jazzman_Marburg]

Hallo jfheins,
dankeschön für Deinen Vorschlag!

Hierzu noch mal eine kleine Nachfrage.

Du schlägst vor:
---------------------------------
// OnTimer oder so
begin
Ball.Step(deltaT);

MyBitmap.Clear();
Gitternetz.Paint();
Ball.Paint();
BitBlt({MyBitmap => Paintbox});
end;
---------------------------------

Das würde doch bedeuten, dass bei jedem Pixel um das sich der Ball bewegt, wird
1. Das gesamte "Spielfeld" gelöscht.
2. Das Gitternetz neu gezeichnet
3. Der Ball auf dem Gitternetz gezeichnet
4. Schlussendlich der OffScreen auf das sichtabre Canvas gezeichnet.

Ich frage mich ob der Schritt 1 und 2 nicht unnötig sind? Natürlich nur wenn das Gitternetz und der Ball auf verschiedene Canvas' gezeichnet würden: Am Gitternetz ändert sich doch nichts -- wozu es Neuzeichnen? Wenn der Ball ein eingenständiges Objekt ist, und ein eigenes Image zur Verfügung hat, dann müßte es doch viel effektiver (schneller) sein, nur den Ball zu zeichnen, ihn zu löschen (unsichtbar machen), und dann an der neuen Position zu zeichnen. Man würde somit nur 5% des sichtbaren Images (Gitternez plus Ball) neuzeichnen, statt das gesamte Gitternetz löschen, neuzeichnen, Ball löschen, neuzeichnen.

Bei meinem (zugegeben sehr flackrigem) Vorgehen, ist der Ball ein eigenständiges Objekt -- und nicht nur ein Kreis auf dem Gitternetz.

Sehr verwirrend das Alles -- aber vielleicht kommt jetzt durch was ich damit meine Gitternetz und Ball sollten "unabhängig" sein.

Vielen Dank für Deinen Kommentar.

Gruss
Jazzman

[jfheins]

Zitat von Jazzman_Marburg:

Das würde doch bedeuten, dass bei jedem Pixel um das sich der Ball bewegt, wird
1. Das gesamte "Spielfeld" gelöscht.
2. Das Gitternetz neu gezeichnet
3. Der Ball auf dem Gitternetz gezeichnet
4. Schlussendlich der OffScreen auf das sichtabre Canvas gezeichnet.

Genau das ist der Fall.

Zitat von Jazzman_Marburg:

Ich frage mich ob der Schritt 1 und 2 nicht unnötig sind? Natürlich nur wenn das Gitternetz und der Ball auf verschiedene Canvas' gezeichnet würden: Am Gitternetz ändert sich doch nichts -- wozu es Neuzeichnen? Wenn der Ball ein eingenständiges Objekt ist, und ein eigenes Image zur Verfügung hat, dann müßte es doch viel effektiver (schneller) sein, nur den Ball zu zeichnen, ihn zu löschen (unsichtbar machen), und dann an der neuen Position zu zeichnen. Man würde somit nur 5% des sichtbaren Images (Gitternez plus Ball) neuzeichnen, statt das gesamte Gitternetz löschen, neuzeichnen, Ball löschen, neuzeichnen.

Vielleicht wirst du lachen. Aber bei deinem Ansatz (Ball und Gitternetz bekommen je eine eigene Image-Komponente) passiert folgendes:

1. Das Image vom Gitternetz wird von Delphi gezeichnet.

2. Das Image vom Ball wird gezeichnet, und überdeckt dann das Gitternetz.

3. Im OnTimer verschiebst du den Ball. Daraufhin zeichnet sich das Image des Gitternetzes neu (weil es Teile gibt, die vorher nicht sichtbar waren, es jetzt aber sein sollen) und verdeckt den Ball. Daraufhin wird wieder der Ball gezeichnet, der nun wiederrum das Gitternetz überdeckt.

Das erklärt auch das Flackern: Erst zeichnet sich das Gitternetz (Ball ist unsichtbar) und danach zeichnet sich der Ball wieder drüber. Es gibt also immer Momente in denen der Ball nicht zu sehen ist.

Das neuzeichnen des Gitternetzes ist nötig, das sich der Ball bewegt hat. dadurch gibt es Pixel, auf deinen der Ball war, wo jetzt aber Gitternetz sein soll.

Die siehst also: Das wovor du dich sträubst passiert in Wirklichkeiut bereits. Nur mit dem Unterschied dass die Komposition (Zusammenzeichnen von Ball und Gitternetz in einem Bild) im Moment von Delphi sichtbar gemacht wird, und es dadurch flackert. Abhilfe ist halt, dass du das gleiche machst, nur eben ijm Hintergund und das Bild erst anzeigst, wenn es fertig ist.

Wenn du das ganze implementierst wirst du übrigens sehen, dass das "unnötige" Neuzeichnen unveränderter Bereiche nicht viel Zeit kostet