Suche Schnelle Alternative zu "CopyRect"

[Corpsman]

Hi Leuts,

Ich hab da mal vor Langer Zeit nen Screensaver geschrieben. Dieser geht auch richtig rockig schnell und hat 0 % CPU Load auf all meinen Systemen.

Wie der das Erreicht ist ganz Einfach, ich lagere alle Aufgaben Dank OpenGL auf die Grake aus.

Auf meinem Desktop Rechner ist das OK, den die Gforce 8800 gts von mir läuft eh immer mit Voller Rate.

Doch nu hab ich ja auch ein Notebook, da hab ich ebenfalls 0 % CPU load, aber da die Grake Gforce 8400 M wohl zwischen 3D und 2D mode umschalten kann ändert sich die Temperatur doch deutlich.

Soviel zum Hintergrund.

Nu Dachte ich mir, der Screensaver macht eh nur 2D ( nutzt also OpenGL eigentlich gar nicht in seiner eigentlichen 3D Eigenschaft )

Schreibe ich den Source einfach um, auf Ohne OpenGL und hab dafür dann ein bischen mehr CPU Load.

Also habe ich nun ein TBitmap genommen das in das ich "Reinrendere" und das ich am Ende dann mittels Canvas.draw auf meine Form1 ausgebe.

Zum Eigentlichen Problem.

Mein Screensaver geht her und Kopiert nun aus 10 weiteren ( deutlich kleineren ) Tbitmaps Teile in 1:1 auf das Temp TBitmap

Das macht er aber viel zu langsam, in der OpenGL variante machte ich das mit GlCallLists und da gings rockig.

Mit meinem Bisherigen Ansatz kriege ich gerade mal 16 FPS hin, ich will aber schon 60 ( und die braucht der Effeckt auch )haben ...

Bisher hab ich es mit 2 varianten probiert, einmal mittels Copyrect und einmal mittels Scanline ( scanline brachte dabei gerade mal 7 FPS ).

Hat von euch noch jemand ne Idee wie ich das hier beschleunigen könnte.

Delphi-Quellcode:

Procedure CopyRect(Const Source, Dest: Tbitmap; SourceX, SourceY, DestX, DestY: Integer);
Type
  PBGR = ^TBGR;

  TBGR = Record
    B, G, R: Byte;
  End;
Var
  p1, p2: PBGR;
  i, j: Integer;
  w, h: Integer;
Begin
  w := Dest.Width - 1;
  h := dest.height - 1;
  For j := 0 To 11 Do Begin
    If h >= DestY + j Then Begin
      p1 := source.ScanLine[SourceY + j];
      inc(p1, sourceX);
      p2 := Dest.ScanLine[DestY + j];
      inc(p2, DestX);
      For i := 0 To 7 Do
        If w >= DestX + i Then Begin
          p2^.B := p1^.B;
          p2^.G := p1^.G;
          p2^.R := p1^.R;
          inc(p2);
          inc(p1);
        End;
    End;
  End;
End;

Procedure TASCII_Font.RenderChar(Const Canvas: TBitmap; x, y: Integer; Number: integer; Color: Integer);
Var
  vx, vy: Integer;
Begin
  //  vx := (Number Mod 32) * Fcharwidth;
  vx := (Number Mod 32) Shl 3;// Fcharwidth = 8
  //  vy := (number Div 32) * FCharHeight;
  vy := (number Shr 5) * FCharHeight;// FCharHeight = 12

  //  Das hier gibt 7 FPS
  //  copyrect(fonts[color], Canvas, vx, vy, x, y);

  // Das hier gibt 16 FPS
  canvas.canvas.CopyRect(
    rect(x, y, x + FCharwidth, y + FCharHeight),
    fonts[color].canvas,
    rect(vx, vy, vx + FCharwidth, vy + FCharHeight));
End;

[Luckie]

Hast du es schon mal mit BitBlt probiert?

[MSSSSM]

Nutzt du TImage?
Oder nimmst du ein TBitmap und renderst das auf die Form?
Nimm dann eine Paintbox bzw. den Canvas der Form.

Editz: Ach nee, das ist ja son erfahrener Typ

[turboPASCAL]

Zitat von Luckie:

Hast du es schon mal mit BitBlt probiert?

Mach das so, bzw. versuch es so.

[Corpsman]

OK thx, werde das mit BitBLT mal Austesten.

Ich nutzte immer TBitmap, da ich da am Leichtesten an die Ferben und Daten ran komme, ist TImage besser ?

Und ja ich rendere der art das ich sage

Delphi-Quellcode:

Begin
Bitmap.clear;
RendertoBitmap;
Form1.canvas.draw(0,0,Bitmap);
End;

@MSSSSM

Zitat:

Editz: Ach nee, das ist ja son erfahrener Typ

Mein Sarkassmus zu DE Compiler ist Kaputt, Was willst du mir damit sagen ?

[Edit]

Also ich hab das nu so

Delphi-Quellcode:

Procedure TASCII_Font.RenderChar(Const Canvas: TBitmap; x, y: Integer; Number: integer; Color: Integer);
Var
  vx, vy: Integer;
Begin
  //  vx := (Number Mod 32) * Fcharwidth;
  vx := (Number Mod 32) Shl 3;
  //  vy := (number Div 32) * FCharHeight;
  vy := (number Shr 5) * FCharHeight;

  BitBLT(canvas.Handle, x, y, 8, 12, fonts[color].Handle, vx, vy, SRCCOPY);
//  copyrect(fonts[color], Canvas, vx, vy, x, y);
//  canvas.canvas.CopyRect(
//    rect(x, y, x + FCharwidth, y + FCharHeight),
//    fonts[color].canvas,
//    rect(vx, vy, vx + FCharwidth, vy + FCharHeight));
End;

Probiert, was bassiert ist das ich deutlich mehr CPU Load bekomme, aber nichts sehe, d.h. ich habe BitBLT wohl Falsch parametrisiert, nur verstehe ich nicht was ich falsch gemacht haben soll..

[Phantom1]

probiers mal so:

BitBLT(canvas.Handle, x, y, 8, 12, fonts[color].canvas.Handle, vx, vy, SRCCOPY);

[Corpsman]

*g*

fast

  BitBLT(canvas.canvas.Handle, x, y, 8, 12, fonts[color].canvas.Handle, vx, vy, SRCCOPY); Aber das Bringt auch nur 17-18 Frames.

Das ist zwar besser, aber immer noch gut 20 - 40 FPS zu wenig

Es scheint aber das BitBLT die Last besser auf die beiden CPU's verteilt als CopyRect ...

[jfheins]

Also wesentlich schneller als BitBlt kann man imho nichtkopieren ... demzufolge sollte der Flaschenhals woanders liegen

Es sei denn ... was kopierst du denn da eigentlich?

P.S. Es ist verwirrend wenn du dein Bitmap canvas nennst

[Luckie]

Zitat von Corpsman:

Es scheint aber das BitBLT die Last besser auf die beiden CPU's verteilt als CopyRect ...

Diese Aussage ist Blödsinn. Eine API Funktion kann nicht gleichzeitig auf meherern CPUs ausgeführt werden.

[Corpsman]

Die BitBLT funktion wird ja knapp 200 - 400 mal pro Frame aufgerufen, daher denke ich das der Sceduler evtl ab und zu eine andere CPU zuteilt.

Nachdem ich an dem Programm lediglich die OpenGL Dinge gegen TBitmap ausgetauscht habe, fällt es mir auch schwer zu glauben das der Rest des Programmes eine Hohe CPU Load erzeugen soll.

Zudem erzeugt die OpenGl version ja gar keine CPU Load ...

Egal wie ich gehe davon aus das es so, einfach nicht schneller geht.

Ich habe da noch eine Idee die die OpenGL Befehle nachbaut, evtl macht dieser ansatz das schneller, aber da mus ich gut nen Tag dran Rumprogrammieren. Ich werde die Ergebnisse dann hier Posten.