Prioritäten der Events Timer.Tick, Form.MouseMove und Form.Paint

  • VB.NET

Es gibt 15 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Prioritäten der Events Timer.Tick, Form.MouseMove und Form.Paint

    Guten Abend.

    Ich stehe vor einem kleinen Problem.
    Die Reihenfolge, oder besser: die Prioritäten, die den Events

    VB.NET-Quellcode

    1. Me.MouseMove
    2. TimerStuff.Tick
    3. Me.Paint

    zugeordnet werden passt mir nicht ganz ins Konzept.

    Folgendes Beispiel:

    VB.NET-Quellcode

    1. Dim WithEvents TimerStuff As New Timer With {.Interval = 30, .Enabled = True}
    3. Dim PX As Integer = 0
    4. Dim PY As Integer = 0
    6. Dim X As Integer = 0
    8. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    9. PX = e.X
    10. PY = e.Y
    11. Me.Invalidate()
    12. End Sub
    14. Private Sub TimerTick() Handles TimerStuff.Tick
    15. X += 1
    16. If X > Me.ClientRectangle.Width Then
    17. X = 0
    18. End If
    19. Me.Invalidate()
    20. End Sub
    22. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    23. e.Graphics.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias
    24. 'Mausposition mit gekreuzten Linien darstellen
    25. e.Graphics.DrawLine(Pens.Red, PX, 0, PX, Me.ClientRectangle.Height)
    26. e.Graphics.DrawLine(Pens.Red, 0, PY, Me.ClientRectangle.Width, PY)
    27. 'Irgendwas aufwendiges zeichnen
    28. For i As Integer = 0 To Me.ClientRectangle.Width
    29. e.Graphics.DrawLine(Pens.Green, 0, 0, X + i, Me.ClientRectangle.Height)
    30. e.Graphics.FillRectangle(Brushes.Green, X + i, Me.ClientRectangle.Height - 20, 20, 20)
    31. Next
    32. End Sub


    Wenn das ausgeführt wird (Me.DoubleBuffered auf True), dann werden ein paar grüne Rechtecke am unteren Rand gezeichnet und ein paar Linien von links oben zu den jeweilgen Punkten. Es werden auch zwei rote Linien horizontal und vertikal gezeichnet, um die Mausposition anzuzeigen.
    Wenn man die Maus nun auf der Form bewegt und in Bewegung hält, dann friert alles ein, was in der Sub TimerTick passiert (nämlich einen Wert inkrementieren).
    Das MouseMove Event "blockiert" sozusagen durch sein häufiges Auftreten das Tick Event des Timers.
    Da stellt sich mir aber die Frage wie das sein kann.
    Denn irgendwann ist der Intervall des Timers zu Ende und der Event wird ausgelöst und befindet sich in der "Warteschlange" (Ich glaube das hieß Message Queue).
    Durch Me.Invalidate() in der Sub MeMouseMove wurde auch das Paint Event ausgelöst. Abhängig, ob das vor oder nach dem Tick passiert ist wird beim Verlassen der Sub MeMouseMove entweder das Paint Event, oder das Tick Event behandelt.
    Das Problem ist allerdings: Es wird immer das Paint Event behandelt und dann sofort wieder ein neues MouseMove Event behandelt, ohne Acht auf das inzwischen schon lange eingetretene Tick Event zu geben.

    Meine Frage: Lässt sich das irgendwie steuern?
    Das Problem ist nämlich, dass die Animation weiterlaufen soll und gleichzeitig andere Dinge verschoben werden können sollen (... mögen müssen ^^).
    Falls es sich nicht steuern lässt: wie lässt sich das Problem anders lösen?
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    ErfinderDesRades schrieb:

    mir scheint, die Zeichnerei in deinem Paint-Event ist einfach zu aufwändig.

    Das ist nun wirklich nur ein Bruchteil seines Problems

    Niko Ortner schrieb:

    Wenn man die Maus nun auf der Form bewegt und in Bewegung hält, dann friert alles ein, was in der Sub TimerTick passiert (nämlich einen Wert inkrementieren).Das MouseMove Event "blockiert" sozusagen durch sein häufiges Auftreten das Tick Event des Timers.Da stellt sich mir aber die Frage wie das sein kann.

    Hallo, hast Du Dir eigentlich jemals Deinen eigenen Code kritisch angeschaut und gemerkt was Du Deinem Windows System da so zumutest ?

    Jedes MouseMove an sich ist schon extrem aufwändig, weil dazu im Hintergrund WM_Messages ausgelöst werden. Pack nen total überflüssigen 30ms Timer dazu und zeichne dann auch noch jeweils die ganze Form neu, natürlich alles nur auf dem GUI Thread. Zu allem Überfluss noche eine total sinnlose überfrachtete Paint Logik: ... und da wunderst Du Dich daß Dein System Dicke Backen macht ???

    Mein Vorschlag: kauf Dir einen neuen PC, so 2 Xeons + tolle Grafikkarte + ne Menge Speicher sollten die Performance doch um Einiges verbessern. Problem gelöst !

    Ansonsten, überleg Dir evtl mal wo Deine grössten Performance Schlucker sitzen und wie man die optimieren könnte:

    _ überlege Dir Deine Effekte und den Aufwand den sie verursachen genau: Zeichnen von Quadraten im Pixelabstand sind Blödsinn
    - zeichne nur in dem sichtbaren Rand: momentan zeichnest Du aus Faulheit mit der For-Schleife über den Clientbereich hinweg
    - muss wirklich in jedem MouseMove etwas geschehen , und genau was ???
    - wieso der Timer, wenn Du Positionsprüfungen im MouseMove Event abfangen kannst, sogar noch besser im MouseLeave, MouseEnter Event
    - was soll das Zeichnen der ganzen Form??? zeichne nur die Bereiche die wirklich neu gezeichnet werden müssen

    Letzteres wird vermutlich den drastischten Performanceschub geben: je kleiner Du die neu zu zeichnenden Rechtecke bestimmtst und nur diese invalidierst + zeichnest, desto kürzer das Paint Event

    Und nur das zählt ...

    Der von mir gepostete Code war auch nur ein Beispiel und ist deshalb nicht sinnvoll.
    Und der Code im Paint Event ist aufwändig, weil er einfach aufwändig ist. Das ist im Anwendungsfall auch so.

    Einen neuen Laptop kaufe ich bestimmt nicht wegen so 'ner sache.

    Bevor ich überlege erkläre ich mal genau was ich machen möchte:
    Ich möchte das inzwischen schon lange auf dem Friedhof liegende Programm Wave Simulator nochmal neu machen und dabei einige Dinge ändern. Und mir ist beim Testen aufgefallen, dass beim Herumziehen von Dingen auf dem Spielfeld die Simulation hängen bleibt (das phänomen, das ich meine).
    Und da ich nicht weiß, wie ich das lösen könnte (ohne einen Super Ultra 1337 PC kaufen zu müssen) habe ich gegoogelt (ohne Erfolg) und dann hier nachgefragt.

    Also ich überlege:
    -Die Kreise, die gezeichnet werden sind in der Tat sehr aufwändig, aber es ist nunmal Sinn des Programmes Kreise zu zeichnen.
    -Die Kreise werden auch im Programm teilweise außerhalb des sichtbaren Randes gezeichnet. Das ist allerdings nicht vermeidbar (und wenn der Radius die Diagonale + 10 überschreitet wird der Kreis entfernt).
    -Nicht in jedem, aber in den Situationen, wenn ein Objekt bewegt wird. Das ausgewählte Objekt wird nämlich 1. durch zwei Linien markiert, 2. neu gezeichnet.
    -Wie mir das MouseLeave bzw. MouseEnter Event hilft ist mir nicht ganz klar.
    Denn: Sobald die Maus bewegt wird soll neu gezeichnet werden, unabhängig davon, ob der Timer läuft oder nicht.
    Im der Sub TimerTick die Mausposition festzustellen ist auch möglich, aber das bringt zwei Nachteile:
    1. wird die Position dann nur neu gesetzt, wenn der Timer läuft, und
    2. passiert das im Falle eines großen Intervalles in sehr langen Abständen, was optisch nicht gerade schön aussieht.
    -Da die Kreise mehr oder weniger über die ganze Größe des Spielfeldes verteilt sind und recht häufig auftreten macht es wenig Sinn für jeden Kreis separat die Koordinaten für das zu invalidierende Rectangle auszurechnen, PictureBox_Bla.Invalidate(DasRechteck) aufzurufen und dann nochmal im der MePaint Sub alle Kreise zeichnen zu lassen.
    Ich denke da überwiegt die Dauer der Berechnung aller Koordinaten der Zeitersparnis des gezielten Invalidierens.
    Und es müssten die alten Koordinaten ebenfalls gespeichert werden, da diese ebenfalls invalidiert werden müssen, damit dort der Kreis vom Bildschirm verschwindet.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Niko Ortner schrieb:

    Der von mir gepostete Code war auch nur ein Beispiel und ist deshalb nicht sinnvoll.

    Aha, dann frag ich mich doch mal: warum postest Du ihn dann eigentlich überhaupt ? Wenn Dein eigentlicher Code doch Kreise malt statt Rechtecke, Du natürlich nicht sowohl beim Timer als auch beim MouseMove die ganze Form invalidierst, etc. etc. ???

    Ich schlag vor Du kommst mal wieder wenn Du Dir über solche geringfügigen Details abschliessende Gedanken gemacht hast. Vorher verschwendest Du nur jedermanns Zeit ...

    Weil genauso niemand glücklich ist, wenn ich den Code eins zu eins rüberkopier, weil niemand weiß was welches Objekt macht.
    Darum ein Codebeispiel, das genau diesen Fehler reproduziert.
    Aber lass es mich umschreiben:

    VB.NET-Quellcode

    1. Dim WithEvents TimerStuff As New Timer With {.Interval = 30, .Enabled = True}
    3. Dim PX As Integer = 0
    4. Dim PY As Integer = 0
    6. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    7. PX = e.X
    8. PY = e.Y
    9. Me.Invalidate()
    10. End Sub
    12. Private Sub TimerTick() Handles TimerStuff.Tick
    13. EinPaarWerteAddieren()
    14. Me.Invalidate()
    15. End Sub
    17. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    18. KompliziertesZeichnen()
    19. End Sub


    In wie fern das aufwändige Zeichnen mit dem oben genannten Problem zu tun hat weiß ich aber nicht.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    ErfinderDesRades schrieb:

    GDI ist einfach ganz schnell überfordert damit, große Flächen in so schneller Folge neu zu zeichnen

    Richtig, deswegen zeichnet man ja auch nie grosse Flächen immer wieder im Mousemove Event:
    - man zeichnet nur die (möglichst winzigen) Flächen die sich geändert haben (Invalidate auf möglichst schmale Rechtecke, nie auf die ganze Form)
    - oder benutzt Block-Transfers wenn sich grosse Bereiche verschieben

    Ansonsten gilt immer noch was ich im ersten Post geschreiben hatte

    Hier das Problem nochmal in Kurzfassung:
    Paint Event und MouseMove Event werden permanent ausgelöst, und dabei wird das Tick Event des Timers ignoriert.



    Und um auf Kangaroo zu antworten: Das einzige, was ich gezielt invalidieren kann sind die beiden Linien:

    VB.NET-Quellcode

    1. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    2. 'Zuerst die alte Position invalidieren, damit's verschwindet
    3. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    4. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    5. 'Neue Positionen übernehmen
    6. PX = e.X
    7. PY = e.Y
    8. 'Neue Positionen invalidieren, damit's dort sichtbar wird
    9. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    10. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    11. End Sub


    Das hat aber nur in einem Fall einen Vorteil: Wenn soziemlich nix auf dem Feld los ist. Und dann wäre sowiso genug Rechenleistung vorhanden um alles auf einmal zu invalidieren. Aber ich lasse es mal so.

    Das Problem ist ganz einfach:
    Wenn ich viele Objekte auf dem Bildschirm habe lohnt es sich nicht mehr alle Bereiche einzeln zu invalidieren,
    weil die zusätzliche Zeit, die es benötigen würde die Rechtecke auszurechnen wohl die
    Zeitersparnis, die man erhält, wenn man nicht alles neu zeichnen muss,
    übersteigt.
    Beziehungsweise werden die Objekte irgendwann sowiso so groß, dass sie über das Feld hinausragen und erst wieder alles invalidiert wird.

    Und: Das klärt immer noch nicht warum das Tick Event ignoriert wird.
    So kann man vielleicht vorerst so weit gehen, dass es egal ist, aber irgendwann wird man wieder zu dem Punkt kommen, wo so viel gezeichnet wird, dass genau dieser Effekt wieder auftritt.
    Und dann darf ich nochmal hier nachfragen.

    Und meine Theorie zu überprüfen habe ich getestet, wie viel Zeitersparnis das Verwenden von gezieltem Invalidieren bringt.
    Hier der Code Allgemein (Me.Doublebffered natürlich auf True):
    Klasse "Emitters"

    VB.NET-Quellcode

    1. Public Class Emitters
    3. Public Class PulseType
    5. Public OnCount(7) As Boolean
    6. Public Factor As Integer
    7. Public Break As Integer
    9. Public Sub New(ByVal NewFactor As Integer, ByVal NewBreak As Integer, ByVal NewOn1 As Boolean, ByVal NewOn2 As Boolean, ByVal NewOn3 As Boolean, ByVal NewOn4 As Boolean, ByVal NewOn5 As Boolean, ByVal NewOn6 As Boolean, ByVal NewOn7 As Boolean, ByVal NewOn8 As Boolean)
    10. OnCount = New Boolean() {NewOn1, NewOn2, NewOn3, NewOn4, NewOn5, NewOn6, NewOn7, NewOn8}
    11. Factor = NewFactor
    12. Break = NewBreak
    13. End Sub
    15. Public Function GetString() As String
    16. Return Factor.ToString & "/" & (Break + 1).ToString & "/" & If(OnCount(0), "1", "0") & If(OnCount(1), "1", "0") & If(OnCount(2), "1", "0") & If(OnCount(3), "1", "0") & If(OnCount(4), "1", "0") & If(OnCount(5), "1", "0") & If(OnCount(6), "1", "0") & If(OnCount(7), "1", "0")
    17. End Function
    19. End Class
    21. Public MustInherit Class WaveBaseClass
    23. Public PositionX As Integer
    24. Public PositionY As Integer
    26. Public MaximumRadius As Double
    27. Public AutoMaximum As Boolean
    29. Public WaveColor As Color
    30. Public WaveWidth As Single
    32. Public Tag As String = "WaveBaseClass"
    34. Public Function CreateWave() As SingleWave
    35. Return New SingleWave(PositionX, PositionY, MaximumRadius, AutoMaximum, WaveColor, WaveWidth)
    36. End Function
    38. End Class
    40. Public Class SingleWave
    41. Inherits WaveBaseClass
    43. Public Shared Property SharedTag As String = "SingleWave"
    45. Public Radius As Single
    47. Public Sub New(ByVal NewPositionX As Integer, ByVal NewPositionY As Integer, ByVal NewMaximumRadius As Double, ByVal NewAutoMaximum As Boolean, ByVal NewWaveColor As Color, ByVal NewWaveWidth As Single, Optional ByVal InitialRadius As Single = 0)
    48. Tag = SharedTag
    49. PositionX = NewPositionX
    50. PositionY = NewPositionY
    51. Radius = InitialRadius
    52. MaximumRadius = NewMaximumRadius
    53. AutoMaximum = NewAutoMaximum
    54. WaveColor = NewWaveColor
    55. WaveWidth = NewWaveWidth
    56. End Sub
    58. Public Shared Function RadToDegree(ByVal RadAngle As Double) As Double
    59. Return (RadAngle * 360.0) / (Math.PI * 2.0)
    60. End Function
    62. End Class
    64. Public Class Pulser
    65. Inherits WaveBaseClass
    67. Public Shared Property SharedTag As String = "Pulser"
    69. Public Delay As Integer
    70. Public Counter As Integer
    72. Public Sub New(ByVal NewPositionX As Integer, ByVal NewPositionY As Integer, ByVal NewMaximumRadius As Double, ByVal NewAutoMaximum As Boolean, ByVal NewWaveColor As Color, ByVal NewWaveWidth As Single, ByVal NewDelay As Integer)
    73. Tag = "Pulser"
    74. PositionX = NewPositionX
    75. PositionY = NewPositionY
    76. MaximumRadius = NewMaximumRadius
    77. AutoMaximum = NewAutoMaximum
    78. WaveColor = NewWaveColor
    79. WaveWidth = NewWaveWidth
    80. Delay = NewDelay
    81. Counter = 0
    82. End Sub
    84. End Class
    86. Public Class IndividualPulser
    87. Inherits WaveBaseClass
    89. Public Shared Property SharedTag As String = "IndividualPulser"
    91. Public EmitterPulseType As PulseType
    92. Public PartCount As Integer
    93. Public Count As Integer
    95. Public Sub New(ByVal NewPositionX As Integer, ByVal NewPositionY As Integer, ByVal NewMaximumRadius As Double, ByVal NewAutoMaximum As Boolean, ByVal NewWaveColor As Color, ByVal NewWaveWidth As Single, ByVal NewPulseType As PulseType)
    96. Tag = SharedTag
    97. PositionX = NewPositionX
    98. PositionY = NewPositionY
    99. MaximumRadius = NewMaximumRadius
    100. AutoMaximum = NewAutoMaximum
    101. WaveColor = NewWaveColor
    102. WaveWidth = NewWaveWidth
    103. EmitterPulseType = NewPulseType
    104. PartCount = 0
    105. Count = 0
    106. End Sub
    108. End Class
    110. Public Class OnHitPulser
    111. Inherits WaveBaseClass
    113. Public Shared Property SharedTag As String = "OnHitPulser"
    115. Public Delay As Integer
    116. Public Counter As Integer
    118. Public Sub New(ByVal NewPositionX As Integer, ByVal NewPositionY As Integer, ByVal NewMaximumRadius As Double, ByVal NewAutoMaximum As Boolean, ByVal NewWaveColor As Color, ByVal NewWaveWidth As Single, ByVal NewDelay As Integer)
    119. Tag = SharedTag
    120. PositionX = NewPositionX
    121. PositionY = NewPositionY
    122. MaximumRadius = NewMaximumRadius
    123. AutoMaximum = NewAutoMaximum
    124. WaveColor = NewWaveColor
    125. WaveWidth = NewWaveWidth
    126. Delay = NewDelay
    127. Counter = 0
    128. End Sub
    130. Public Function WasIntersect(ByVal TargetedWave As SingleWave, ByVal Increment As Single) As Boolean
    131. Dim Difference As Double = Math.Sqrt((TargetedWave.PositionX - PositionX) ^ 2 + (TargetedWave.PositionY - PositionY) ^ 2) - TargetedWave.Radius
    132. Return Difference >= -Increment And Difference < 0
    133. End Function
    135. End Class
    137. End Class


    'Hauptformular

    VB.NET-Quellcode

    1. Public Class Form1
    3. Dim WithEvents TimerStuff As New Timer With {.Interval = 30, .Enabled = True}
    5. Dim PX As Integer = 0
    6. Dim PY As Integer = 0
    8. Dim AllWaves As New List(Of Emitters.SingleWave)
    9. Dim AllEmitters As New List(Of Emitters.WaveBaseClass)
    11. Dim RadiusIncrement As Single = 2
    13. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    14. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    15. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    16. PX = e.X
    17. PY = e.Y
    18. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    19. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    20. End Sub
    22. Private Function GetMaximumRadius() As Double
    23. Return Math.Sqrt((Me.ClientRectangle.Width) ^ 2 + (Me.ClientRectangle.Height) ^ 2) + 10
    24. End Function
    26. Private Sub MeMouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseDown
    27. Select Case e.Button
    28. Case Windows.Forms.MouseButtons.Left
    29. AllWaves.Add(New Emitters.SingleWave(e.X, e.Y, GetMaximumRadius, True, Color.Green, 1, 0))
    30. Case Windows.Forms.MouseButtons.Right
    31. AllEmitters.Add(New Emitters.Pulser(e.X, e.Y, GetMaximumRadius, True, Color.Red, 1, 40))
    32. End Select
    33. End Sub
    35. Private Sub TimerTick() Handles TimerStuff.Tick
    36. For Each i As Emitters.WaveBaseClass In AllEmitters
    37. Select Case i.Tag
    38. Case Emitters.Pulser.SharedTag
    39. With DirectCast(i, Emitters.Pulser)
    40. If .Counter = 0 Then
    41. AllWaves.Add(.CreateWave)
    42. End If
    43. .Counter += 1
    44. If .Counter >= .Delay Then
    45. .Counter = 0
    46. End If
    47. End With
    48. Case Emitters.IndividualPulser.SharedTag
    49. With DirectCast(i, Emitters.IndividualPulser)
    50. If .PartCount = 0 Then
    51. If .EmitterPulseType.OnCount(.Count) Then
    52. AllWaves.Add(.CreateWave)
    53. End If
    54. .Count += 1
    55. If .Count > .EmitterPulseType.Break Then
    56. .Count = 0
    57. End If
    58. End If
    59. .PartCount += 1
    60. If .PartCount >= .EmitterPulseType.Factor Then
    61. .PartCount = 0
    62. End If
    63. End With
    64. Case Emitters.OnHitPulser.SharedTag
    65. With DirectCast(i, Emitters.OnHitPulser)
    66. If .Counter = 0 Then
    67. Dim WillIntersect As Boolean = False
    68. For j As Integer = 0 To AllWaves.Count - 1
    69. If .WasIntersect(AllWaves(j), RadiusIncrement) Then
    70. WillIntersect = True
    71. Exit For
    72. End If
    73. Next
    74. If WillIntersect Then
    75. AllWaves.Add(.CreateWave)
    76. .Counter += 1
    77. End If
    78. ElseIf .Counter >= .Delay - 1 Then
    79. .Counter = 0
    80. Else
    81. .Counter += 1
    82. End If
    83. End With
    84. End Select
    85. Next
    86. Dim ThisIndex As Integer = 0
    87. Dim MaximumIndex As Integer = AllWaves.Count - 1
    88. Do Until ThisIndex > MaximumIndex
    89. With AllWaves(ThisIndex)
    90. If .AutoMaximum Then
    91. .MaximumRadius = GetMaximumRadius()
    92. End If
    93. If .Radius > .MaximumRadius Then
    94. ThisIndex += 1
    95. Else
    96. .Radius += RadiusIncrement
    97. End If
    98. End With
    99. ThisIndex += 1
    100. Loop
    101. Me.Invalidate()
    102. End Sub
    104. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    105. e.Graphics.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias
    106. For Each i As Emitters.SingleWave In AllWaves
    107. e.Graphics.DrawEllipse(New Pen(i.WaveColor, i.WaveWidth), i.PositionX - i.Radius, i.PositionY - i.Radius, i.Radius * 2, i.Radius * 2)
    108. Next
    109. For Each i As Emitters.WaveBaseClass In AllEmitters
    110. e.Graphics.FillRectangle(New SolidBrush(i.WaveColor), i.PositionX - 1, i.PositionY - 1, 3, 3)
    111. Next
    112. e.Graphics.DrawLine(Pens.Red, PX, 0, PX, Me.ClientRectangle.Height)
    113. e.Graphics.DrawLine(Pens.Red, 0, PY, Me.ClientRectangle.Width, PY)
    114. End Sub
    116. End Class



    Und hier der Code für das Zeichnen mit gezieltem Invalidieren:
    Was sich geändert hat ist der untere Teil der TimerTick Sub.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Sub TimerTick() Handles TimerStuff.Tick
    3. '...
    5. Dim ThisIndex As Integer = 0
    6. Dim MaximumIndex As Integer = AllWaves.Count - 1
    7. Do Until ThisIndex > MaximumIndex
    8. With AllWaves(ThisIndex)
    9. If .AutoMaximum Then
    10. .MaximumRadius = GetMaximumRadius()
    11. End If
    12. If .Radius > .MaximumRadius Then
    13. ThisIndex += 1
    14. Else
    15. .Radius += RadiusIncrement
    16. End If
    17. Me.Invalidate(New Rectangle(CInt(.PositionX - .Radius - .WaveWidth / 2), _
    18. CInt(.PositionY - .Radius - .WaveWidth / 2), _
    19. CInt(.Radius * 2 + 1), _
    20. CInt(.Radius * 2 + 1)))
    21. End With
    22. ThisIndex += 1
    23. Loop
    24. End Sub


    Auch das behebt das Problem nicht.
    Und was schneller ist müsste man bei mehreren bestimmten Anzahlen von Objekten auf dem Feld messen lassen und in ein Diagramm packen. Dann sieht man, was schneller ist.
    Das könnte ich auch noch machen, wird aber etwas dauern.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    gezieltes Invalidieren des Fadenkreuzes bringt nix.

    Die beiden Aufrufe fließen zusammen, und neu gezeichnet wird dann das umschließende Rechteck beider Invalidierungen. Und das ist grad im Fall eines Fadenkreuzes die gesamte Control-Fläche.

    kannst dir auch die Comments von Control mit beweglicher Figur durchlesen (oder auch nicht) - da habich dasselbe geschrieben. Aber immerhin da bringt das was.

    Danke für die Informationen.
    Ich hab gesehen worum's geht.
    Allerdings werden die beiden Rectangles schön separat invalidiert. Möglicherweise werden intern Regions verwendet. Die können solche Formationen beinhalten.
    Der Test:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. 'Ein Timer, der so schnell wie möglich invalidiert
    2. Dim WithEvents TimerStuff As New Timer With {.Enabled = True, .Interval = 1}
    4. 'Positionen der beiden Linien
    5. Dim LastX As Integer = 0
    6. Dim LastY As Integer = 0
    8. 'Nacheinander werden unterschiedliche Farben gezeichnet
    9. Dim ColIndex As Integer = 0
    10. Dim Colors As New List(Of Color)
    12. 'Farben auswählen
    13. Private Sub Initialize() Handles MyBase.Load
    14. Colors.Add(Color.Red)
    15. Colors.Add(Color.Green)
    16. Colors.Add(Color.Blue)
    17. Colors.Add(Color.Yellow)
    18. Colors.Add(Color.Lime)
    19. Colors.Add(Color.Black)
    20. Colors.Add(Color.Pink)
    21. Colors.Add(Color.Cyan)
    22. End Sub
    24. 'Positionen übernehmen
    25. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    26. LastX = e.X
    27. LastY = e.Y
    28. End Sub
    30. 'Bereiche der Linien invalidieren
    31. Private Sub Calc() Handles TimerStuff.Tick
    32. Me.Invalidate(New Rectangle(LastX, 0, 1, Me.ClientRectangle.Height))
    33. Me.Invalidate(New Rectangle(0, LastY, Me.ClientRectangle.Width, 1))
    34. End Sub
    36. 'Zeichnen
    37. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    38. 'Bei jeder Zeichnung wird die nächste Farbe gewählt
    39. ColIndex += 1
    40. If ColIndex >= Colors.Count Then
    41. ColIndex = 0
    42. End If
    43. 'Anschließend wird alles auf eine Farbe gesetzt;
    44. 'Nur die invalidierten Bereiche wechseln die Farbe
    45. e.Graphics.Clear(Colors(ColIndex))
    46. End Sub



    Weil beim Starten der Anwendung natürlich der gesamte Bereich invalidiert wird wird erst mal alles grün. Dann kann man gut erkennen, dass wirklich nur die Rectangles neu gezeichnet werden, die bei .Invalidate() angegeben wurden.


    Ich wollte noch mehr schreiben, aber eine Nachricht darf nur 15000 Zeichen enthalten. Darum kommt das Andere später.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Niko Ortner schrieb:

    Allerdings werden die beiden Rectangles schön separat invalidiert.

    jo, der Invalidate-Aufruf erfolgt separat. Der ist auch sehr schnell, und beide Aufrufe erfolgen, ehe das nächste Paint-Event feuert.
    Aber im Paint-Event das übergebene Graphics ist geclipt, und zwar auf das umschließende Rechteck aller zwischenzeitlich eingegangenen Invalidate-Aufrufe.
    Und dassis leider das ganze Control.

    kannst ja e.ClipRectangle im Debugfenster ausgeben.

    Ach soooo...
    Ich weiß nicht wie ich anfangen soll, darum frage ich gerade heraus:
    Was ist der Unterschied zwischen den invalidierten Bereichen und dem Clip-Rectangle des Graphics-Objektes.
    Gezeichnet wird Ändern tut sich's ja nur in den invalidierten Bereichen.


    Und was ich vorhin noch schreiben wollte:

    Ich habe mit mehreren Objekten Tests durchgeführt.
    Von 4 bis 24 Emitter in 4-er Schritten bin ich durchgegangen und habe gemessen, wie schnell das Tick-Event aufgerufen wird. Es wurde bis 500 Ticks gemessen.

    Auf der X-Achse ist die anzahl an vergangenen Ticks.
    Auf der Y Achse der Zeitunterschied des ersten Ticks zu den nachfolgenden Ticks. Die Anzahl an Objekten ist dabei durchschnittlich angestiegen (Das Maximum bei 24 Emittern war 600).
    Die einzelnen Farben zeigen die Anzahl an Emittern auf dem Feld (Je weiter oben, desto mehr Emitter waren es; ganz unten 4, dann 8, ganz oben 24).
    Dabei zeigt die hellere Linie die Zeiten ohne gezieltes Invalidieren an und die dunklere Linie mit gezieltem Invalidieren.

    Man erkennt: Nahezu kein Unterschied. Und wenn man die Ungenauigkeit des Verfahrens dazunimmt kann man den Unterschied gleich vergessen.

    Wer es testen will, hier der Code (Die Klasse Emitters ist gleich geblieben):
    Alles Invalidieren

    VB.NET-Quellcode

    1. Public Class Form1
    3. Dim WithEvents TimerStuff As New Timer With {.Interval = 1, .Enabled = True}
    5. Dim PX As Integer = 0
    6. Dim PY As Integer = 0
    8. Dim AllWaves As New List(Of Emitters.SingleWave)
    9. Dim AllEmitters As New List(Of Emitters.WaveBaseClass)
    11. Dim RadiusIncrement As Single = 2
    13. Private Sub Initialize() Handles Me.Shown
    14. Dim Rnd As New Random
    15. 'Hier wird angegeben, wie viele Emitter sich zum Testen auf dem Feld befinden sollen
    16. For i As Integer = 1 To 24
    17. AllEmitters.Add(New Emitters.Pulser(Rnd.Next(0, Me.ClientRectangle.Width), Rnd.Next(0, Me.ClientRectangle.Height), GetMaximumRadius, True, Color.Red, 1, 20))
    18. Next
    19. End Sub
    21. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    22. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    23. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    24. PX = e.X
    25. PY = e.Y
    26. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    27. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    28. End Sub
    30. Private Function GetMaximumRadius() As Double
    31. Return Math.Sqrt((Me.ClientRectangle.Width) ^ 2 + (Me.ClientRectangle.Height) ^ 2) + 10
    32. End Function
    34. Private Sub MeMouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseDown
    35. Select Case e.Button
    36. Case Windows.Forms.MouseButtons.Left
    37. AllWaves.Add(New Emitters.SingleWave(e.X, e.Y, GetMaximumRadius, True, Color.Green, 1, 0))
    38. Case Windows.Forms.MouseButtons.Right
    39. AllEmitters.Add(New Emitters.Pulser(e.X, e.Y, GetMaximumRadius, True, Color.Red, 1, 40))
    40. End Select
    41. End Sub
    43. #Region "Testen"
    45. Dim TimesList As New List(Of Double)
    46. Dim CountsList As New List(Of Integer)
    48. Dim FirstTime As DateTime = Now
    50. Private Sub WriteFile()
    51. Dim SB As New System.Text.StringBuilder
    52. For i As Integer = 0 To TimesList.Count - 1
    53. SB.AppendLine(TimesList(i).ToString & ";" & CountsList(i).ToString)
    54. Next
    55. System.IO.File.WriteAllText("C:\Users\Administrator\Desktop\Zeiten\Ohne\Times_" & AllEmitters.Count.ToString & ".txt", SB.ToString, System.Text.Encoding.Default)
    56. End Sub
    58. Private Sub TimerTick() Handles TimerStuff.Tick
    59. TimesList.Add(Now.Subtract(FirstTime).TotalMilliseconds)
    60. CountsList.Add(AllWaves.Count)
    61. If TimesList.Count = 500 Then
    62. TimerStuff.Enabled = False
    63. WriteFile()
    64. End If
    65. For Each i As Emitters.WaveBaseClass In AllEmitters
    66. Select Case i.Tag
    67. Case Emitters.Pulser.SharedTag
    68. With DirectCast(i, Emitters.Pulser)
    69. If .Counter = 0 Then
    70. AllWaves.Add(.CreateWave)
    71. End If
    72. .Counter += 1
    73. If .Counter >= .Delay Then
    74. .Counter = 0
    75. End If
    76. End With
    77. Case Emitters.IndividualPulser.SharedTag
    78. With DirectCast(i, Emitters.IndividualPulser)
    79. If .PartCount = 0 Then
    80. If .EmitterPulseType.OnCount(.Count) Then
    81. AllWaves.Add(.CreateWave)
    82. End If
    83. .Count += 1
    84. If .Count > .EmitterPulseType.Break Then
    85. .Count = 0
    86. End If
    87. End If
    88. .PartCount += 1
    89. If .PartCount >= .EmitterPulseType.Factor Then
    90. .PartCount = 0
    91. End If
    92. End With
    93. Case Emitters.OnHitPulser.SharedTag
    94. With DirectCast(i, Emitters.OnHitPulser)
    95. If .Counter = 0 Then
    96. Dim WillIntersect As Boolean = False
    97. For j As Integer = 0 To AllWaves.Count - 1
    98. If .WasIntersect(AllWaves(j), RadiusIncrement) Then
    99. WillIntersect = True
    100. Exit For
    101. End If
    102. Next
    103. If WillIntersect Then
    104. AllWaves.Add(.CreateWave)
    105. .Counter += 1
    106. End If
    107. ElseIf .Counter >= .Delay - 1 Then
    108. .Counter = 0
    109. Else
    110. .Counter += 1
    111. End If
    112. End With
    113. End Select
    114. Next
    115. Dim ThisIndex As Integer = 0
    116. Dim MaximumIndex As Integer = AllWaves.Count - 1
    117. Do Until ThisIndex > MaximumIndex
    118. With AllWaves(ThisIndex)
    119. If .AutoMaximum Then
    120. .MaximumRadius = GetMaximumRadius()
    121. End If
    122. If .Radius > .MaximumRadius Then
    123. ThisIndex += 1
    124. Else
    125. .Radius += RadiusIncrement
    126. End If
    127. End With
    128. ThisIndex += 1
    129. Loop
    130. Me.Invalidate()
    131. End Sub
    133. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    134. e.Graphics.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias
    135. For Each i As Emitters.SingleWave In AllWaves
    136. e.Graphics.DrawEllipse(New Pen(i.WaveColor, i.WaveWidth), i.PositionX - i.Radius, i.PositionY - i.Radius, i.Radius * 2, i.Radius * 2)
    137. Next
    138. For Each i As Emitters.WaveBaseClass In AllEmitters
    139. e.Graphics.FillRectangle(New SolidBrush(i.WaveColor), i.PositionX - 1, i.PositionY - 1, 3, 3)
    140. Next
    141. e.Graphics.DrawLine(Pens.Red, PX, 0, PX, Me.ClientRectangle.Height)
    142. e.Graphics.DrawLine(Pens.Red, 0, PY, Me.ClientRectangle.Width, PY)
    143. End Sub
    145. #End Region
    147. End Class


    Gezieltes Invalidieren

    VB.NET-Quellcode

    1. Public Class Form1
    3. Dim WithEvents TimerStuff As New Timer With {.Interval = 1, .Enabled = True}
    5. Dim PX As Integer = 0
    6. Dim PY As Integer = 0
    8. Dim AllWaves As New List(Of Emitters.SingleWave)
    9. Dim AllEmitters As New List(Of Emitters.WaveBaseClass)
    11. Dim RadiusIncrement As Single = 2
    13. Private Sub Initialize() Handles Me.Shown
    14. Dim Rnd As New Random
    15. 'Hier wird angegeben, wie viele Emitter sich zum Testen auf dem Feld befinden sollen
    16. For i As Integer = 1 To 24
    17. AllEmitters.Add(New Emitters.Pulser(Rnd.Next(0, Me.ClientRectangle.Width), Rnd.Next(0, Me.ClientRectangle.Height), GetMaximumRadius, True, Color.Red, 1, 20))
    18. Next
    19. End Sub
    21. Private Sub MeMouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseMove
    22. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    23. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    24. PX = e.X
    25. PY = e.Y
    26. Me.Invalidate(New Rectangle(PX, 0, 1, Me.ClientRectangle.Height))
    27. Me.Invalidate(New Rectangle(0, PY, Me.ClientRectangle.Width, 1))
    28. End Sub
    30. Private Function GetMaximumRadius() As Double
    31. Return Math.Sqrt((Me.ClientRectangle.Width) ^ 2 + (Me.ClientRectangle.Height) ^ 2) + 10
    32. End Function
    34. Private Sub MeMouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseDown
    35. Select Case e.Button
    36. Case Windows.Forms.MouseButtons.Left
    37. AllWaves.Add(New Emitters.SingleWave(e.X, e.Y, GetMaximumRadius, True, Color.Green, 1, 0))
    38. Case Windows.Forms.MouseButtons.Right
    39. AllEmitters.Add(New Emitters.Pulser(e.X, e.Y, GetMaximumRadius, True, Color.Red, 1, 40))
    40. End Select
    41. End Sub
    43. #Region "Testen"
    45. Dim TimesList As New List(Of Double)
    46. Dim CountsList As New List(Of Integer)
    48. Dim FirstTime As DateTime = Now
    50. Private Sub WriteFile()
    51. Dim SB As New System.Text.StringBuilder
    52. For i As Integer = 0 To TimesList.Count - 1
    53. SB.AppendLine(TimesList(i).ToString & ";" & CountsList(i).ToString)
    54. Next
    55. System.IO.File.WriteAllText("C:\Users\Administrator\Desktop\Zeiten\Mit\Times_" & AllEmitters.Count.ToString & ".txt", SB.ToString, System.Text.Encoding.Default)
    56. End Sub
    58. Private Sub TimerTick() Handles TimerStuff.Tick
    59. TimesList.Add(Now.Subtract(FirstTime).TotalMilliseconds)
    60. CountsList.Add(AllWaves.Count)
    61. If TimesList.Count = 500 Then
    62. TimerStuff.Enabled = False
    63. WriteFile()
    64. End If
    65. For Each i As Emitters.WaveBaseClass In AllEmitters
    66. Select Case i.Tag
    67. Case Emitters.Pulser.SharedTag
    68. With DirectCast(i, Emitters.Pulser)
    69. If .Counter = 0 Then
    70. AllWaves.Add(.CreateWave)
    71. End If
    72. .Counter += 1
    73. If .Counter >= .Delay Then
    74. .Counter = 0
    75. End If
    76. End With
    77. Case Emitters.IndividualPulser.SharedTag
    78. With DirectCast(i, Emitters.IndividualPulser)
    79. If .PartCount = 0 Then
    80. If .EmitterPulseType.OnCount(.Count) Then
    81. AllWaves.Add(.CreateWave)
    82. End If
    83. .Count += 1
    84. If .Count > .EmitterPulseType.Break Then
    85. .Count = 0
    86. End If
    87. End If
    88. .PartCount += 1
    89. If .PartCount >= .EmitterPulseType.Factor Then
    90. .PartCount = 0
    91. End If
    92. End With
    93. Case Emitters.OnHitPulser.SharedTag
    94. With DirectCast(i, Emitters.OnHitPulser)
    95. If .Counter = 0 Then
    96. Dim WillIntersect As Boolean = False
    97. For j As Integer = 0 To AllWaves.Count - 1
    98. If .WasIntersect(AllWaves(j), RadiusIncrement) Then
    99. WillIntersect = True
    100. Exit For
    101. End If
    102. Next
    103. If WillIntersect Then
    104. AllWaves.Add(.CreateWave)
    105. .Counter += 1
    106. End If
    107. ElseIf .Counter >= .Delay - 1 Then
    108. .Counter = 0
    109. Else
    110. .Counter += 1
    111. End If
    112. End With
    113. End Select
    114. Next
    115. Dim ThisIndex As Integer = 0
    116. Dim MaximumIndex As Integer = AllWaves.Count - 1
    117. Do Until ThisIndex > MaximumIndex
    118. With AllWaves(ThisIndex)
    119. If .AutoMaximum Then
    120. .MaximumRadius = GetMaximumRadius()
    121. End If
    122. If .Radius > .MaximumRadius Then
    123. ThisIndex += 1
    124. Else
    125. .Radius += RadiusIncrement
    126. End If
    127. Me.Invalidate(New Rectangle(CInt(.PositionX - .Radius - .WaveWidth / 2), _
    128. CInt(.PositionY - .Radius - .WaveWidth / 2), _
    129. CInt(.Radius * 2 + 1), _
    130. CInt(.Radius * 2 + 1)))
    131. End With
    132. ThisIndex += 1
    133. Loop
    134. End Sub
    136. Private Sub MePaint(ByVal sender As Object, ByVal e As PaintEventArgs) Handles Me.Paint
    137. e.Graphics.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias
    138. For Each i As Emitters.SingleWave In AllWaves
    139. e.Graphics.DrawEllipse(New Pen(i.WaveColor, i.WaveWidth), i.PositionX - i.Radius, i.PositionY - i.Radius, i.Radius * 2, i.Radius * 2)
    140. Next
    141. For Each i As Emitters.WaveBaseClass In AllEmitters
    142. e.Graphics.FillRectangle(New SolidBrush(i.WaveColor), i.PositionX - 1, i.PositionY - 1, 3, 3)
    143. Next
    144. e.Graphics.DrawLine(Pens.Red, PX, 0, PX, Me.ClientRectangle.Height)
    145. e.Graphics.DrawLine(Pens.Red, 0, PY, Me.ClientRectangle.Width, PY)
    146. End Sub
    148. #End Region
    150. End Class



    Das gilt vor allem für Kangaroo: Bitte sieh Dir das Diagramm an und sag mir ob das gezielte Invalidieren den Unterschied macht. (Dass das Problem dadurch nicht behoben wurde habe ich bereits in Post #9 erwähnt).
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Niko Ortner schrieb:

    Was ist der Unterschied zwischen den invalidierten Bereichen und dem Clip-Rectangle des Graphics-Objektes.

    zwischen 2 Paint-Vorgängen können mehrere gezielte Invalidierungen stattfinden. Intern wird der Clip als das umschließende Rechteck aller Invalidierungen berechnet., und dieses Rechteck wird im Paint gezeichnet.

    Aber mir leuchtet nicht ganz ein warum der Clip Bereich nötig ist, wenn sowiso nur die invalidierten Bereiche neu gezeichnet werden.
    Ich kenne die .SetClip() Methode, bei der auch GraphicsPaths, Regions, etc. angegeben werden können. Nur in wie fern unterscheidet sich das dann von den invalidierten Bereichen? Wirkt sich das Kleinhalten des Clip Bereiches signifikant auf die Performance aus? Wenn ja: Warum wird dann der Clip Bereich als umschließendes Rechteck ausgelegt, und nicht gleich genau so, wie es bei den Invalidierungen angegeben wurde.

    So wie ich es zur Zeit verstehe:

    VB.NET-Quellcode

    1. Dim Rec1 As New Rectangle(0, 0, 100, 100)
    2. Dim Rec2 As New Rectangle(200, 200, 100, 100)
    3. Me.Invalidate(Rec1)
    4. Me.Invalidate(Rec2)
    5. 'Ergibt als Clip-Rectangle:
    6. 'X=0, Y=0, Width = 300, Height=300
    7. 'Gezeichnet werden aber nur die Bereiche, die durch Rec1 und Rec2 bestimmt sind, und nicht der ganze Clip Bereich.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Du hast mit SetClip nix zu schaffe, das macht Windows für dich.
    Und Windows kann nicht jedesmal neu painten, wenn du Invalidate aufrufst - das wäre in anderen Fällen total unperformant, und ist glaub auch technisch nicht möglich (Bildwechselrate und solche sachen).

    Also werden, wenn sie schnell aufeinander folgen, die Rectangles mehrerer Invalidates zusammengefasst zu einem.
    Das einzelne Invalidate(rct) gibt ein Rectangle an, und merkt vor, dass bei nächster Gelegenheit neu gezeichnet wird.

    Und für die Performance ist entscheidend, wie groß das ClipRectangle schließlich ist, welches geneuzeichnet wird.

    Also du kannst ziemlich bedenkenlos den Code zum Zeichnen des gesamten Controls durchlaufen lassen - das Graphics-Objekt ignoriert davon alles, was nicht in seim ClipRectangle liegt.

Facebook
Telefonspende