Hopalong - Fraktal

    • VB.NET

    Es gibt 84 Antworten in diesem Thema. Der letzte Beitrag () ist von zn-gong.

      ErfinderDesRades schrieb:

      Sinnvoll zu zeigen sind vlt. 30 Bildwechsel/s oder sowas. Also man könnte das Gehoppel berechnen lassen, alle 20ms ein Standbild schießen, und anschließend als Film vorführen.
      Aber die Darstellung des einzelnen Punktes zu beschleunigen - seh ich nicht so viel Sinn drin - oder binnich auffm falschen Dampfer?


      Aber heißt das nicht einfach, das wenn ich 30 Bilder / Sekunde haben will, dann Timer.Intervall = 1000 / 30 setzen muss ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      Nein, du berechnest erst alle Iterationen und speicherst alle x Iterationen das Bild in eine List(Of Bitmap). x ergibt sich aus der Anzahl der Iterationen geteilt durch die Anzahl der zu generierenden Bilder, beispielsweise 50 (25/s, 2s). Sobald alles fertig generiert ist (sollte maximal 2-3s gehen wenn du es sauber programmierst), spielst du die Bilder hintereinander ab.

      nafets3646 schrieb:

      x ergibt sich aus der Anzahl der Iterationen geteilt durch die Anzahl der zu generierenden Bilder, beispielsweise 50 (25/s, 2s)


      Den habe ich nicht verstanden, auch wenn das simple Mathematik ist: Wenn ich n Iterationen habe, also auch n Bilder generiere, und 30 Bilder / Sekunde zeigen will, dann muss ich jedes wievielte speichern ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      Leute ? Kann mir das keiner beantworten ?

      P.S.: Ihr werdet demnächst wahrscheinlich noch etwas mehr von mir hören, wegen der GUI, das könnte kompliziert werden :s
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      Du musst rechnen, wie lange die Animation dauern soll. Dann diese Zeit in Sekunden mit der Anzahl der Bilder pro Sekunde multiplizieren. Danach teilst du die gesamte Anzahl der Iterationen durch das Produkt von vorher.

      das war mirn bischen doof.
      wieviele Sekunden soll die Animation dauern?
      wieviele Bilder brauchst du also insgesamt?
      alle wieviele Iterationen ist also ein Snapshot fällig?

      wie gesagt: alles sehr aufwändig fürnen fragwürdigen Zweck.
      Im Grunde verschiebt sich der Schwerpunkt des Projektes weg vom Hopalong-Fraktal-Algo hin zu Generieren, Speichern und Abspielen von Film-Material.

      Gut, mal folgendes angenommen:

      Die Animation soll 5s lang gehen, die Iteration hat 100000 Schritte, und es sollen 30 Bilder / Sekunde sein.
      Also: 100000 / (30 * 5) = 666 - Also alle 666 Iterationen ein Bild ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      ThePlexian schrieb:

      Also alle 666 Iterationen ein Bild ?
      Das probier lieber aus, Windows ist kein Echtzeit-Betriebssystem.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Du musst Updates und Zeichnen getrennt voneinander durchführen.
      Schau dir mal das hier an, ist zwar nicht wirklich nen Spiel, aber das Prinzip ist das gleiche:
      [C#] [OpenSource] [Projektvorstellung] Langzeitprojekt - GameUtils
      Da siehst du dann auch gleich recht gut, wie du das Timing hinbekommst.

      Okay, aber mal eine ganz simple Frage:

      Warum dauert es um ein Vielfaches länger,
      - das Bild in einem externen Thread zu "bemalen" und es im Mainthread nur abrufen zu müssen, als
      - es direkt im Mainthread zu zeichnen ??

      Das macht für mich keinen Sinn, was verbraucht denn da so viel (relativ) Zeit ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      ThePlexian schrieb:

      Warum dauert es um ein Vielfaches länger, das Bild in einem externen Thread zu "bemalen" und es im Mainthread nur abrufen zu müssen
      Der ThreadWechsel.

      Genaueres kannichnich sagen, aber so Threads sind sehr autonome Einheiten, und da Daten von einem in den anneren zu puhlen ist ein gewaltiger Overhead.

      Im Code mag es aussehen wie dieselbe Variable, aber in Wirklichkeit hat jeder Thread >1 MB Cache, und weiß der Kuckuk, was da drin ist, und daher, was im einen Thread in dieser Variable steht, steht noch lange nicht im anneren Thread in dieser Variable, und Heiden-Theater mittm GarbageCollector und all son Zeugs.

      Das heißt mein Vorhaben geht gar nicht so richtig, denn bei einem Thread freezt die Form, und bei Multithreading ist einfach zu viel Garbage vorhanden um es schnell genug zu bekommen ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      Okay danke, dann habe ich zumindest eine Übersicht :)

      1. Habt ihr recht, ich weiß nicht ob sich der Aufwand lohnt, schließlich habe ich ca. 15 Fraktale, und das Hopalong ist das einzige mit dem Problem (die anderen basieren auf dem Lindenmayer-System --> andere Probleme, siehe unten)

      2. @Artentus: Wow..., die Lib sieht echt kompliziert aus :/ Also C#-Code ist kein Problem, ich verstehe nur nicht welche Class jetzt für mich hilfreich ist :s
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

      Sry, aber ich kann die Vorteile darin nicht sehen :s :/

      Im GDIRenderer hast du doch auch nur eine Bitmap (surface) und die Graphics (device).
      Und wenn deine Flag (rendering) True ist, wird sich ein Brush geholt, und via Graphics.Draw... gemalt :?:

      In der GameLoop, sind zwei Threads (updateThread + renderThread), die im Start Sub gestartet / im Stop Sub gecancellt werden. Aber ich verstehe den Inhalt der Loops nicht, also von UpdateLoop und RenderLoop:
      Es wird eine Stopwatch erstellt, und solange deine Threads nicht gecancelt wurden (die Flag auf False gesetzt wurde), wird iwas in einer For-Schleife geregelt, ich sehe nur was von Update und Thread.Sleep, wenn die SW eine bestimmte zeit erreicht hat. Aber was bewirkt dieses (components[i] as IUpdateable).Update(); ?

      Hier mal der Snippet, falls du nicht wissen solltest was ich meine:

      C-Quellcode

      1. List<IGameComponent> components;
      2. components = new List<IGameComponent>();
      4. '...
      6. private void UpdateLoop()
      7. {
      8. var sw = new Stopwatch();
      9. while (loopRunning)
      10. {
      11. sw.Start();
      12. for (int i = 0; i < components.Count; i++)
      13. {
      14. if (components[i] is IUpdateable)
      15. (components[i] as IUpdateable).Update();
      16. }
      17. sw.Stop();
      18. var targetMilliseconds = 1000.0 / TargetUpdatesPerSecond;
      19. if (sw.ElapsedMilliseconds < targetMilliseconds)
      20. Thread.Sleep((int)(targetMilliseconds - sw.ElapsedMilliseconds));
      21. sw.Reset();
      22. }
      23. }


      BTW: Wo ist der C#-Codetag ? Ich habe jetzt intuitiv "vb" und "/vb" durch "c" und "/c" ersetzen können, aber wo ist der Button dazu ?
      »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

    Facebook