Wiedermal ein wenig mit GDI rumgespielt und einen wirklich netten Effekt erhalten. Das Ganze kann man vielleicht auch als Benchmark benutzen. Man kann eigentlich so gut wie alles anpassen 
[Blockierte Grafik: http://sninfando.magix.net/public/poly.png]
Viel Spaß! 
Nochmal deutlicher, was das AntiAliasing ausmacht. Hier zwei Modi, jeweils bei 50000er RotRange:
AntiAliasing 1x
[Blockierte Grafik: http://sninfando.magix.net/public/poly2.png]
AntiAliasing 20x
[Blockierte Grafik: http://sninfando.magix.net/public/poly3.png]
Logischerweise drückt das AA die Performance ganz schön
Die Effizienz deines AA Algorithmus ist... unkonventionell :D. Ansonsten sieht das wirklich hübsch aus, cooler und simpler Effekt.
Hi,
der Effekt ist fein, aber
Die Effizienz deines AA Algorithmus ist... unkonventionell
ist noch *hust* stark untertrieben, da das Ganze absolut NICHTS mit Antialiasing zu tun hat 
Bevor man etwas ANTI-aliased muss es vorher erstmal aliased sein 
absolut NICHTS mit Antialiasing zu tun hat
*MÖÖÖÖÖP*
Und das ist absolut falsch :D. Der Zweck des Effektes ist es, glatte Übergänge zu haben, lässt du alles so wie vorgegeben und stellst mal die Rotation höher siehst du ganz genau das Aliasing. Die Erhöhung des AA, also der simplen Interpolation zwischen den Punkten glättet das sofort raus, so dass wieder weiche Übergänge entsehen. Ergo: AntiAliasing
Das das AA irgendwann umbricht und völlig falsche Ergebnisse produziert sieht man ja in Post #2, aber entsteht noch ein schönerer Effekt. Bug -> Feature
Der Zweck des Effektes ist es, glatte Übergänge zu haben,
DAS ist richtig!
Das aber mit Anti-Aliasing gleichzusetzen, DAS ist falsch.
Du lässt das Aliasing garnicht erst zu (wenn du die "Auflösung" verfeinerst), ergo kannst du auch garkein ANTI Aliasing darauf anwenden!
Anti-Aliasing ist ein Verfahren, dass ein bereits bestehendes Bild im NACHHINEIN so bearbeitet, dass es diese "glatten Übergänge" bekommt!
Wenn das Bild schon im Vorfeld keine (sichtbaren) Treppenstufen hat, dann bewirkt ein AA-Algorithmus bestenfalls nichts...außer Performance zu fressen...
Nein! 
Man braucht sich doch nur Wu's Linienalgorithmus oder sonstige AA Verfahren auszusehen, die alle Realtime arbeiten. Es gibt PostFX Algorithmen, das ist wahr, aber genauso gibt es auch solche, die kein anderes Bild zulassen! Versuch mal mit Wu's eine ähnlich aliaste Linie wie mit Bresenham zu zeichnen.
Es ist und bliebt AA 
. Hier nochmal ganz deutlich:
Vorher
[Blockierte Grafik: http://t41.img-up.net/aauas0444.png]
Nachher:
[Blockierte Grafik: http://x77.img-up.net/aaan8641.png]
Fazit: Kantenglättung aka. AntiAliasing muss nicht Post-Mortum des Bildes der Berechnung erfolgen
__________________________
Gehen wir mal von keinem AA aus, dann wird das Bild mit 10^2 Iterationen einfach gezeichnet. Man könnte den Code jetzt auch aufteilen auf normale Erstberechnung und folgende Nachberechnung durch die Iterationen die durch den AA noch dazustoßen:
While 1
1. Erstberechnung
2. Wenn AA > 1 dann Nachberechnung der zwischenliegenden Pixel
WEnd
Du behauptest also, wenn man 2 voneinander unabhängige Bilder zeichnet (Vorher und Nachher) dann dürfte man das Verfahren, in dem man das zweite Bild gezeichnet hat , Anti-Aliasing nennen, nur weil es weniger "Treppenstufen" hat?
Man braucht sich doch nur Wu's Linienalgorithmus oder sonstige AA Verfahren auszusehen, die alle Realtime arbeiten.
Naja, ich glaube da wirfst du einiges durcheinander.
Die Algorithmen versuchen den "Treppeneffekt" im Vorfeld zu vermeiden. Wenn ich eine mit welchem Algorithmus auch immer gezeichnete Linie so erstelle, dass sie auf einem Ausgabemedium garnicht Aligned Aliased ist, dann ist das Ziel erreicht.
Versuch mal mit Wu's eine ähnlich aliaste Linie wie mit Bresenham zu zeichnen.
Das ist nicht das Thema, das Thema ist, dass du keinerlei veränderten Linienalgorithmus verwendest und somit auch nicht die Linie auf dem Bildschirm an sich! s.Script, da kannst du die Parameter ändern wie du willst, die Linie an sich bleibt IMMER gleich (Aligned Aliased^^)!
Opt("GUIOnEventMode", 1)
[/autoit] [autoit][/autoit] [autoit]; Hier rumspielen! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
[/autoit] [autoit][/autoit] [autoit]Local $ForeRed = 0, $ForeGreen = 0, $ForeBlue = 0 ; Farbe für den Vordergrund (das Äußere)
Local $BackRed = 255, $BackGreen = 0, $BackBlue = 0 ; Hintergrund (das Innere)
Local $AntiAliasing = 0.4 ; AA höher als 1x sollte nur bei RotRange > 100 nötig sein!
Local $RotRange = 100 ; Wie stark soll es rotieren
; Rumspielen beenden! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]$hGUI = GUICreate("PolyPlay | FPS: 0",500,500,-1,-1,Default,34078728)
GUISetBkColor(0)
Global $hGraphics = GUICtrlCreateGraphic(0,0)
GUISetOnEvent(-3, "done")
GUISetState()
AdlibRegister("FPS", 1000)
[/autoit] [autoit][/autoit] [autoit]Local $r = -$RotRange, $modificator = 1, $iFPS = 0
While 1
$r += $modificator
If $r > $RotRange Or $r < -$RotRange Then $modificator *= -1
Draw($ForeRed, $ForeGreen, $ForeBlue, $BackRed, $BackGreen, $BackBlue, $r, 100 * $AntiAliasing)
$iFPS += 1
WEnd
Func Draw($FRed, $FGreen, $FBlue, $BRed, $BGreen, $BBlue, $Rotate, $Step)
$old = $hGraphics
$hGraphics = GUICtrlCreateGraphic(0,0)
Local $ROffSet=($BRed-$FRed)/$Step,$GOffset=($BGreen-$FGreen)/$Step,$BOffset=($BBlue-$FBlue)/$Step,$XOffset=250/$Step,$YOffset=250/$Step
Local $RotateOffset = $Rotate / $Step
Dim $T
For $T = 0 To $Step
$Color = RGB($FRed+($T*$ROffSet),$FGreen+($T*$GOffset),$FBlue+($T*$BOffset))
GUICtrlSetGraphic($hGraphics,8,$Color,$Color)
;~ GUICtrlSetGraphic($hGraphics,6,250+X(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
;~ GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
; GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
GUICtrlSetGraphic($hGraphics,2,250+X(-(250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
Next
GUICtrlSetGraphic($hGraphics, 22)
GUICtrlDelete($old)
EndFunc
Func RGB($r, $g, $b)
Return "0x" & Hex(Int($r), 2) & Hex(Int($g), 2) & Hex(Int($b), 2)
EndFunc
Func X($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RX * Cos($TZAn) - $RY * Sin($TZAn)
EndFunc
Func Y($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RY * Cos($TZAn) + $RX * Sin($TZAn)
EndFunc
Func FPS()
WinSetTitle("", "", "PolyPlay | FPS: " & $iFPS)
$iFPS = 0
EndFunc
Func done()
Exit
EndFunc
Du verwendest jedes Mal den gleichen Linien-Algorithmus, aber zeichnest immer nur ein komplett anderes Bild, in dem sich diese Linien eben so überlagern, dass es einmal "Treppenstufen" anzeigt, und im anderen Bild (aufgrund eines veränderten Parameters) eben nicht...
Das ist so, als ob ich sagen würde, DaVinci´s "Mona Lisa" sei die Anti-Aligned-Version von einem kubistisch gemalten Gesicht....die Beiden haben AlignedAliasing-Technisch genausoviel gemeinsam wie deine "Vorher/Nachher"-Bilder.
autoit.de/wcf/attachment/21022/autoit.de/wcf/attachment/21017/
//EDIT// aliasing <> aligning...Recht hat er^^
Soviel hättest du nicht schreiben müssen. Schau dir einfach mal noch einmal die zwei Bilder oben an. Es IST exakt das gleiche Bild. Du sagst (richtigerweise), dass einfach bloß mehr Rechtecke gezeichnet werden, und das IST auch richtig. Genau DESWEGEN ist es ja Kantenglättung! Es werden MEHR Zwischenpunkte berechnet (und dargestellt) um ein glatteres Ergebnis zu erhalten.
Und ich würfle da nichts durcheinander. Man muss sich nur überlegen, was genau der Unterschied zwischen einer normalen Linie und einer geglätteten Linie ausmacht. Genau! MEHR Pixel. Um die Linienpunkte werden einfach MEHR Pixel in NACHBERECHNETER Sättigung gezeichnet. Und exakt und zwar wortwörtlich das gleiche passiert hier! . Zwar werden nicht die einzelnen Linien geglättet, aber das letztendliche Bild durch eine Mehrberechnung. Das ist es, was AntiAliasing ausmacht. Da kannst du sagen was du willst .
Übrigens weiß ich nicht, warum du von "Aligned" redest, das heißt nämlich "angeordnet".
So und jetzt Frieden und Ruhe.
ok, Aliasing hätte man auch kürzer erklären können, s Script. Habe mal die Rotation weggelassen um DEIN Verständnis von Anti-Aliasing darzustellen.
Dazu einfach nur den Parameter
Local $AntiAliasing = 1
[/autoit]auf bspw. 2 setzen und tadaaaaa das Bild vorher wird Anti-Aliased...
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
Opt("GUIOnEventMode", 1)
[/autoit] [autoit][/autoit] [autoit]; Hier rumspielen! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
[/autoit] [autoit][/autoit] [autoit]Local $ForeRed = 0, $ForeGreen = 0, $ForeBlue = 0 ; Farbe für den Vordergrund (das Äußere)
Local $BackRed = 255, $BackGreen = 0, $BackBlue = 0 ; Hintergrund (das Innere)
Local $AntiAliasing = 1 ; AA höher als 1x sollte nur bei RotRange > 100 nötig sein!
Local $RotRange = 100 ; Wie stark soll es rotieren
; Rumspielen beenden! = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]$hGUI = GUICreate("PolyPlay | FPS: 0",500,500,-1,-1,Default,34078728)
GUISetBkColor(0)
Global $hGraphics = GUICtrlCreateGraphic(0,0)
GUISetOnEvent(-3, "done")
GUISetState()
AdlibRegister("FPS", 1000)
[/autoit] [autoit][/autoit] [autoit]Local $r = -$RotRange, $modificator = 1, $iFPS = 0
While 1
$r += $modificator
If $r > $RotRange Or $r < -$RotRange Then $modificator *= -1
Draw($ForeRed, $ForeGreen, $ForeBlue, $BackRed, $BackGreen, $BackBlue, $r, 100 * $AntiAliasing)
$iFPS += 1
WEnd
Func Draw($FRed, $FGreen, $FBlue, $BRed, $BGreen, $BBlue, $Rotate, $Step)
$old = $hGraphics
$hGraphics = GUICtrlCreateGraphic(0,0)
Local $ROffSet=($BRed-$FRed)/$Step,$GOffset=($BGreen-$FGreen)/$Step,$BOffset=($BBlue-$FBlue)/$Step,$XOffset=250/$Step,$YOffset=250/$Step
Local $RotateOffset = $Rotate / $Step
Dim $T
For $T = 0 To $Step
$Color = RGB($FRed+($T*$ROffSet),$FGreen+($T*$GOffset),$FBlue+($T*$BOffset))
GUICtrlSetGraphic($hGraphics,8,$Color,$Color)
;~ GUICtrlSetGraphic($hGraphics,6,250+X(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y(-(250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
;~ GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)),-(250-($T*$YOffset)),$RotateOffset*$T))
; GUICtrlSetGraphic($hGraphics,2,250+X( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T),250+Y( (250-($T*$XOffset)), (250-($T*$YOffset)),$RotateOffset*$T))
GUICtrlSetGraphic($hGraphics,($step>100)*2+10,50, 50,400,400,$RotateOffset*$T)
Next
GUICtrlSetGraphic($hGraphics, 22)
GUICtrlDelete($old)
EndFunc
Func RGB($r, $g, $b)
Return "0x" & Hex(Int($r), 2) & Hex(Int($g), 2) & Hex(Int($b), 2)
EndFunc
Func X($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RX * Cos($TZAn) - $RY * Sin($TZAn)
EndFunc
Func Y($RX, $RY, $ZAn)
$TZAn = $ZAn * (3.141592654 / 180)
Return $RY * Cos($TZAn) + $RX * Sin($TZAn)
EndFunc
Func FPS()
WinSetTitle("", "", "PolyPlay | FPS: " & $iFPS)
$iFPS = 0
EndFunc
Func done()
Exit
EndFunc
Bitte, da siehst du es. Denn ein Kreis ist nur ein Vieleck. Die Aliaseste (wasn Wort) Form eines Kreises ist: Ein Dreieck (hier ein Viereck). Prinzip der Kantenglättung
Na also, geht doch
