Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Mi Jul 16, 2025 23:08

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 4
  [ 48 Beiträge ]  Gehe zu Seite 1, 2, 3, 4  Nächste
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Das AKW
 Betreff des Beitrags: Schnelleres Partikelsystem
BeitragVerfasst: Sa Jan 22, 2005 12:00 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Hallo Welt,

ich habe mich nach langer Zeit mal dazu durchgerungen eine Partikelengine (wenn man es als engine bezeichnen kann :D ) zu schreiben. Die Partikel bzw das Partikelsystem wird wie folgt gespeichert:

Code:
  1.  
  2.  Particle = record
  3.   Birth: Integer;
  4.   XShift: Single;
  5.   Current: Array[0..2] of Single; // Aktuelle Koordinate
  6.   Direction: Array[0..1] of Single; // Richtung bzw Geschwindigkeit
  7.   Livetime: Integer; // Anzahl Renderdurchgänge bis zur Löschung
  8.   Color: Array[0..3] of Single; // Farbe im RGBA Format
  9.   Fading: Single;
  10.   Size: Single;
  11.   Precached: record
  12.    Alpha, b, a, l: Single;
  13.    Size, Start: Single;
  14.    Color: Array[0..3] of Single;
  15.   End;
  16.  End;
  17.  
  18.  Particlesystem = record
  19. //  ParticleImage: String;
  20.   Texture: Cardinal;
  21.   NumOfParticles: Integer;
  22.   Speed: Array[0..1] of Single;
  23.   Start: Single;
  24.   Size: Array[0..1] of Single;
  25.   Color: Array[0..3, 0..1] of Single;
  26.   Livetime: Array[0..1] of Integer;
  27.   Angle: Integer;
  28.   Particles: Array of Particle;
  29.  End;
  30.  


Nachdem die Partikeldaten mit entsprechenden Funktionen oder direkt an ein Particlesystem übergeben wurden, berechnet eine Routine die Daten für jedes einzelne Partikel:

Code:
  1.  
  2. Procedure giPrepareParticleSystem(PS: Particlesystem; TexFile: String);
  3. Procedure CalculateParticle(ID: Integer);
  4. Function Bow(Winkel: Single): Single;
  5. Begin
  6.  Result:= Winkel/180*Pi;
  7. End;
  8. Var
  9.  b, a, l, Alpha: Single;
  10.  
  11. Begin
  12.  With PS do
  13.  Begin
  14.   Randomize;
  15.   // \"Lebenszeit\"
  16.   Particles[ID].Livetime:= RandomRange(PS.LiveTime[0], PS.LiveTime[1]);
  17.  
  18.   // Partikelweg (Vorberechnung)
  19.   l:= (RandomRange(Round(Speed[0]*100), Round(Speed[1]*100)))/100;
  20.   Particles[ID].Precached.l:= l;
  21.  
  22.   Alpha:= (RandomRange(0, Round(Angle*100)))/100;
  23.   Particles[ID].Precached.Alpha:= Alpha;
  24.  
  25.   // Partikelweg (Hauptberechnung)
  26.   b:= cos(Bow(Alpha))*l; a:= sin(Bow(Alpha))*l;// a:=a/5; b:=b/5;
  27.   Particles[ID].Precached.b:= b;
  28.   If random(1000) < 500 then a:= a*-1;
  29.   Particles[ID].Precached.a:= a;
  30.  
  31.   // Wertübergabe
  32.   Particles[ID].Direction[0]:= a; Particles[ID].Direction[1]:= b;
  33.  
  34.   // Berechnung des Startpunkts
  35.   Particles[ID].Current[0]:= (RandomRange(0, Round(Start*100)))/100;
  36.   If Random(1000) > 500 then Particles[ID].Current[0]:= Particles[ID].Current[0]*-1;
  37.   Particles[ID].Current[1]:= 0; Particles[ID].Current[2]:= 0;
  38.   Particles[ID].Precached.Start:= Particles[ID].Current[0];
  39.  
  40.   Particles[ID].Size:= (RandomRange(Round(Size[0]*100), Round(Size[1]*100)))/100;
  41.   Particles[ID].Precached.Size:= Particles[ID].Size;
  42.  
  43.   Particles[ID].Color[0]:= (RandomRange(Round(Color[0, 0]*100), Round(Color[0, 1]*100)))/100;
  44.   Particles[ID].Color[1]:= (RandomRange(Round(Color[1, 0]*100), Round(Color[1, 1]*100)))/100;
  45.   Particles[ID].Color[2]:= (RandomRange(Round(Color[2, 0]*100), Round(Color[2, 1]*100)))/100;
  46.   Particles[ID].Color[3]:= (RandomRange(Round(Color[3, 0]*100), Round(Color[3, 1]*100)))/100;
  47.   Particles[ID].Fading:= ((Particles[ID].Color[3]*1000)/Particles[ID].LiveTime)/1000;
  48.  
  49.   Particles[ID].Precached.Color[0]:= Particles[ID].Color[0]; Particles[ID].Precached.Color[1]:= Particles[ID].Color[1];
  50.   Particles[ID].Precached.Color[2]:= Particles[ID].Color[2]; Particles[ID].Precached.Color[3]:= Particles[ID].Color[3];
  51.  
  52.   PArticles[ID].Birth:= random(length(PS.Particles) div 2);
  53.  End;
  54. End;
  55.  
  56.  
  57. Var
  58.  C: Integer;
  59.  
  60. Begin
  61.  giLoadBMP(TexFile, TF);
  62.  For C:= 0 to length(PS.Particles)-1 do
  63.   CalculateParticle(C);
  64. End;
  65.  

Dabei lagere ich manche Daten doppelt ein, um sie später nicht neu generieren zu müssen. Die Ausgabe und Neuberechnung läuft über folgende Prozedur:
Code:
  1.  
  2. Procedure giDrawParticleSystem(Var PS: Particlesystem);
  3. Procedure ReCalculateParticle(ID: Integer);
  4. Function Bow(Winkel: Single): Single;
  5. Begin
  6.  Result:= Winkel/180*Pi;
  7. End;
  8. Var
  9.  a: Single;
  10.  
  11. Begin
  12.  With PS do
  13.  Begin
  14.   Randomize;
  15.   Particles[ID].Livetime:= RandomRange(PS.LiveTime[0], PS.LiveTime[1]);
  16.  
  17.   a:= Particles[ID].Precached.a;
  18.  
  19.   Particles[ID].Direction[0]:= a; Particles[ID].Direction[1]:= Particles[ID].Precached.b;;
  20.  
  21.   Particles[ID].Current[0]:= Particles[ID].Precached.Start;
  22.   Particles[ID].Current[1]:= 0; Particles[ID].Current[2]:= 0;
  23.  
  24.   Particles[ID].Precached.Color[0]:= Particles[ID].Precached.Color[0]; Particles[ID].Color[1]:= Particles[ID].Precached.Color[1];
  25.   Particles[ID].Precached.Color[2]:= Particles[ID].Precached.Color[2]; Particles[ID].Color[3]:= Particles[ID].Precached.Color[3];
  26.  End;
  27. End;
  28.  
  29.  
  30. Procedure CalculatePosition(ID: Integer);
  31. Begin
  32.  With PS.Particles[ID] do
  33.  Begin
  34.   Color[3]:= Color[3]-Fading;
  35.   Current[0]:= Current[0]+Direction[0];
  36.   Current[1]:= Current[1]+Direction[1];
  37.  End;
  38. End;
  39.  
  40.  
  41. Procedure DrawParticle(ID: Integer);
  42. Begin
  43.  With PS.Particles[ID] do
  44.  Begin
  45.   giColor(Color[0], Color[1], Color[2], Color[3]);
  46.   giBegin(gi_Quads);
  47.    giTexEdge(1); giVertex(-Size+Current[0], Size+Current[1], 0.0+Current[2]);
  48.    giTexEdge(2); giVertex(-Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  49.    giTexEdge(3); giVertex(Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  50.    giTexEdge(4); giVertex(Size+Current[0], Size+Current[1], 0.0+Current[2]);
  51.   giEnd;
  52.  End;
  53. End;
  54.  
  55.  
  56. Var
  57.  C: Integer;
  58.  
  59. Begin
  60.  giSetTexture(PS.Texture);
  61.  giPrepareAlphaBlending;
  62.  For C:= 0 to length(PS.Particles)-1 do
  63.  Begin
  64.   If PS.Particles[C].Birth > 0 then Dec(PS.Particles[C].Birth) else
  65.   Begin
  66.    Dec(PS.Particles[C].Livetime);
  67.    If PS.Particles[C].Livetime <= 0 then ReCalculateParticle(C)
  68.    else
  69.    CalculatePosition(C);
  70.    DrawParticle(C);
  71.   End;
  72.  End;
  73.  giExitAlphaBlending;
  74. End;
  75.  


Bei mir läuft das Partikelsystem ansich sehr schnell. Aber ich würde es gerne noch optimieren.

Hier die bin's vom Partikelsystem als firedemo:
http://akwclan.servegame.org/external/fire.rar

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
TAK2004
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 10:52 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Erstmal respekt sieht gut aus und zweitens hätt ich noch ne idee zur verbesserung der perf.
Mach doch noch eine funktion rein die vor der renderschleife die position der Partikel in eine liste speichert und wenn ein schalter an ist nimmt er die liste anstatt jedesmal die pos neu zu berechnen. Ist zwar speicheraufwendiger aber wenn man die gleichen settings mehrmals hat in falle von Fakeln oder ähnliches braucht man diese nur einmal. Dies macht die FPS ein bischen besser, da ein paar rechenoperationen wegfallen.

MfG TAK2k4

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 11:25 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Danke für das Kompliment. Hätte nicht gedacht, dass jeman, der mehr Ahnung hat als ich mich mal loben könnte. Das baut dann direkt mal wieder auf.
Ich hatte ja schon extra die Steigung und die Farben etc. gespeichert, damit ich das nicht neu berechnen muss. Meinst du echt, dass würde nochmal boost geben? Aber mit dem Schalter könnte ich ja immerhin auswählen, ob ich den RAM oder die CPU vollknalle.
Ich werde es mal probieren.

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 12:08 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
So, hab jetzt so gemacht, dass das Partikelsystem beim Aufruf der Vorberechnung (giPrepareParticleSystem) das Ganze erstmal in eine Art Liste "rendert".
Diese Liste speichert die Informationen X, Y und das Fading vom Alpha. Für die Indizierung des Arrays der Liste hab ich das alles einfach an die LiveTime gekoppelt. Mit nem Schalter UseMem kann man das einstellen. Nur während der Laufzeit geht das noch nicht.

Code:
  1.  
  2. type
  3.  Particle = record
  4.   Birth: Word;
  5.   XShift: Single;
  6.   Current: Array[0..2] of Single; // Aktuelle Koordinate
  7.   Direction: Array[0..1] of Single; // Richtung bzw Geschwindigkeit
  8.   Livetime: Word; // Anzahl Renderdurchgänge bis zur Löschung
  9.   Color: Array[0..3] of Single; // Farbe im RGBA Format
  10.   Fading: Single;
  11.   Size: Single;
  12.   Precached: record
  13.    Alpha, b, a, l: Single;
  14.    Size, Start: Single;
  15.    Color: Array[0..3] of Single;
  16.    WayToMove: Array of record
  17.     X, Y, Fading: Single;
  18.    End;
  19.   End;
  20.  End;
  21.  
  22.  Particlesystem = record
  23.   UseMem: Boolean;
  24.   Texture: Cardinal;
  25.   NumOfParticles: Integer;
  26.   Speed: Array[0..1] of Single;
  27.   Start: Single;
  28.   Size: Array[0..1] of Single;
  29.   Color: Array[0..3, 0..1] of Single;
  30.   Livetime: Array[0..1] of Integer;
  31.   Angle: Integer;
  32.   Particles: Array of Particle;
  33.  End;


Code:
  1.  
  2. //*********************************************************************************************************
  3. //*********************************************************************************************************
  4.  
  5.  
  6. Procedure giDrawParticleSystem(Var PS: Particlesystem);
  7. Procedure ReCalculateParticle(ID: Integer);
  8. Function Bow(Winkel: Single): Single;
  9. Begin
  10.  Result:= Winkel/180*Pi;
  11. End;
  12. Var
  13.  a: Single;
  14.  
  15. Begin
  16.  With PS do
  17.  Begin
  18.   Randomize;
  19.   Particles[ID].Livetime:= RandomRange(PS.LiveTime[0], PS.LiveTime[1]);
  20.  
  21.   a:= Particles[ID].Precached.a;
  22.  
  23.   Particles[ID].Direction[0]:= a; Particles[ID].Direction[1]:= Particles[ID].Precached.b;;
  24.  
  25.   Particles[ID].Current[0]:= Particles[ID].Precached.Start;
  26.   Particles[ID].Current[1]:= 0; Particles[ID].Current[2]:= 0;
  27.  
  28.   Particles[ID].Precached.Color[0]:= Particles[ID].Precached.Color[0]; Particles[ID].Color[1]:= Particles[ID].Precached.Color[1];
  29.   Particles[ID].Precached.Color[2]:= Particles[ID].Precached.Color[2]; Particles[ID].Color[3]:= Particles[ID].Precached.Color[3];
  30.  End;
  31. End;
  32.  
  33.  
  34. Procedure CalculatePosition(ID: Integer);
  35. Begin
  36.  With PS.Particles[ID] do
  37.  Begin
  38.   Color[3]:= Color[3]-Fading;
  39.   Current[0]:= Current[0]+Direction[0];
  40.   Current[1]:= Current[1]+Direction[1];
  41.  End;
  42. End;
  43.  
  44.  
  45. Procedure DrawParticle(ID: Integer);
  46. Begin
  47.  With PS.Particles[ID] do
  48.  Begin
  49.   If PS.UseMem then
  50.   Begin
  51.    giColor(Color[0], Color[1], Color[2], Precached.WayToMove[LiveTime].Fading);
  52. //   giColor(Color[0], Color[1], Color[2], 1.0);
  53.    giBegin(gi_Quads);
  54.     giTexEdge(1); giVertex(-Size+Current[0], Size+Current[1], 0.0+Current[2]);
  55.     giTexEdge(2); giVertex(-Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  56.     giTexEdge(3); giVertex(Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  57.     giTexEdge(4); giVertex(Size+Current[0], Size+Current[1], 0.0+Current[2]);
  58.    giEnd;
  59.   End
  60.   else
  61.   Begin
  62.    giColor(Color[0], Color[1], Color[2], Color[3]);
  63.    giBegin(gi_Quads);
  64.     giTexEdge(1); giVertex(-Size+Current[0], Size+Current[1], 0.0+Current[2]);
  65.     giTexEdge(2); giVertex(-Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  66.     giTexEdge(3); giVertex(Size+Current[0], -Size+Current[1], 0.0+Current[2]);
  67.     giTexEdge(4); giVertex(Size+Current[0], Size+Current[1], 0.0+Current[2]);
  68.    giEnd;
  69.   End;
  70.  End;
  71. End;
  72.  
  73.  
  74. Var
  75.  F: Text;
  76.  C: Integer;
  77.  
  78. Begin
  79.  giSetTexture(PS.Texture);
  80.  giPrepareAlphaBlending;
  81.  For C:= 0 to length(PS.Particles)-1 do
  82.  Begin
  83.   If PS.Particles[C].Birth > 0 then Dec(PS.Particles[C].Birth) else
  84.   Begin
  85.    Dec(PS.Particles[C].Livetime);
  86.    If PS.Particles[C].Livetime <= 0 then ReCalculateParticle(C)
  87.    else
  88.    CalculatePosition(C);
  89.    DrawParticle(C);
  90.   End;
  91.  End;
  92.  giExitAlphaBlending;
  93. End;
  94.  
  95. //*********************************************************************************************************
  96. //*********************************************************************************************************
  97.  
  98. Procedure giPrepareParticleSystem(Var PS: Particlesystem; TexFile: String; Memory: Boolean);
  99. Procedure CalculateParticle(ID: Integer);
  100. Function Bow(Winkel: Single): Single;
  101. Begin
  102.  Result:= Winkel/180*Pi;
  103. End;
  104. Var
  105.  b, a, l, Alpha: Single;
  106.  
  107. Begin
  108.  With PS do
  109.  Begin
  110.   Randomize;
  111.   // \"Lebenszeit\"
  112.   Particles[ID].Livetime:= RandomRange(PS.LiveTime[0], PS.LiveTime[1]);
  113.  
  114.   // Partikelweg (Vorberechnung)
  115.   l:= (RandomRange(Round(Speed[0]*100), Round(Speed[1]*100)))/100;
  116.   Particles[ID].Precached.l:= l;
  117.  
  118.   Alpha:= (RandomRange(0, Round(Angle*100)))/100;
  119.   Particles[ID].Precached.Alpha:= Alpha;
  120.  
  121.   // Partikelweg (Hauptberechnung)
  122.   b:= cos(Bow(Alpha))*l; a:= sin(Bow(Alpha))*l;// a:=a/5; b:=b/5;
  123.   Particles[ID].Precached.b:= b;
  124.   If random(1000) < 500 then a:= a*-1;
  125.   Particles[ID].Precached.a:= a;
  126.  
  127.   // Wertübergabe
  128.   Particles[ID].Direction[0]:= a; Particles[ID].Direction[1]:= b;
  129.  
  130.   // Berechnung des Startpunkts
  131.   Particles[ID].Current[0]:= (RandomRange(0, Round(Start*100)))/100;
  132.   If Random(1000) > 500 then Particles[ID].Current[0]:= Particles[ID].Current[0]*-1;
  133.   Particles[ID].Current[1]:= 0; Particles[ID].Current[2]:= 0;
  134.   Particles[ID].Precached.Start:= Particles[ID].Current[0];
  135.  
  136.   Particles[ID].Size:= (RandomRange(Round(Size[0]*100), Round(Size[1]*100)))/100;
  137.   Particles[ID].Precached.Size:= Particles[ID].Size;
  138.  
  139.   Particles[ID].Color[0]:= (RandomRange(Round(Color[0, 0]*100), Round(Color[0, 1]*100)))/100;
  140.   Particles[ID].Color[1]:= (RandomRange(Round(Color[1, 0]*100), Round(Color[1, 1]*100)))/100;
  141.   Particles[ID].Color[2]:= (RandomRange(Round(Color[2, 0]*100), Round(Color[2, 1]*100)))/100;
  142.   Particles[ID].Color[3]:= (RandomRange(Round(Color[3, 0]*100), Round(Color[3, 1]*100)))/100;
  143.   Particles[ID].Fading:= ((Particles[ID].Color[3]*1000)/Particles[ID].LiveTime)/1000;
  144.  
  145.   Particles[ID].Precached.Color[0]:= Particles[ID].Color[0]; Particles[ID].Precached.Color[1]:= Particles[ID].Color[1];
  146.   Particles[ID].Precached.Color[2]:= Particles[ID].Color[2]; Particles[ID].Precached.Color[3]:= Particles[ID].Color[3];
  147.  
  148.   Particles[ID].Birth:= random(length(PS.Particles) div 2);
  149.  End;
  150. End;
  151.  
  152.  
  153. Procedure RenderToCache(ID: Integer);
  154. Var
  155.  C: Integer;
  156.  
  157. Begin
  158.  With PS.Particles[ID] do
  159.  Begin
  160.   Setlength(Precached.WayToMove, LiveTime+1);
  161.   Precached.WayToMove[LiveTime].Fading:= Color[3];
  162.   Precached.WayToMove[LiveTime].X:= Current[0];
  163.   Precached.WayToMove[LiveTime].Y:= 0.0;
  164.   For C:= LiveTime-1 downto 0 do
  165.   Begin
  166.    Precached.WayToMove[C].Fading:= Precached.WayToMove[C+1].Fading-Fading;
  167.    Precached.WayToMove[C].X:= Precached.WayToMove[C+1].X+Direction[0];
  168.    Precached.WayToMove[C].Y:= Precached.WayToMove[C+1].Y+Direction[1];
  169.   End;
  170.  End;
  171. End;
  172.  
  173.  
  174.  
  175. Var
  176.  C: Integer;
  177.  
  178. Begin
  179.  PS.UseMem:= Memory;
  180.  giLoadBMP(TexFile, PS.Texture);
  181.  For C:= 0 to length(PS.Particles)-1 do
  182.  Begin
  183.   CalculateParticle(C);
  184.   RenderToCache(C);
  185.  End;
  186. End;


Hier nochmal die neue Firedemo. Weiß nur nicht, ob das wirklich so viel schneller geworden ist:
http://akwclan.servegame.org/external/fire2.rar

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
TAK2004
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 14:00 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Hi,
besser ist relativ und was jetzt fehlt ist eine FPS anzeige sowie eine möglichkeit den schalter zur laufzeit mal umzulegen.
Achso in demo 2 ist flamme 1 = flamme 3, in demo 1 aber sind alle unterschiedlich weis nicht ob das gewollt war.
Wenn noch ein visuellen FPS counter willst, sag bescheid. Ich kann dir ein geben.
Denn Problem ist wie soll man sehen obs schneller ist wenn keine fps da ist ^^

MfG TAK2k4

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 14:02 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Ja, ein visueller wäre ganz gut. Hab nur einen für in den Fenstertitel. Aber den sieht man nur im fenstermodus. und selbiger funzt bei der compilierten version irgendwie nich.

EDIT:
Meintest du bei den Flammen das Aussehen? Ja, da hatte ich gestern an den Parametern rumgedreht, weil ich einem Freund das mal zeigen wollte.

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
TAK2004
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 19:10 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Na dann, hier hast mal ein kleines Perfmontool Marke eigenbau ^^
Ich bin noch an basteln und wenn du vieleicht schon mal in meine letzte demo geguckt hast kannst du in der readme lesen das noch doku und ein paar Indikatoren fehlen. Deswegen hab ich dir einfach mal ne komplette demo gepackt.
http://e-e.neroneus.de/GLPerfmon.rar

MfG TAK2k4

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 19:22 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Ich muss ehrlich gesagt gestehen, dass ich noch keine Demo von dir gesehen hab. Ich hab versucht über den Link unter deinen Antworten auf deine HP zu kommen, aber das geht nie.

Ist http://e-e.neroneus.de deine HP?

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
TAK2004
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 22:35 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
^^ das ist die adresse wo ich files ablege das ist ein 100MBit Server den ich mit ein paar kumpels zusammen mieten.
Die Demo findest du wenn du mal in OpenGL Thread ziemlich weit oben suchst, ist erst gestern online gegangen ^^.

MfG TAK2k4

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: So Jan 23, 2005 22:44 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Ich hab versucht mir die Demo anzugucken. Aber die geht genau wie das Beispielprog zu Perfmon nicht. Da kommt immer kurz ein schwarzer Monitor und dann kommt Windows wieder.

Momentan habe ich aber auch viel zu tun. Ich werde mal bei GElegenheit anhand deines Perfmon Progs kucken wodran es bei mir liegt.

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
TAK2004
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 24, 2005 11:44 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Das Problem liegt irgendwo bei ChangeDisplaySettings mach einfach mal selber compilieren und setzt davei einfach mal auf nicht vollbild.
Zumindestens hat es so einer dann starten können aber ist trotzdem komisch wieso das bei 2 nicht ging und beim rest schon ?:/

am perfmon interresieren dich ledeglich der uses, with GLPerfmon do,startortho bis endortho und der GLPerfmon.stop teil im quelltext.

MfG TAK2k4

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 24, 2005 12:27 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Habe mir die Demo noch nicht angeschaut sondern nur erst einmal den Code überflogen. Evtl solltest du noch deine OpenGL Ausgabe optimieren. Und zwar meine ich dort im Speziellen giBegin(gi_Quads); und giEnd. Wieso heißt das eigentlich gi? Denke aber mal, dass das direkt OpenGL ist.

Und zwar empfielt es sich, dass du glBegin und glEnd nicht "unnötig" aufrufst. Wenn du also 2000 Flächen zeichnen musst die alle vom selben Typen sind würde ich es so machen. Das ließe sich auch recht einfach einbauen.
Code:
  1. glBegin(GL_Quads);
  2. for Idx := 0 to 2000 do begin
  3.   glColor(...);
  4.   glVertex(...);
  5.   // etc.
  6. end;
  7. glEnd;


Einen größeren Geschwindigkeitsvorteil dürfest du haben, wenn du alternativ zu GL_QUADS auch einen Renderpfad mit GL_POINT einbaust. Diesen kannst du aber auch nur dann benutzen, wenn folgende Extensions unterstützt werden.
GL_ARB_point_parameters
GL_ARB_point_sprite
Durch die letzte Extension brauchst du dich nicht mehr um Texturen zu kümmern. Die werden dann immer komplett auf dem Punkt dargestellt. Bei Punkten hast du nur noch einen Vertex und die zeigen eh immer in Richtung der Kamera. Du bräuchtest dich dann nur noch um die Farbe, Position und die Größe kümmern.

Wenn du das sinnvoll optimiert und nach der Größe sortierst könntest du deine Punkte auch in einem Vertext Buffer Object schreiben und könntest dann das Zeichnen noch einmal recht stark vereinfachen und womöglich auch noch mal Beschleunigen.
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 24, 2005 13:19 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Die Partikel kann man auch in einem Vertex Program animieren. Bei NVidia gibt's Demos dazu. Ob das immer praktisch ist, hängt von der Situation ab.
Außerdem sieht es auch noch gut aus, wenn man die Partikel dreht.
Nach oben
 Profil  
Mit Zitat antworten  
Das AKW
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 24, 2005 15:36 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 30, 2004 14:49
Beiträge: 71
Wohnort: STADT Kirchen
Wenn ich ehrlich sein soll, hab ich keinen Plan, wovon ihr redet :shock:
Ich bin N00b und weiß ehrlich gesagt nix mit Renderpfad, Extensions oder Vertexprogrammen anzufangen. :oops:
Ich bin erst noch dabei, einer von den guten Codern zu werden :mrgreen:

_________________
Rock is a message.
Hear the message an you will rock!
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 24, 2005 16:18 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Okay. Wenn das so ist dann vergiss am Besten das was ich über VBO's (Vertex Buffer Objects) gesagt habe. Das ist die Möglichkeit Grafikkartenspeicher zu alloziieren um dort Vertex, Farb und Texturkoordinaten abzulegen. Das kannst du aber momentan erst einmal außer acht lassen. Solltest du dich aber später mal mit beschäftigen.

Das mit den glBegin und glEnd brauche ich jetzt aber nicht noch einmal erklären, oder?

GL_POINTS gehört zu den Grundprimitiven von OpenGL. Neben GL_QUADS, GL_TRIANGLES, etc. Ein Punkt zeichnet sich dadurch aus, dass er nur eine Vertexkoordinate besitzt. Wärend du bei einem Dreieck oder Viereck jeweils 3 oder 4 Koordinaten angeben musst genügt dort einer. Aus diesem Grund musst du bei einem Punkt noch eine Größe angeben. Das machst du mit glPointSize. Diese Angaben sind in Pixel und können von Grafikkarte zu Grafikkarte unterschiedlich ausfallen. Die Punkte werden immer gleich groß dargestellt egal wo sie sich befinden. Und sie besitzen nur eine Farbe. In diesem Zustand sind die Punkte natürlich überhaupt nicht für ein Partikelsystem einsetzbar.

Aus diesem Grund wurden die beiden Extension zur OpenGL implementation hinzugefügt. Wenn der Grafikkartentreiber eine Extension unterstützt wird der Extensionname zu einem abrufbarem Text hinzugefügt. Unser OpenGL Header liest diesen ein und versucht die Funktionspointer der Extensions zu laden. Um abzufragen ob eine Extension unterstützt wird brauchst du nur if GL_ARB_point_parameters then ... machen.

GL_ARB_point_parameters bietet Möglichkeiten die Punktgröße von OpenGL automatisch, je nach Entfernung des Punktes, anpassen zu lassen. Der selbe Effekt wie bei normalen Flächen. Umso weiter sie weg sind umso kleiner werden sie.

GL_ARB_point_sprite bietet die Möglichkeit Texturen auf Punkte anwenden zu lassen. Somit hättest du dann eine Textur als Punkt. Nichts anderes wird ja in einem Partikelsystem gemacht.

Renderpfad. Die sinnvollste und beste Möglichkeit wäre wohl, wenn du dir eine abstrakte Basisklasse anlegst. Diese definiert nur die Methoden und die Verwaltung der Partikel mit Lebenszeit, etc. Das Zeichnen hingegen wird in einer Ableitung dieser Klasse erledigt. Somit weiß das eigentliche Partikelsystem nicht als was die Partikel dargestellt werden. Die könnten dann rein theoretisch auch als kleine fliegende Schweine dargestellt werden. Wenn du dann dein Partikelsystem erzeugst erstellst du eine Instanze von den Ableitungen. Du musst natürlich überprüfen was alles unterstützt wird. Werden beide Extension (von oben) unterstützt kannst du ein Punktpartikelsystem erstellen. Sollte das nicht der Fall sein so müsstest du dann ein Herkömmliches auf Flächen basiertes System erstellen.

Über Klassen kannst du dich hier schlau machen.
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 4
  [ 48 Beiträge ]  Gehe zu Seite 1, 2, 3, 4  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: Bing [Bot] und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.015s | 15 Queries | GZIP : On ]