getMYGAMEFPS (Der FPS-Counter für das Eigene Spiel!)

    • Beta

    Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von Krischkros.

      getMYGAMEFPS (Der FPS-Counter für das Eigene Spiel!)

      Name des Programms:
      getMYGAMEFPS

      Beschreibung:
      Das Programm liest die aktuellen Frames der Applikation aus.

      Screenshot(s):
      -NICHT VERFÜGBAR(Klassenbiblothek)-

      Verwendete Programmiersprache und IDE:
      Visual Basic 2010

      Systemanforderungen:
      .NET Framework 2.0

      Download:
      Siehe Anhang

      Lizenz/Weitergabe:
      Freeware...
      Benötigt Erwähnung,wenn eventuell im eigenem Spiel implementiert wird...

      Nützliches:
      Impotieren der DLL

      Verweis-> getAPPLICATIONFPS.dll

      VB.NET-Quellcode

      1. Imports getAPPLICATIONFPS


      Definition

      VB.NET-Quellcode

      1. Dim (Bsp) x As New getAPPLICATIONFPS.fpsREADING


      Nun wird ein Label und ein Timer mit dem Intervall 100 benötigt

      VB.NET-Quellcode

      1. Private Sub Timer1_Tick(sender As System.Object, e As System.EventArgs) Handles Timer1.Tick
      2. x.LoadFPS()
      3. Label1.Text = x.getFPS
      5. End Sub


      Programm ist Option Strict ON



      Mfg. eniking1998
      Dateien

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „enIking1998“ ()

      Mal ernsthaft. Das sind keine 100 Zeilen. Und dafür muss eine Erwähnung rein? Ach ja und auch bei Klassenbibliotheken kann man einen Screenshot eines Klassendiagramms haben.
      Außerdem wer nennt einen Namespace getAPPLICATIONFPS und btw. Klassennamen sollte man groß schreiben :)


      Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

      lol Timer auf 100 ms stellen. Bringt was? Hab ich permanent ne FPS von 10. Super. ist ja genau das, was ich brauch.
      Außerdem funktioniert der Counter nicht richtig.

      Quellcode

      1. 00 | 1
      2. 00 | 3959068
      3. 00 | 4476052
      4. 01 | 4165139
      5. 00 | 4153536
      6. 00 | 3912877
      7. 02 | 4300052
      8. 00 | 4089110
      9. 01 | 4070557
      10. 03 | 4076174
      11. 01 | 4146201
      12. 01 | 4142138
      13. 00 | 4282018
      14. 00 | 4124977
      15. 14 | 4150753
      16. 10 | 4144817
      17. 00 | 4193217

      Links ist dein Counter, Rechts ist die Anzahl der Ticks des Prozessors.

      Das Programm (ja ist C#, solltest du aber auch lesen können (Konverter))
      lol

      C-Quellcode

      1. class Program {
      2. static void Main( string[] args ) { // lol Konsole
      3. bool halt = false;
      5. fpsREADING lol = new fpsREADING(); // deine komische Klasse
      6. ManualResetEventSlim waitFinish = new ManualResetEventSlim( false, Environment.ProcessorCount ); // wir warten genau die Anzahl der Kerne ab
      7. long count = 0;
      9. Console.CancelKeyPress += ( sender, e ) => {
      10. e.Cancel = true; // zwar abbrechen, aber nicht zwangsweise
      11. halt = true; // alles abarbeiten
      12. };
      14. new Action( () => { // diese Action ist dazu da, die FPS anzuzeigen (hier sinds Ticks pro Sekunde)
      15. do {
      16. Console.WriteLine( "{0} | {1}", lol.getFPS, count ); // deine "FPS" und meine gezählten Durchläufe.
      17. count = 0; // zurücksetzen
      18. Thread.Sleep( 1000 ); // ne Sekunde warten
      19. } while ( !halt );
      20. } ).BeginInvoke( null, null ); // das ganze Asynchron ausführen
      22. Parallel.For( 0, // bei 0 Anfangen
      23. Environment.ProcessorCount, // bis ausschließlich Kern-Anzahl
      24. new ParallelOptions() {
      25. MaxDegreeOfParallelism = Environment.ProcessorCount // alles soll parallel laufen
      26. },
      27. i => {
      28. while ( !halt ) { // solange noch nicht angehalten wurde
      29. count += 1; // count erhöhen
      30. lol.LoadFPS(); // deine Methode ausführen
      31. }
      32. waitFinish.Set(); // hah bin fertig!
      33. } );
      35. waitFinish.Wait(); // wenn alle Threads fertig sind, beenden.
      36. }
      37. }

      Ergo: unnötig und falsch.

      Wenn ich n Spiel habe, nutze ich erstens XNA und wenn ich dann noch FPS haben will, nutz ich ne FpsComponent.
      Ist genauer, schneller und fehlerfreier - denn ne FPS-Komponente sollte schon mit 4 Milliarden Ticks pro Sekunde handlen können.

      FPS-Komponente? lol, nichtmal das, das sind genau 4 zeilen Code und das egal in welcher Sprache...Dafür wird man doch keine Lib einbinden? Und wer es nicht kann, der soll von mir aus die Lib benutzen, der sollte aber auch kein Spiel programmieren...
      Tut mir leid, aber mach lieber etwas größeres, mit etwas mehr Sinn, wie wärs mit einer Kollisions Library, damit haben viele Leute Probleme...
      Ich wollte auch mal ne total überflüssige Signatur:
      ---Leer---

      Ich frage mich immernoch warum das freigeschlaten wurde ...



      Spoiler anzeigen

      C-Quellcode

      1. public fpsREADING()
      2. {
      3. this.FPS_SECOND = DateAndTime.TimeOfDay.Second;
      4. this.refreshTIME = 0;
      5. this.ENDSUM = 0;
      6. }
      7. public void LoadFPS()
      8. {
      9. bool flag = this.FPS_SECOND == DateAndTime.TimeOfDay.Second;
      10. checked
      11. {
      12. if (flag)
      13. {
      14. this.refreshTIME++;
      15. }
      16. else
      17. {
      18. this.ENDSUM = this.refreshTIME;
      19. this.refreshTIME = 0;
      20. this.FPS_SECOND = DateAndTime.TimeOfDay.Second;
      21. }
      22. this.getFPS = this.ENDSUM;
      23. }
      24. }

      Warum sollte jemand deine Dll nutzen ?
      1. Es ist eine dll mehr im Ordner.
      2. Der quellcode ist circa 10 zeilen lang.
      3. falls jemand wirklich sowas brauchen sollte könnte er auch einfach schon einen Fertigen source code nehmen oder ?.

      MFG BlackNetworkBit
      MFG 0x426c61636b4e6574776f726b426974
      InOffical VB-Paradise IRC-Server
      webchat.freenode.net/
      Channel : ##vbparadise

      Nett. Eine Frage, hast du eine CapsLock-Zuckung ^^?
      Leider muss ich sagen, das da definitiv Verbesserungsmöglichkeiten gibt. Lese die Beiträge gut :)
      Ich mags mehr (entnommen ist der "StyleCopNorm"), wenn Eigenschaften und Methoden groß geschrieben werden und Attribute klein:

      Quellcode

      1. - variableA :int
      2. + GetData() :Data
      3. + GetTest() :void
      4. + VariableA :int