Hallo!

Also ich hatte vor etwas längerer Zeit mal ein Bluescreen Programm geschrieben es aber nicht so wirklich fertig gemacht weil ich wenig Freizeit hatte. Nun möchte ich weiter machen...

Ich bin damals soweit gewesen das ich ein Bild in Echtzeit anzeige und dabei das Blau mit einem Hintergrundbild ersetzte. Das ganze habe ich mit Graphics32 realisiert. Die Auflösung war 320x240 und damit ziemlich klein.

Nun wollte ich bevor ich anfange weiter zumachen mal fragen ob ich mit meiner Methode weitermachen soll oder ich etwas anderes benutzen soll was schneller ist. Gibt es was, was schnell ist und einfach zu lernen? Ich habe mir so 640x480 oder größer vorgestellt.

Gibt es da was?

Ich bin mir bei Graphics32 halt nicht sicher ob des wirklich das richtige ist weil es, denke ich, in erster Linie für Graphikanzeige gecoded wurde.

Grüße
MasterDG

DirectX? OpenGL? DelphiX?

Hallo!

Was davon ist denn einfacher zu lernen? Sind die schneller als Graphics32?

Ich hab zwar alles schon mal gehört aber bisher noch nicht in einem Programm benutzt und kenne daher nicht die Schnelligkeit und die Möglichkeiten.

Gruß
MasterDG

Ich denke, wenn du mit OffScreenBitmaps (Kabarakh oder wie der Kerl heißt, kann dir sicher mehr dazu erzählen), sollte das mit der Graphics32 schnell genug sein.

Hallo!

Danke für eure Antworten!

Also bei 640x480 sind das 307200 Aktionen in 1/30 sec. Das is ne ganze Menge. Ich werde mal sehn ob ich das mit Graphics32 und Offscreen-Bitmaps hinbekomme.

Mal abgesehen von der Geschwindigkeit, was denkt ihr sollte ich das mit Graphics32 machen, oder ist das unfein?

Ich schreibe das Programm für mich und einen Freund, weil wir mit Bluescreen-Technik drehen wollen und da eine Vorschau echt praktisch wäre.


Gruß
MasterDG

Zitat von Spider:

(Kabarakh oder wie der Kerl heißt, kann dir sicher mehr dazu erzählen)

Ein "h" hast du vergessen .

Zur Geschwindigkeit lässt sich sagen, dass meistens das Anzeigen durch Windows das Langsamste am Ganzen ist. Wenn du keine 100 Layer oder aufwendige Berechnungen benutzt, hängt die Framerate also im Wesentlichen von Windows ab. Am Besten einfach mal ausprobieren .
Dazu kannst du dir auch die "Sprites_Ex"-Demo im GR32-Verzeichnis anschauen, mit der das Team ein paar Performancemessungen betrieben hat:

http://graphics32.org/documentation/Images/rp_005a.png

Zitat von MasterDG:

Mal abgesehen von der Geschwindigkeit, was denkt ihr sollte ich das mit Graphics32 machen, oder ist das unfein?

Ich wüsste keine Aufgabe, für die die GR32-Lib besser geeignet ist, als zwei Bitmaps zu verbinden.

Hallo Khabarakh.

Danke für deine Antwort.

Also ich glaube ich weiß jetzt was mein Fehler war, den ich die ganze Zeit gemacht habe. Ich zeige das Bitmap in das ich schreibe (bzw. male) die ganze Zeit an. So wie ich dich verstanden habe sollte ich besser ein Bitmap im Hintergrund erstellen und da rein zeichnen und dann dieses Bitmap in ein Bitmap kopieren das angezeigt wird.

Wie ich dem Diagramm entnehmen kann ist es also kein Problem hohe Fps auch bei z.B. Vollbild zu bekommen... Das würde dann vollkommen ausreichen.

Meine einzigen Berechungen sind das zerlegen von einem TColor32 in RGB-Werte und das anschließende kontrollieren dieser Werte, also relativ einfache Berechungenen.

Eine kleine Nebenfrage habe ich noch: Ich habe zwei Möglichkeiten die Farbe in RGB-Werte zu zerlegen: 1. Eine Funktion der GR32-Library benutzten oder 2. mit shr . Bei der Funktion von GR32 werden die Farben in 3 Variablen geschrieben bei shr die Bytes verschoben. Was ist besser?

Gruß
MasterDG

Ich denke, du meinst diese Funktion:

Zitat:

Color32ToRGB

markieren

Delphi-Quellcode:

procedure Color32ToRGB(Color32: TColor32; var R, G, B: Byte);

procedure Color32ToRGBA(Color32: TColor32; var R, G, B, A: Byte);

Both procedures split the Color32 parameter up into their respective components.

These procedures are provided for convenience only. Use direct conversion in performance-critical parts of your code:

Alpha := Color32 shr 24;

Red := (Color32 and $00FF0000) shr 16;

Green := (Color32 and $0000FF00) shr 8;

Blue := Color32 and $000000FF;

Bit-Shifting ist also schneller, da du dir einen Funktionsaufruf sparst (wobei du dank D2005 auch die Inline-Methoden Red/Green/BlueComponent benutzen kannst, die sollten dann gleich schnell sein).
Eine weitere Möglichkeit ist der Zugriff über TColor32Entry:

markieren

Delphi-Quellcode:

var
  C: TColor32;
  Red: Byte;
begin
  Red := TColor32Entry(C).R;
end;

Was nun am Schnellsten ist, kann ich dir nicht sagen, da müsstest du unsere Assembler-Experten fragen ^^ .

Zitat:

Also ich glaube ich weiß jetzt was mein Fehler war, den ich die ganze Zeit gemacht habe. Ich zeige das Bitmap in das ich schreibe (bzw. male) die ganze Zeit an. So wie ich dich verstanden habe sollte ich besser ein Bitmap im Hintergrund erstellen und da rein zeichnen und dann dieses Bitmap in ein Bitmap kopieren das angezeigt wird.

Wenn du TImage32 benutzt, musst du dich darum nicht mehr kümmern, das benutzt schon ein OffScreenBitmap.

Hallo.

Also ich habe jetzt schon mal ein Vorab-Programm zum Testen der Schnelligkeit geschrieben. Ich benutze jetzt Layer im TBitmap32. Ein Layer ist der Vordergrund, eins der Hintergrund.

Das klappt alles recht gut. Ich habe mit QueryPerformanceCount mal die Zeit gemessen und bei einer Kamera mit 320x240 ist es bei ca 8000 - 9000. Allerdings habe ich ein leichtes Problem mit Ruckeln, denn regelmäßig springt die Zeit für die Berechung auf über 15000! Ich glaube dass dadurch die Ruckler verursacht werden.

Ich habe momentan keine richtige Idee woher das kommen könnte. Kann es sein dass es durch einen gleichzeitigen Zugriff auf das Bitmap32 kommen könnte?

Gruß
MasterDG