Hallo!
Ich habe ein kleines Testprog gebastelt und musste feststellen, dasswenn man "nur" 30 kleine Images verschiebt, das riesige Belastung bedeutet für den PC bedeutet. Diese werden mittels Timer verschoben (und die bilder sind wirklich winzig (20x20 pixel)..
Sogar wenn Doublebuffered und Transparent deaktiviert ist . Gibt es da eine Möglichkeit das schneller zu machen, und zwar ohne OpenGL und DirectX (das ist immer so umständlich )

Woran liegt es eigentlich, dass das so langsam ist? Delphi? Graka? oder CPU? (letztes beides dürte nicht Grund sein, da PC relativ neu...)

Hat jemand einen Lösungsvorschlag?

MfG

es liegt zwar nicht an der größe, aber stell dir doch nur mal vor: der prozessor bekommt dann den auftrag 30 bilder (nur 30! hehe) zu verschieben. da muss der jedes einzelne anpacken und verschieben. es dauert auch länger 300 2 x 2 cm große Würfel als einen großen wegzuschleppen!

nimm assembler oder halt opengl oder directx. anders dürfte es nicht gehen!

MfG, Scorpion!

Und warum sollte das mitm Assembler gehen? Dann muß er ja auch so viele anpacken, oder etwa nicht?!

Nimm am besten gdi funktionen, die sind wesentlich schneller, als die Verwendung von Tcanvas.
Wobei die Frage aufkommt, wie verschiebst du die bzw. was verwendest du um dies umzusetzen ?

Ich habe ein Objectlist von einer abgewandelten Timage in eine Komponente gesetzt.
Per procedure aufruf werden dann alle objekte bewegt (dieser wird vom Timer ausm Hauptprogramm aufgerufen).

@ScorpionKing: Das will er ja gerade nicht. Aber das sollte normal auch kein Thema sein, da Delphi (GDI) bereits eine gewisse Hardwarebeschleunigung bietet. Das sollte man nicht unterschätzen. Da dürfte Assembler auch recht alt gegen aussehen. Abgesehen davon steht der Entwicklungsaufwand dann in meinem Verhältnis mehr.

@Niels_: Als erstes. Zeichne bei so etwas nicht direkt auf den Bildschirm. Und schon gar nicht durch TImage. Lade alle Bilder in ein TBitmap und Benutze dies dann zum Zeichnen.

Erstelle dir zu Begin deiner Anwendung ein Bild welches die Größe deiner Zeichenfläche hat. Dort ganz Wichtig kein PixelFormat einstellen, da es sonst auf dem Prozessor durchgeführt wird. Zur Not stellst bu dem TBitmap den HandleType auf DDB.

Und beim Zeichnen brauchst du dann lediglich nur noch die Bilder mittels Canvas.Draw (X, Y, Bild) auf dein Temporäres Bild zeichnen. Dort solltest du evtl nach dem Laden auch den HandleType auf DDB stellen.

Wenn du das Bild fertig hast, dann zeichnest du dieses auf deine Zeichenfläche. Genauso wie du es mit den kleinen Bilden, auf dem temporären Bild, gemacht hast. Für die Zeichenfläche würde sich normal ein Panel oder direkt das Form anbieten. Weiß nicht ob es einen Unterschied macht, wenn du auf eine PaintBox zeichnest. Ich benutze aber fast immer ein Panel bei dem ich das Löschen des Hintergrundes durch Windows verboten habe. Dadurch verhindert man noch einmal zusätzlich, dass das Bild flackert.

Wenn du deine Anwendung dann schließt, dann kannst du auch das temporäre Bild löschen. Das solltest du auf keinen Fall bei jedem Zeichnen anlegen, da das einfach nur extrem langsam ist.

Wenn du eine halbwegs Aktuelle Grafikkarte besitzt (TNT2 reicht auch schon), dann dürfte es recht flott sein. Aber das Beste ist, wenn du die Zeit für deine Zeichenoperationen misst und diese in der Caption ausgibst oder so. Dann kannst du selber noch einmal sehen was am schnellsten ist und ob es zu Geschwindigkeitseinbußen kommt, wenn du irgendwas geändert hast.
Du solltest aber auf keinen Pixels benutzen. Das ist Langsam egal was du macht! Wenn du Pixelzugriff brauchst, dann musst du mal schauen was am schnellsten ist. Das sollte aber Normal Scanline sein. Funktioniert nur bei DIB bildern.

Die andere Alternative wäre, wenn direkt auf den Speichers des Bitmaps zugreifst und dann die Bilddaten direkt per Move hineinkopierst. Das geht aber nur mit DIB Bildern. Also wenn du ein PixelFormat ausgewählt hast. Aber wenn du dich auf die Reine GDI beschränkst ist der erste Weg im Normalfall schneller.

ui danke danke..
@lossy eX:
Das mit Canvas.draw(x,y,pic) hatte ich auch schon überlegt und hab damit angefangen! Werde das gleich mal ausprobieren! Wenn du von GDI redest, ist das die Engine, mit der Delphi arbeitet?
Werde das dann mal so versuchen! Tausend Dank für eure Hilfe!

Japp. Alles was zum TCanvas gehört gehört zur GDI. Na ja. Alles was zeichnet.

Jap! Es funzt..
Jedoch hat die Methode den Nachteil, dass man nur Bitmaps verwenden darf.
Außerdem hatte ich eine Unit benutzt (imgrot), die es mir ermöglich die bilder zu drehen... Hatte gedacht, dass sowas schneller möglich wäre.. Naja! Aber so geht es auch!

Jo. Drehen ist so ne Sache. Wenn du nir 90° drehen willst, dann geht das recht einfach. Alles andere ist recht Zeitaufwendig. Evtl solltest du so etwas vorberechnen. Das aber auch nur, wenn das Bild nicht so groß ist und du nicht so viele Stufen brauchst.

Anderfalls würde ich dir mal dringend ans Herz legen, dass du dich mal mit OpenGL beschäftigst. Das ist zwar im Anfang komplizierter bietet dafür aber 100%tig Hardwarebeschleunigung. Rotation, Skalieren, Transparenz, etc inbegriffen.

Ich denke auch, dass es sich durchaus bei einigen Sachen lohnt auf OpenGL zu zugreifen. Gerade wenn einige Leute sich mit einer witzig animierten About-Box mit dem GDI abqäulen. Bevor man da zu Assembler greift, würd ich OpenGL empfehlen. Sicherlich lohnt sich das nicht für ein einzelnes Icon, läßt sich aber sehr schnell erlernen und sich notfalls als in einem Panel recyceln lassen. Gerade wenn es um viele Transparente Objekte wird die gedreht werden. Warum also nicht die GPU belasten, statt die CPU?

Wenn du dich nicht tiefer mit DirectX beschäftigen willst nimm einfach DelphiX.

Binde es in dein Delphi ein und schau dir ein paar Beispiele an.

setze eine DirectDraw-Fläche, Größe definieren (Name DXDraw1)
setze einen DXTimer (Name DXTimer1)
setze einen Imagelist (Name DXImageList1)

Binde die DXImageList1 an DXDraw1

Lade bei Form1.OnCreate die Imagelist
müsste ungefähr so aussehen.

DXImageList1.Items[0].LoadFromFile(DATEI);

wähle den Timer aus und schreibe in die

Procedure OnTimer
DXDraw1.Fill(0); (Schwarzer Hintergrund)

DXImageList.Items[0].Draw(DXDraw1.Surface, Positionen etc.);
.
.

DXDraw1.Flip;

Fertig!

Einfacher als mit Delphi-X geht nicht!

Alles andere ist nur spielerei und wird auf Dauer zu keinem befriedigenden Ergebnis führen.

MfG

Martin