TBitMap transparent zeichnen - StrechDraw verzerrt

Sylvus · Beiträge: 195

Hi Leute, also ich will folgendes erreichen. Auf einem Hintergrund ziehen Wolken entlang, durch die man den Hintergrund durchscheinen sieht. Also z.B. zu 50%. Folgende Probleme:

Die Wolken habe ich als TBitMap;
Die Wolken haben ein grünes Umfeld, das mit transparent=true; ausgeblendet wird;
Ich zeichne die Wolken in ein Puffer, indem ich zuerst ein Hintergrund reinzeichne und die Wolken dann darauf setzte.

So, dass sind so die Hauptprobleme, das ich noch nen Anfänger bin, und dass sich die Wolken bewegen, sollte klar sein.
Genug geredet, hier der Code:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

procedure TForm1.Timer1Timer(Sender: TObject);
var
  I: integer;
begin
    Wolke;                                     
    Puffer.Canvas.Draw(0, 0, Background);
    for i := 0 to 3 do
    begin
      Puffer.Canvas.StretchDraw(rect(WolkenPos[I].X, WolkenPos[I].Y, WolkenPos[I].X + WolkenPos[I].X div 2 div 4 * 2, WolkenPos[I].Y + WolkenPos[I].X div 5 - 10), Wolken[i]);
    end;
    Image1.Canvas.Draw(0, 0, Puffer);            //Pufferzeichnung
end;

procedure TForm1.Wolke;
var
  I, K, y, x, Anzahl: integer;
  P1, p2: PByteArray;
begin
  for I := 0 to 3 do
  begin
    if WolkenPos[I].X div 2 div 4 * 2 < 5 then //Wolkenbewegung
      WolkenPos[I].X := 1200;
    WolkenPos[I].X := WolkenPos[I].X - (Lvl.Tag + 3);
    Anzahl := 1;
    for K := 0 to Anzahl do
    begin
      for y := 0 to Wolken[I].height - 1 do
      begin
        P1 := Wolken[i].ScanLine[y];
        p2 := Background.ScanLine[Y + WolkenPos[i].Y];
        for x := 0 to 900 do
        begin
          P1[x] := p1[x] + round((p2[x] - p1[x]) / Anzahl * K);
        end;
      end;
      Wolken[i].canvas.refresh;
    end;
  end;
end;

Funktioniert, natürlich nicht. Also folgendes:
-Die Wolken sind zu durchsichtig
-Es ruckelt
-Ich kann meine schöne Wolkenform vergessen und hab nur noch ein Viereck.
-Der Hintergrund der Wolken, entspricht dem Hintergrund an einer falschen Stelle.
Sprich, durch die Wolken scheint der Hintergrund von einer falschen Stelle.

Ja kann daran liegen, dass ich mir aus vielen Foren was zusammen geklaut habe, aber könnt ihr mir trotzdem helfen?
Danke, Viele Grüße Sylvus

P.S. Wenn ich weiter bin, editiert ich hier rein!

//1.Edit
Ich hänge mal ein Screen an, damit ihr wisst, was ich meine!

//2.Edit
Ich überleg grad und glaube es liegt an folgender Zeile, dass die Bilder nicht aktualisiert werden:

markieren

Delphi-Quelltext

1:	Wolken[i].canvas.refresh;

Was muss ich da anders machen?

Moderiert von Christian S.: Luckies Namen aus Titel entfernt

Einloggen, um Attachments anzusehen!

busybyte · Beiträge: 40

Bei so aufwändigen Grafiken siehe OpenGL oder DirectX.
Bei mir sieht das so aus das mit OpenGL meine CPU-Auslastung (2*3GHz) bei ca 35% liegt aber meine Geforce2 die Bremse ist (2,5FPS) bei 1024*1024.Neue GK ist schon bestellt.
Ausserdem ist ein standard Timer absolut ungeeignet für Grafikrefresh's.
OpenGL ist dank DirectX10 nicht mehr aktuell.Allerdings ist OpenGL im Gegensatz zu DirectX Plattformunabhängig.

Horst_H · Verfasst: Mo 07.04.08 18:10

Hallo,

Du korrigierst beim Hintergrund die y Position, lässt aber das verschobene x ausser acht.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

procedure TForm1.Wolke; 
var 
  I, K, y, x, Anzahl: integer; 
  P1, p2: PByteArray; 
begin 
  for I := 0 to 3 do 
  begin 
    if WolkenPos[I].X div 2 div 4 * 2 < 5 then //Wolkenbewegung 
      WolkenPos[I].X := 1200; 
    WolkenPos[I].X := WolkenPos[I].X - (Lvl.Tag + 3); 
    Anzahl := 1; 
    for K := 0 to Anzahl do 
    begin 
      for y := 0 to Wolken[I].height - 1 do 
      begin 
        P1 := Wolken[i].ScanLine[y]; 
        p2 := Background.ScanLine[Y + WolkenPos[i].Y]; 
        WStart := WolkenPos[I].X;
        for x := 0 to 900-WStart do 
        begin 
//hier muesste auch X für Background korrigiert werden
//p2[x] sollte eher p2[X + WolkenPos[i].X] oder so sein, aber muss dann begrenzt werden
//sodass [X + WolkenPos[i].X]< 900 bleibt, apropos 900 Pixel sind von 0..899
//K ist 0..1 für K = 0 ist diese Berechnung p1= p1 also sinnlos
//Faktioren vorher zusammenfassen Faktor :=  1/ Anzahl * K und damit multiplizieren ist schneller.
          P1[x] := p1[x] + round((p2[x] - p1[x+WStart]) / Anzahl * K); 
        end; 
      end; 
      Wolken[i].canvas.refresh; 
    end; 
  end; 
end;
{
In FarbAnimation.zip in http://www.delphi-forum.de/viewtopic.php?t=66816 habe ich den Faktor durch eine Integerzahl ersetzt statt 1/Anzahl * K einfach zu IntFakt := round((1 shl 16)/Anzahl * K).
Dann  wird
}
 P1[x] := p1[x] + round((p2[x] - p1[x+WStart]) / Anzahl * K); 
//zu
 P1[x] := p1[x] + ((p2[x] - p1[xWStart]) *IntFakt) shr 16;

Zum Klicken... In FarbAnimation.zip in www.delphi-forum.de/viewtopic.php?t=66816
Gruß Horst

Sylvus · Beiträge: 195

hm irgendwie ist mir das alles zu komisch also folgender Code:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

procedure TForm1.Wolke;
var
  I, y, x: integer;
  P1, p2: PByteArray;
begin
  for I := 0 to 3 do
  begin
    if WolkenPos[I].X div 2 div 4 * 2 < 5 then //Wolkenbewegung
      WolkenPos[I].X := 1200;
    WolkenPos[I].X := WolkenPos[I].X - (Lvl.Tag + 3);
    for y := 0 to Wolken[I].height - 1 do
    begin
      P1 := Wolken[i].ScanLine[y];
      p2 := Background.ScanLine[Y + WolkenPos[i].Y - 1];
      for x := 0 to 900  do
      begin
      P1[x] := round((p1[x]-p2[x+WolkenPos[I].X])/2);
      end;
    end;
   Puffer.Canvas.StretchDraw(rect(WolkenPos[I].X, WolkenPos[I].Y, WolkenPos[I].X + WolkenPos[I].X div 2 div 4 * 2, WolkenPos[I].Y + WolkenPos[I].X div 5 - 10), Wolken[i]);
  end;
end;

Also so zeigt er mir die Wolken ganz bunt an und eher so als ob mein Bildschirm einen Fehler hätte.
Nochmal: Ich scane die erste Reihe, gehe dann in jeden einzelnen Pixel rein, und veränder diesen.
Das mach ich mit allen Reihen und dann zeichne ich mir meine Wolke. Wo liegt das Problem?
Offensichtlich an:

markieren

Delphi-Quelltext

1:	P1[x] := round((p1[x]-p2[x+WolkenPos[I].X])/2);

Mein Vorgänger sagte zwar schon sehr viel dazu, aber ich versteh nicht warum man da shr 16... benutzen muss. Warum geht das nicht so?
Die "2" ist natürlich austauschbar, aber die müsste eigentlich eine 50% Transparents erzeugen, oder?
P1[x] gibt doch einfach einen Wert von 0 bis 255 wieder...
Hm irgendwie verzweifele ich grad, aber sonst kann mir mein Info Lehrer morgen ja auch noch was dazu sagen...

Ok über Hilfe bin ich wie immer sehr dankbar!
Viele Grüße Elias

Horst_H · Verfasst: Mi 09.04.08 08:56

Hallo,

ich will Dich nicht verschrecken. Es ging nur darum, es schneller zu machen, da round einiges an Zeit braucht.
Schneller machen sollte man immer erst, wenn es auch funktioniert.

Nun zu den falschen Farben:
Schau einfach mal den Aufbau eines Bildpunktes im Hauptspeicher an.
Das richtet sich nach dem Bitmap.PixelFormat.
Deine Vorgehensweise funktiniert nur bei pf24bit (R,G,B jeweils in einem Byte) und pf32bit (R,G,B und Transparenz jeweils in einem Byte), da diese jeden Farbkanal in einem seperaten Byte speichern.

Das bedeutet, dass WolkenPos[I].X muss um den Faktor BytesPerPixel vergrößert werden.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:

{Ich hoffe das trifft es
// meist steht 0 in Bmp.pixelfornat drin, auflösung des Monitor?????
const
  BytesPerPixel :array [pf1bit..pf32bit] of double = (0.125,0.5,1,2,2,3,4);
}
für pf32bit ist es BytesPerPixel = 4 und für 24 bit eben 3.


P1[x] := round((p1[x]-p2[x+WolkenPos[I].X*BytesPerPixel]/2);

Uups, jetzt wird noch klar was schief läuft, dein x läuftz nicht über 900 Pixel sondern nur über x div BytesPerPixel.
Das musst Du noch anpassen.
Viel Erfolg dabei.

Gruß Horst

Sylvus · Beiträge: 195

Argh, also ich glaub langsam komm ich da hinter, hatte zwar heute nen 10 minütiges Gespräch mit meinem Info Lehrer, aber der hat auch keine Ahnung

Also folgendes, ich hab meine Bilder ja als 24bit Typen, d.h. die Pixel sind aus 3 Werten aufgebaut.
So meine Überlegung sah dann wie folgt aus:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

procedure TForm1.Wolke;
var
  I, y, x,k: integer;
  P1, p2: PByteArray;
begin
  for I := 0 to 3 do
  begin

    if WolkenPos[I].X div 2 div 4 * 2 < 5 then //Wolkenbewegung
      WolkenPos[I].X := 1200;
    WolkenPos[I].X := WolkenPos[I].X - (Lvl.Tag + 3);
    Wolken[I].PixelFormat := pf24Bit;
    for y := 0 to Wolken[I].height - 1 do
    begin
      P1 := Wolken[i].ScanLine[y];
      p2 := Background.ScanLine[Y + WolkenPos[i].Y - 1];
      for x := 0 to Wolken[i].width do
      begin
      for k:=1 to 3 do begin
        P1[x] := round((p1[x]-p2[(X+WolkenPos[I].X)*k])/2);
        end;
      end;
    end;
   Puffer.Canvas.StretchDraw(rect(WolkenPos[I].X, WolkenPos[I].Y, WolkenPos[I].X + WolkenPos[I].X div 2 div 4 * 2, WolkenPos[I].Y + WolkenPos[I].X div 5 - 10), Wolken[i]);
  end;
end;

Damit müsste ich doch eigentlich jeden Pixel ansprechen und ihn dann überschreiben. Wenn man weiter denkt müsste es auch eigentlich so heißen:

markieren

Delphi-Quelltext

1:	P1[x] := round((p1[xk]-p2[(X+WolkenPos[I].X)k])/2);

Aber leider zeigt es immer noch nicht so den Erfolg. Was habe ich falsch gemacht, bzw falsch verstanden?
Tut mir Leid, falls ich mich grad son bissle doof stelle, aber ich habs halt noch nie gemacht

Ich werd auch mal mein Projekt im Anhang dazu fügen, vielleicht hast du ja mal Zeit, es anzuschauen.
Viele Grüße Sylvus

//edit wenns nen E/A Error 103 beim ausführen gibt, einfach weiter laufen lassen, arbeite grad dran, liegt daran, dass er irgendwie die Highscore.txt nicht immer öffnen kann.

Einloggen, um Attachments anzusehen!

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Wie wäre es, wenn du zur Einfachheit lieber einen Typen wie PRGBTriple benutzt? Denn das ist ein 3 Byte großer Datentyp mit dem du direkt auf die Komponenten eines Pixels zugreifen kannst. Außerdem ist es verständlicher (du weißt eher wo du bist) und du hast die innere Schleife nicht. Bei 32 Bit Bildern kannst du als Datentyp auch ein PRGBQuad verwenden.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

var
  BMP: TBitmap;
  X, Y: Integer;
  pPix: PRGBTriple;
begin
  for Y := 0 to BMP.Width -1 do begin
    // erstes Pixel
    pPix := BMP.ScanLine[Y];

    for Y := 0 to BMP.Width -1 do begin
      // pixel verrechnen
      pPix^.rgbtRed   := pPix^.rgbtRed   + 2;
      pPix^.rgbtGreen := pPix^.rgbtGreen + 2;
      pPix^.rgbtBlue  := pPix^.rgbtBlue  + 2;

      // nächstes pixel
      Inc(pPix);
    end;
  end;
end;

Die innerste Schleife: Die muss in jedem Fall raus!! Außerdem darfst du dort auf gar keinen Fall irgendwelche Positionen berechen. Diese Stelle ist das letzte in der Schleifenhirarchie und wird entsprechend am Häufigsten aufgerufen. Bei Einem 512x512 großen Bild schlappe 786.432 Mal. Du solltest alle Positionen bereits so berechnen, dass du innerhalb von "for Y := 0 to BMP.Width -1 do" nur noch die Pixel verrechnen musst und die Positionen auf das nächste Pixel setzen musst. Alles andere kostet unnötig Zeit und multipliziert sich entsprechen auf.

Zum Berechnen der Pixel solltest du nach Möglichkeit kein Round/Trunc (Fließkomma operationen) oder DIV verwenden. Div ist mitunter noch schlimmer als Round. Ich muss gestehen, dass ich nicht genau weiß was du dort berechnest aber zum Teilen eines Wertes mit 2 kannst du auch "shr 1" machen. Dabei wird der Wert um ein Bit nach rechts verschoben was einem "/ 2" entspricht nur, dass es direkt auf der binären Datenebene stattfindet und nicht berechnet werden muss.

Zu guter Letzt: StretchDraw ist auch mit Vorsicht zu genießen. Denn die GDI kann von Hardware beschleunigt werden. Kann. Das muss sie aber nicht. Wenn du jetzt an ein System gerätst an der die Grafikkarte diese Operation nicht beschleunigt muss das umständlich auf der CPU ausgeführt werden. Wenn du die Größe nicht veränderst dann solltest du es besser direkt mit BitBlt zeichnen. Selbst wenn das dann nicht beschleunigt wird sollte das nur aus einem simplen Speicherkopieren bestehen was kaum Risiken darstellen sollte. Falls du es doch in der Größe veränderst solltest du dir überlegen ob es nicht evtl. Sinn macht da mehrere Wolken Bilder von vorherrein zu hinterlegen.

PS: Je nach Aufbau deines Programmes wäre es evtl sogar auch praktisch, wenn du zu Beginn eines Bildes erst den Hintergrund in den Puffer zeichnest und dann die Wolken direkt in den Puffer verrechnest. Denn so könntest du dir eine ganze Zeichenaktion sparen. Aber das kommt auf den Aufbau drauf an.

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

Sylvus · Beiträge: 195

Na das wird doch langsam.

Also ich versuch erstmal, zu verstehen und es so hinzu bekommen, dass es funktioniert. Danach versuch ich das zu optimieren

Ja ich weiß, etwas umständlich aber sonst ist mir das zu viel auf einmal.
Also momentan habe ich folgenden Code:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

procedure TForm1.Wolke;
var
  I, y, x: integer;
  pPix1, pPix2: PRGBTriple;
begin
  for I := 0 to 3 do
  begin
    if WolkenPos[I].X div 2 div 4 * 2 < 5 then //Wolkenbewegung
      WolkenPos[I].X := 1200;
    WolkenPos[I].X := WolkenPos[I].X - (Lvl.Tag + 3);
    Wolken[I].PixelFormat := pf24Bit;
    for y := 0 to Wolken[I].height - 1 do
    begin
      pPix1 := Wolken[i].ScanLine[y];
       pPix2 := Background.ScanLine[Y + WolkenPos[i].Y - 1];
      for x := 0 to Wolken[i].width do
      begin
      //ShowMessage(inttostr(pPix1^.rgbtGreen));
       if (pPix1^.rgbtGreen=255) AND (pPix1^.rgbtblue=0) AND (pPix1^.rgbtred=0) then
       pPix1:=pPix1
       else
       begin
        pPix1^.rgbtRed := (pPix2^.rgbtRed + 255) DIV 2;
        pPix1^.rgbtGreen := (pPix2^.rgbtGreen + 255) DIV 2;
        pPix1^.rgbtBlue := (pPix2^.rgbtBlue + 255) DIV 2;
        end;
        Inc(pPix1);
        Inc(pPix2);
      end;
    end;
    Puffer.Canvas.StretchDraw(rect(WolkenPos[I].X, WolkenPos[I].Y, WolkenPos[I].X + WolkenPos[I].X div 2 div 4 * 2, WolkenPos[I].Y + WolkenPos[I].X div 5 - 10), Wolken[i]);
  end;
end;

Und er funktioniert!
So jetzt das große Problem:
Meine Wolken sind zwar transparent, jedoch zeigen sie immer den Hintergrund an einer bestimmten Stelle an.
Ich möchte aber, dass der Hintergrund durchscheint, bei dem sie auch grade sind. Sprich ich müsste zu dem pPix2 irgendwie meine WolkenPos[I].X dazu addieren.
Wie erreiche ich das? Über pPix2:=pPix2+WolkenPos[i].X; geht es nicht!
Und die andere Frage, was bedeutet dieses ^??

Auf jeden Fall schon mal ein großes Danke! Und wenn es funktioniert schau ich mal, wie ich das DIV 2... raus bringe

Viele Grüße Sylvus

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Das Dach ^ bedeutet, dass die Variable davor ein Pointer ist und der Wert dereferenziert werden soll. Also, dass du auf die eigentlichen Daten zugreifen möchtest und nicht auf die Adresse innerhalb des Pointers. Einfaches Beispiel.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  By: PByte;

// erhöht die Adresse um 1 * die Größe von sich selbst. In diesem Falle
// ein Byte. Bei Word wären es 2 Byte usw...
Inc(By);

// Erhöht den Wert an der Stelle auf der der Pointer zeigt.
Inc(By^);

Erst verstehen und dann optimieren ist evtl. umständlich aber in jedem Fall der richtige Weg. Denn du kannst nichts optimieren wenn du nicht weißt wie es funktioniert. Außerdem. Um so komplizierter der Code dadurch wird um so schwieriger kann es werden ihn zum Laufen zu bewegen. Wenn du da schon mal einen hast der geht ist das in jedem Falle besser.

Zu den Problem mit den Wolken. Beim Zugriff auf Scanline deines Hintergrundes berücksichtigst du bereits die Y Position deiner Wolken. Der Pointer befindet sich aber immer auf dem ersten Pixel der Zeile. Nach Scanline musst du dann natürlich noch auf das richtige Pixel in der Horizontalen positionieren.

markieren

Delphi-Quelltext

1:
2:
3:
4:

      pPix1 := Wolken[i].ScanLine[y];
      pPix2 := Background.ScanLine[Y + WolkenPos[i].Y - 1];

      Inc(pPix2, WolkenPos[i].X); // Horizontale Position setzen

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

Sylvus · Beiträge: 195

hey super, find ich toll, dass es noch viele Leute gibt, die etwas mehr Ahnung als mein Lehrer und ich haben

Aber irgendwie ist es immer noch so um nen paar Pixel verschoben, naja mal schauen.
Auf jeden Fall ist das Ergebnis schon akzeptabel

DANKE Viele viele Grüße Elias

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Ich mache aber auch seit Jahren hauptsächlich nur solche Dinge.

Im Zweifel kannst du auch mal ein Bild davon anhängen. Ich denke da kann man dann sicher erkennen wo das Problem liegt. Und dir dann tipps geben wieso es verschoben aussieht.

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

Sylvus · Beiträge: 195

na das tue ich doch gerne

Sonst schreibe ich da jetzt einfach so was wie +10 oder so hin. Aber trotzdem mal das Bild. Wir wollen ja schließlich das Problem auf die feine Art lösen

Viele Grüße Sylvus

Einloggen, um Attachments anzusehen!

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Also laut dem Bild würde ich nicht sagen, dass es verschoben ist. Denn die rechte Seite der Wolke sieht wirklich verschoben aus. Aber was ist mit der linken Seite? Diese kleine Ecke der Wolke (links mittlere höhe) wird richtig fortgesetzt und es schaut an dieser Ecke so aus wie es sein soll. Also denke ich liegt dein Problem in der Art wie du die Wolke zeichnest. Nämlich mit StrechDraw und dann auch nicht in der originalen Größe. Dadurch zeichnest du den verrechneten Hintergrund kleiner ins Bild als er eigentlich ist.

Aktuell hast du auch das Problem, dass du die Wolken immer in voller Größe berechnen musst auch wenn du sie später gerade mal 30x30 Pixel groß zeichnest. Da geht auf jeden Fall einiges an Zeit verlohren.

Als Lösung würde ich da evtl. vorschlagen, dass du die Wolken vorberechnest. Also entweder unterschiedlich große Wolkenbilder oder beim Laden der Wolkenbilder diese eben mit Strechdraw auf ein anderes Bild zeichnen um so die größen zu verändern. Beim Zeichnen dann normal die Daten verrechnen und mit Draw (nicht StrechtDraw) die Bilder an einer entsprechenden Position zeichnen. Dann sollte es auch mit dem Hintergrund klappen.

Wobei du da evtl auch gleich die Wolken in den Hintergrund rechnen kannst und nicht erst temporär in ein Bitmap. Denn so würden auch Wolkenüberlagerungen gleich mit in die Berechnung einfließen. Weniger sichtbarkeit. Was derzeit schlicht ignoriert werden würde.

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

Sylvus · Beiträge: 195

Hi,
ja, also ich versteh zumindest schon mal was mein Problem ist

Nur habe ich die Lösungsansätze nicht richtig verstanden. Also das Bild mit dem Hintergrund verrechnen, ok und wie?
Also irgendein Befehl, nach dem ich suchen kann, oder ein anderer Ansatzpunkt. Hab irgendwie keinen Plan wonach ich suchen muss

Oder geh ich da ganz falsch ran?
Nen Tipp wäre super

Viele Grüße Sylvus

Ehemaliges Mitglied Erhaltene Danke: 1

Was hat denn bitte sehr der Threadtitel mit dem Problem zu tun? Ich dachte hier ginge es um Vista oder so. :roll:

Sylvus · Beiträge: 195

Hier ist zwar schon viel passiert, aber eigentlich sollte er darauf hinweißen, dass meine Transparenz nicht geht.
Der erste Teil des Titles kommt daher, dass man das ganze auch mit der WindowsFunktion AlphaBlending machen könnte, es da aber total langsam ist.

Alles klar?
Sonst frag einfach, aber besser per PN sonst wird das hier nur Offtopic

Viele Grüße Sylvus

Ehemaliges Mitglied Erhaltene Danke: 1

Ich wollte nur darauf hinweisen, dass es sinnvoller ist einen aussagekräftigen Titel zu nehmen anstatt einen beid em amn sich den Sinn erst zusammen reinem kann, wenn man das Problem kennt.

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Sylvus: Was verstehst du denn genau nicht? Du darst das StretchDraw nicht so benutzen wie du es derzeit benutzt. Denn Aktuell benutzt du es um unterschiedlich große Wolken zu erzeugen. Und dadurch, dass du vorher den Hintergrund einrechnest wird der natürlich kleiner dargestellt. Was aber falsch ist. Und sogar ein bisschen überflüssig.

Das was ich aber empfehlen würde ist folgendes.
Start der Anwendung:
- Laden / Erstellen von Wolken in verschiedenen Größen

Zeichnen:
- Hintergrund in den Buffer zeichnen
- Verschieden große Wolken mit Scanlines auf den Hintergrund aufbringen und dabei die Transparenz mit einbringen
- Puffer auf dem Bildschirm darstellen

Das wars eigentlich schon. Und so gesehen machst du das alles irgendwo schon (+ ein bisschen mehr). Du musst genau genommen nur die Reihenfolge und die verwendeten Bitmaps umstellen.

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

Sylvus · Beiträge: 195

Ja, das hab ich verstanden, aber wie erstelle ich die Bilder in den unterschiedlichen Größen?
Also ich wollte eigentlich nicht 1000 verschiedene Bilder in Paint zeichnen und diese alle in mein Programm laden. Oder ist genau dies der Weg?
Ich hab halt im Moment keine Ahnung wie ich das StretchDraw umgehen kann.
Wenn mir da jemand etwas helfen könnte, wäre das toll.
Also z.B.
"Hier benutz den Befehl in der Schleife und du lädst dir damit automatisch alle Bilder, in verschiedenen Größen, in den Speicher!"

In guter Hoffnung Sylvus

Lossy eX · Beiträge: 1048 Erhaltene Danke: 4

Also 1000 Bilder von Vornherein zu erstellen dürfte sicher kompliziert werden. Würde dir aber empfehlen doch ein paar unterschiedliche zu erstellen. Das wirkt besser als wie wenn sie alle gleich aussehen.

Und je nachdem wie viele Wolken du gleichzeitig darstellen willst/musst gibt es 2 Möglichkeiten. Da aber bitte keine hypothetischen Zahlen wie 1000. Das wird dann vermutlich auch einfach nicht mehr aussehen.

Möglichkeit 1: Du erstellst beim Start die von dir benötigten Wolken. Und zwar jede in einem eigenen Bitmap. Welche die nahezugleich sind kannst du als eines betrachten. Das fällt nicht auf. Dazu errechnest du die Größe der Zielwolke, erstellst ein passenden Bitmap und zeichnest die originale Wolke mit StrechDraw in die Zielwolke. Die Zielwolke benutzt du dann später zum Zeichnen. Fertig.
Du musst die Wolken dann nur noch zeichnen. Verbrauchst aber je nach Anzahl der Wolken eine gehörige Mehrmenge an Speicher.

Möglichkeit 2: Du erstellst dir direkt vor dem Zeichnen ein kleinere Varainte der Wolke und benutzt dieses zum Verrechnen in deinen Hintergrund. Dadurch verbrauchst du nicht so viel Speicher aber der Aufwand zum kleiner Rechnen der Wolken kann durchaus um einiges höher sein. Es wird also schlicht langsamer.

Und StrechDraw: Wenn du deinen Ablauf geschickt aufbaust brauchst du eigentlich gar kein StrechDraw. Bis auf evtl beim Start (Möglichkeit 1). Aber sonst nicht. Das hatte ich ein Post weiter oben schon mal beschrieben. Falls du damit Verständnissprobleme hast tu dir keinen Zwang an und frage. Dann Erkläre ich das noch mal ausführlicher. Ich weiß nämlich nicht wie groß deine Fähigkeiten sind.

_________________
Nur die Menschheit ist arrogant genug, um zu glauben sie sei die einzige intelligente Lebensform im All. Wo nicht mal das nachhaltig bewiesen wurde.

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme