Hallo,

ich arbeite nun schon seit ein paar Tagen an einem Tutorial über Color Picking. Nun ist es endlich
soweit fertig und wird von mir hier als Vorab-Version eingestellt um von der Community zerfleischt
zu werden.

Normalerweise würde ich es ja direkt ins Wiki stecken, aber da die Verantwortlichen momentan
ihren Urlaub genießen wollen, was ich ihnen auch gönne, muss es halt mal so gehen.

Edit: Es wäre auch gut, wenn ihr mir sagen könnt, wie ihr den Schwierigkeitsgrad (in DGL-Sternen)
empfindet.

Edit:
Stets aktuelle Version ist nun im Wiki

Das erste was mir aufgefallen ist nach dem Programmstart ist:

"Das Programm kann nicht ausgeführt werden weil SDL.dll nicht gefunden werden konnte."

Die OpenGL.dll ist ja standardmässig auf Miniweich Fenster äääh- Microsoft Windows vorhanden.

Eine Requirements-Liste wäre evtl. ganz gut?

_________________
Gruß Andreas (aka DeepCopy) - Sic Luceat Lux

Classified Directive: initialization write in function for finalization, repeat until public case uses begin, if not case type as default, var in virtual override for while, in case of class type type asm until read begin.

Hier ist die Requirement-Liste:

- Aktueller Grafiktreiber (gibts auf der Seite des Hardwareherstellers)

- *entfernt* SDL braucht man nicht mehr. Ist enthalten.

- Hardware: Eine Grafikkarte mit Shadersupport


Aber im Prinzip steht das Beispielprogramm ja gar nicht im Mittelpunkt, sondern
das Tutorial

Das Programm kann ich aus selben Grund nicht starten. Mit dem SDL ist halt sone Sache. Hier im Forum sind die Hauptverantwortlichen natürlich Linux User und möchten gerne alles auf ihren Standart ummünzen, so dass jetzt jeder Tutorial-nutzer der Seite gezwungen ist plattformunabhängig zu programmieren, was ich eigentlich schade finde, weil der Hauptfeind "Microsoft" ja gerade wegen des "zu etwas zwingen" (und weil se schlampig sind und.. ) so scharf kritisiert wird. Ich selbst arbeite ja nun auch gerade an einem Tutorial und muss mir deswegen die komplette SDL Keule geben, nur damit ich dem DGL-Standart gerecht werde, obwohl es auch ohne funktionieren würde.

Die Umgangssprachlichen "Witze" ala wtf und ^_^ fand ich nervend (bis auf das Ding mit der Zeitmaschine). Ist halt nicht jeder ein 12-jähriges scriptkiddy das seit Geburt an Spladdershooter in irgendwelchen Profi-Ligen zockt. Das soll jetzt keine Beleidigung sein, aber wenn ich einen Text lese der mir etwas vermitteln soll und dann solche Zeichen-Frakturen lesen muss, hab ich schnell das Gefühl, dass ich mir gerade etwas erklären lasse von jemanden, der abseits aller Realität existiert ,noch völlig in der Pubertät steckt und großkotzig die Sau raußlassen will.

Vom Inhalt her und dem Umfang finde ich es absolut genial. Sauber erklärt und detaliert geschildert. Das ist echt ne gute Leistung soweit. Wie gesagt würde ich an einigen Stellen noch die Wortwahl überarbeiten und nicht unbedingt auf den "nu sind wir mal alle krampfhaft/krankhaft lustig" Zug aufspringen.

_________________
Klar Soweit?

Also erst mal danke, dass du dir die Mühe gemacht. Vom Umfang her siehts ja schon echt gut aus. Allerdings habe ich noch Anmerkungen dazu. Das ist nur meine Meinung. Und die trifft definitv nicht den Geschmack der Masse. Bzw ist an manchen Stellen vielleicht etwas eigen. Entsprechend solltest du das nicht sofort für bare Münze nehmen sondern erst mal abwarten was andere dazu sagen.

Codeauslagerung mit Includes geht in meinen Augen absolut nicht! Das ist zwar damit möglich aber nur weils möglich ist muss man das nicht machen.

Jetzt zu deinem Tutorial.
1)
- Den Anfang finde ich etwas unpassend. Direkt das Erste was du sagst ist gefluche? Sonst hast du allerdings recht, dass das Picking mittlerweile einfach nicht mehr praktikabel ist. Auch wenn ich das vermutlich etwas anders ausdrücken würde.
- Gut finde ich die Auflistung von Vor und Nachteilen. Wobei die Vorteile auf mich etwas arg weichgespült wirken.

2)
Kurz. Klar. Abstrakt aber sehr verständlich.

3)
- Das die Shader eigentlich nur dazu dienen um die Objekte in eine entsprechende Farbe zu hüllen erwähnst du irgendwie gar nicht? Oder habe ich das nur überlesen?
- Auch finde ich den Aufbau etwas unpraktisch. Zu erst kommt die Version mit Shadern, Unterscheidung Little-/Big Endian etc etc etc und danach dann die Version bei der man nur darauf achten muss die richtigen Farben zu setzen. Ich behaupte jetzt mal ein Großteil benutzt gar keine oder eher selten Shader. Und für die wäre das normale wohl auch vollkommen ausreichend.
Bzw könnte man die erklärte Technik an einem Beispiel zeigen und in einem Späteren Abschnitt mit Shadern das Handling vereinfachen. Dadurch bekommt man nicht gleich die Keule sondern kann aufbauen.
- Auch Frage ich mich ob die Unterscheidung Little/Big Endian wirklich notwendig ist. Denn ich muss ehrlich gestehen, dass ich das bisher konsequent ignoriert habe. Eventuell müsste man das auch gar nicht überall schon berücksichtigen sondern könnte das Handling in einen Abschnitt auslagern. Wie gesagt. Was das angeht lasse ich mich auch gerne eines besseren belehren, weil ich dem bisher nie sonderlich viel Beachtung geschenkt habe.
- Ich bin mir unschlüssig ob die Variable IV (mit absolute) so eine gute Idee ist. Ein Tutorial hat nachahm Charakter (dafür isses ja da). Und absolut ist so eine Sache.
- Sehr gut finde ich, dass du auf Antialiasing eingehst und wie man das mit sehr einfachen Mitteln umgehen kann. In der Heutigen Zeit ist das schon sehr wichtig, dass man so etwas berücksichtig.
- 32Bit: Würde es eventuell etwas drastischer schreiben, dass man wirklich sicher gehen MUSS, dass man auch wirklich 32 Bit (inklusive Alpha) hat. Wie sieht das eigentlich mit 16 Bit aus? Sind die Daten dann überhaupt noch korrekt? (wobei wenn man wirklich 32 Bit braucht (mehr als 16 Mio) dann hat man irgendwas anderes falsch gemacht).

4)
- Als Belohnung finde ich diesen Abschnitt schlicht zu wirr. Wie oben schon geschrieben würde ich die Shaderlose Variante eher vorher sehen. In dem Abschnitt kann man auch gut sehen, dass du ein Shaderfan bist. Das ist nicht böse gemeint. Aber mir fällt das am Schreibstil voll auf.
- In einem Spiel wird normal alles über Texturen eingefärbt. Also Farben in DisplayListen sind dort nicht nötig. Außerdem kann man in deinem Fall die Farben auch locker außerhalb setzen. Und ja. Das wäre genau so Imediate Mode wie die Farben außerhalb eines VBOs setzen. Bei DisplayListen wäre das nichts anderes nur, dass es Treiber macht. Also da mal nicht verleiten lassen irgendwelche Dinge per se zu verteufeln.
- Der kleine Exkurs in VBOs ist eigentlich nicht nötig. Zu mal ich den ziemlich wirr finde.

5)
Nur so am Rande: Im Forum nicht per PN allerdings via IRC? Weil so können alle profitieren. Fällt dir da was auf?

Erstmal danke für eure Kritik

Ich wollte nur noch schnell anmerken, dass ich eine neue Version hochgeladen habe. Die hat
allerdings bis jetzt nur minimale Änderungen (mir ist aufgefallen, das im Tutorial von nur 2 eigenen
Units die Rede ist - es sind aber 3). Jedenfalls hat die 3te Unit (utils.pas) auch im Ordner des
Download-Paketes gefehlt. Außerdem habe ich jetzt mal die SDL.dll mitgeliefert. Offensichtlich scheint
es nicht so weit verbreitet zu sein, wie ich dachte.

Ich werde auf den Rest später noch eingehen, aber jetzt wollte ich erstmal vor die Tür und
das hübsche HDR-Rendering genießen

-----------------------------------------------
Edit:
Ich denke am schnellsten abgehandelt ist er Kritikpunkt mit der Sprache: Wenn es euch nicht gefällt,
wird es geändert. Punkt.

Was definitiv nicht geändert ist:
1) Die Behandlung von Big Endian vs. Little Endian
2) Die starke Shaderzentriertheit des Tutorials

ad 1: Ein wesentliches Merkmal, das OpenGL mitunter überhaupt am Leben hält, ist die Plattformunabhängigkeit.
Die meisten Homecomputer benutzen zwar Little Endian, aber auf professionellen Umgebungen und Spielekonsolen
(beides Bereiche in denen oft OpenGL benutzt wird) spielen Big Endian Systeme eher die dominierende Rolle.
Deswegen halte ich es für wichtig beide Fälle zu behandeln.

ad2: Spätestens ab OpenGL3 fallen die meisten Fixed-Function-Teile der Pipeline weg. Viel wichtiger ist aber,
dass die Funktionen in OpenGL3 nicht umsonst deprecated sind: Sie passen einfach nicht in das Konzept
moderner Hardware und arbeiten teils sehr stark gegen den Grafiktreiber und sollten deshalb einfach nicht
mehr benutzt werden.


Schließlich noch ein paar Sachen, die sicher diskutierbar sind. Ich sage einfach mal, was ich mir
dabei gedacht habe.

Codeauslagerung mit Includes:
Ich erwarte, dass wenn sich jemand den Code anguckt, sich im wesentlichen für die Eventschleife und
das Setup interessiert. Ausgelagert wurde nur die Erzeugung der Displaylisten, weil es viel Platz einnimmt
und dabei sogut wie keinen Informationsgehalt hat (was man höchstens lernen könnte ist, wie man einen
Stern zeichnet...).
Schlecht finde ich persönlich daran eigentlich nur, dass in "Setup" 2 Variablen deklariert und erst in
einer ganz anderen Datei - dem Include - verwendet werden. Das liest sich sicherlich sehr komisch.

Weichgespülte Vorteile:
Mhm. Ich hoffte ich hätte meinen Lesern mit dem Abschnitt Flexibilität schon ein Leuchten in die Augen
gezaubert. Was würdest du denn gerne noch erwähnt wissen, Lossy?

Aufbau (erst Shader, dann ohne):
Wie gesagt, das Tutorial ist einfach um Shader herum aufgebaut. Der Abschnitt 4 sollte lediglich ein
kleines Brainstorming sein, damit einerseits dargestellt wird, dass es theoretisch auch anders geht und
andererseits gezeigt wird, wie flexibel das Verfahren ist.
Es handelt sich also wirklich nur um einen kleinen Bonus, nicht um einen vollwertigen Ersatz des
Shaderteils. Vielleicht sollte ich das sprachlich deutlicher machen (oder aber den Teil ohne Shader
sehr stark präzisieren. Allerdings könnte dadurch der Eindruck enstehen, es wäre genau so gut;
was ich nicht will).

Zum Thema 16 Bit:
Habe es bewusst nicht behandelt, da 16 Bit relativ kompliziert ist. Es gibt unterschiedliche Bitlängen
für die einzelnen Farbkomponenten (5 Rot, 6 Grün, 5 Blau) - das macht das Zerlegen und wieder
Zusammensetzen des Index recht aufwändig. Wollte ich niemandem zumuten.

Absolute:
Was gefällt nicht an absolute, Lossy? Shiften will ich nicht unbedingt, weil es verschwendete Rechenzeit
wäre; Zugriff auf einzelne Bytes gibt es kostenlos. Pascals union records haben eine scheußliche Syntax
und fallen damit auch weg. Was bleibt wäre ein Cast auf ein ByteArray... und ob das wirklich der
Absolute-Methode vorzuziehen ist wage ich zu bezweifeln.

Zum Thema Immediate Mode:
Ob ich im Falle eines VBO/VA den Color-Pointer ändere oder ob ich während der Renderschleife
glColor aufrufe ist ein gewaltiger Unterschied. glColor ist deprecated, weil man damit dem Treiber
"häppchenweise" Daten gibt. Das ist es, was Immediate Mode bedeutet und so ziemlich das
grausamste, was man seinem Grafiktreiber antun kann.
Bei diesem Vorgehen geht jede Stream-Optimierung wie man sie bei Bulk-Daten hat verloren - und
ich will nicht, dass sich insbesondere Einsteiger an so einen Weg gewöhnen.

Zum Thema 5:
Ok, FAIL meinerseits

----------
Ich hoffe ihr bekommt jetzt nicht den Eindruck, dass ich einfach nur eure Kritik auf Teufel komm raus
wiederlegen will. Im Gegenteil ist mir eure Kritik sehr wichtig! Ich wollte eben nur gesagt haben, welche
Gedankengänge mich zu meinen Taten haben hinreißen lassen um eine gute Diskussionsbasis zu erzeugen.

Tolles Tutorial!

Lob:
1) Übersichtlich,
2) Verständlich, (hab fast alles verstanden... ohne je geshadert zu haben, toll!)
3) Die Zeichen ^_^ stören mich überhaupt nicht, vielmehr stellen sie den Charakter des Scheibenden dar.
4) Der Hinweis auf BigEndian und LittleEndian, hmm... wer sich OpenGL, Shader, Objekt-Selektion antut (IMHO) weiss eigentlich schon etwas über die Speicherreihenfolge von Bits !?. Na jedenfalls falsch finde ich es nicht.

Kritik:
1) Der erste Satz eines Tutorials sollte nicht mit WTF = What The Fuck beginnen. Besser wäre Oh, nein! oder sowas.
2) Bei dem ersten Codessegment (der für Shader) stand ich richtig im Wald. Erst habe ich gedacht es wäre C-Code aber der Bezeichner uniform kam mir Spanisch vor, ein Bick in die Shader-Datei sel_vs.glsl schaffte dann aber Klarheit, besser wäre hier ein Hinweis wo der Code herkommt (Datei) und das es sich um die Schader-Language handelt.
3) Der Bonusabschnitt "4. Alte Hardware (Anregung)" würde sich besser am Anfang machen, als Aufbau, a la so haben wir es bisher gemacht und dann wie macht man das mit Shadern.

Das mit dem Schlüsselwort absolute finde ich ehrlich gesagt übehaupt nicht schlimm, was soll schwierig zu daran zu verstehen sein, das zwei Variablen auf den "Selben Speicherbereich" zeigen, und sich lediglich in ihrer Typedefinition voneinander unterscheiden (siehe variant records, oder c/c++ union). Also das gehört (IMHO) zur Grundausstattung eines (Pascal-)Programmierers. Und so gesehen ist das ja auch kein Einsteiger-Tutorial zur Pascalprogrammierung, sorry wenn ich jetzt wirke.

Also ich werde mir das in jedem Fall einmal RICHTIG antun!
Dickes THX für deine Arbeit!

_________________
Gruß Andreas (aka DeepCopy) - Sic Luceat Lux

Classified Directive: initialization write in function for finalization, repeat until public case uses begin, if not case type as default, var in virtual override for while, in case of class type type asm until read begin.

Das sehe ich nicht anders. Wenn Vorschläge zu irgendwelchen Units kommen, dann bin ich da auch sehr genau. Ich springe auch nicht jedem Vorschlag direkt hinterher.

Weichgespülte Vorteile:
Ich vermisse da nichts. Sondern ich finde, dass die beiden letzten Punkte fast das Gleiche wiederspiegeln nur eben anders beschrieben. Also wäre es Werbung hättest du schon gewonnen.

Shader:
Shader sind doch überwiegend nur dazu da um dafür zu sorgen, dass alle gesetzten Einstellungen ignoriert werden und nur die Farbe durchkommt, oder? Entsprechend sind Shader nur eine Erweiterung des klassischen Teils. Außerdem soll es ein Tutorial werden und das ist damit kein Teil der so gemacht werden kann. Sondern es wird so gemacht. Das habe ich schon oft genug gesehen. Vielleicht nicht von jedem aber von einigen. Es spielt auch keine Rolle ob du sagst, dass es nur ein Vorschlag ist. Das ist zu mindest meine Befürchtung.

16 Bit:
Also ganz erklären würde ich das nicht wollen. Ich meinte nur mal testen was dabei raus kommt. Kann nämlich sein, dass der Treiber intern trotzdem mit 32Bit arbeitet. Und nur für die Darstellung auf 16 Bit reduziert. Sollte es bei 16 Bit Probleme durch die Farbtiefe geben, dann würde ein Hinweis reichen, dass für ColorPicking 32 Bit Farbtiefe mehr oder weniger vorgeschrieben sind.

Absolute:
Absolute sorgt dafür, dass die Variable den selben Anfang hat wie die angegebene Variable. Alles andere ist egal. Du kannst also bei unsachgemäßer Handhabung recht schnell den Stack oder andere Variablen zerschießen. Wenn I ein Schleifenzähler wird schreiben zwar vom Kompiler geblockt aber na ja.

[edit]Ich finde da im übrigen nichts schwer oder unverständlich dran. Bin aber sehr auf Sicherheit erpicht. Selbst bei Pointern und absolute fällt da ein bisschen raus.[/edit]

Includes:
Includes sind meiner Meinung nicht für so etwas gemacht. So Tutorial und Vorbild hatte ich oben. Der Code ist durch SDL sowieso schon nicht übersichtlich. Da machst das dann auch nichts mehr. Eine Methode reicht meiner Meinung vollkommen. So etwas soll sich niemand angewöhnen. Codevervollständigung / Debuggen etc. funktioniert darin nicht vernünftig.

Ich habe das Tutorial mit euren Vorschlägen im Hinterkopf überarbeitet.
Hoffentlich ist es stellenweise *noch* verständlicher und präziser geworden.

Download hier: Link entfernt

Die Sprache wurde im großen und ganzen angepasst, aber ein paar Smileys
und Kommentare lasse ich mir nicht nehmen

So, ich habe es mir als Aufwachlektüre auch mal zu Gemüte geführt und bis auf einen kleinen Rechtschreibfehler ("mit-zeitreisdenden") fällt mir nichts negativ auf. Jedes Tutorial spiegelt halt den Verfasser wieder. Gut finde ich Kapitel 4, wo erklärt wird, wie es auch OHNE Shader geht. Das Kapitel hat mich erstaunlicherweise besonders interessiert. ^^

LG Ziz

_________________
Denn wer nur schweigt, weil er Konflikte scheut, der macht Sachen, die er hinterher bereut.
Und das ist verkehrt, denn es ist nicht so schwer, jeden Tag zu tun als ob's der letzte wär’.
Und du schaust mich an und fragst ob ich das kann.
Und ich denk, ich werd' mich ändern irgendwann.
_________________Farin Urlaub - Bewegungslos

Ich wäre nicht ich, wenn ich einfach so zu frieden wäre. Aber ist ja schließlich auch nur meine Meinung.

Vorteile:
Sorry aber den Absatz über Speichereffizienz versteh ich mal überhaupt nicht. Auch verstehe ich nicht was da der Vorteil zum NameStack sein soll. Weil die Daten von den Objekten brauchst du so oder so. Abgesehen davon fand ich die 3 ursprünglichen Abschnitte weichgespült und jetzt sinds 4.

16 Bit:
Finde ich so etwas wirr. Vor allem klingt es, als ob man das selbst beeinflussen könnte. Wenn man im Fenster arbeitet wird das aber von Windows diktiert. Und das was ich meinte war, dass man lediglich darauf hinweis, dass es unter 16 Bit Desktopfarbtiefe zu Problemen kommen kann, da der Framebuffer unter Umständen die Farbtiefe des Desktops annimmt. Und dadurch wären die Farben schlechter aufgelöst.

Alte Hardware (Anregung):
Okay. Das ist definitiv anders und nicht mehr so Bruchstückhaft wirr wie vorher. Allerdings hat so ein Abschnitt mal überhaupt nichts in einem Picking Tutorial zu suchen. Das wäre eher etwas für einen speraten Artikel zum treiberfreundlichen Entwickeln. Außerdem stößt mir dort negativ auf, dass du einige Sachen verteufelst und andere wiederrum auf ein Podest stellst. Was sie aber meiner Meinung nach nicht verdient haben. Denn DisplayListen sind in 3.0 genau so deprecated. Und nur weil du DisplayListen benutzt heißt es nicht, dass der Treiber alles weiß. Du kannst in der Liste ja auch wärend dem Zeichnen mehrfach die Farben wechseln. Und was macht der Treiber dann? Erzeugt er ein VBO was Farbwerte enthält (massiv speicher verbrauch)? Oder stückelt er es intern irgendwie. Abgesehen davon gibt es in 3.0 meines Wissens nach gar keine glColor mehr. Sondern das wird alles über VertexAttribute + Shader gelöst.

Ich bin trotzdem der Meinung, dass dieser eine Lösungsvorschlag für viele als bindend angesehen wird und sie dann Shader benutzen obwohl sie es eben gar nicht bräuchten. Aber ist eben nur meine Meinung.

Außerdem bin ich halt wie vorher schon mal gesagt nicht überzeugt ob man auf die Byte Order so detailiert eingehen sollte.

Da ich aber nicht nur meckern kann. Abgesehen von meinen Kritikpunkten finde ich das schon eine sehr solide arbeit. Besonders auch, dass du AA sinnvoll berücksichtigst.

Ich denke mal ich kann mir bei dem aktuellen Stand größere rewrites sparen, deswegen Quote ich nur
veränderte Abschnitte (müsst ihr auch nicht mehr alles neu lesen):



Deutlich geworden?
Solange du die Sache mit dem "Weichgespült" nicht näher ausführst, kann ich daran nichts ändern.
Das sind nunmal die Vorteile, wie sie sind


Der Abschnitt "Ergänzung: 32 Bit Farbtiefe" heißt jetzt "3.5 Ergänzung: 32/16 Bit Farbtiefe" und
hat folgenden zusätzlichen Absatz:




Zum umstrittenen Thema 4:
Genau. Displaylisten werden intern vom Treiber in VBOs umgewandelt (mit massivem Speicherverbrauch).
Von daher ist es ein Unterschied, ob ich glColor in oder außerhalb einer Displayliste aufrufe.

Displaylisten sind in GL3 nicht mehr vorhanden, da sie ihren Sinn eingebüßt haben (die Einfachheit von
Immediate Mode zur Performance eines statischen VBOs). Wenn Befehle wie glColor, glVertex etc. wegfallen,
so könnte man in Displaylisten nur noch glDrawArrays mit einem gebundenem VBO aufrufen - ein bisschen
sinnlos, oder?

Wie gesagt wollte ich in Thema 4 Anreize geben, wie man das Ganze ohne Shader handhabt. Dazu gehört
meiner Meinung nach auch, wie man es "richtig" macht. Ich verteufele Immediate Mode nicht, die
Hardwarehersteller und die Khronos-Group tun das - und was diese beiden Instanzen tun ist nunmal Gesetz.
Was bringt die ganze Optimierung auf minimalen Speicherverbrauch (wie ich es in 4 in dem "tut nicht" Abschnitt
beschrieben habe), wenn man dafür Geschwindigkeitseinbußen erhält?

Ich glaube du hast es auch nicht richtig gelesen. Jedenfalls beschwerst du dich, dass es in GL3 kein glColor mehr
gibt - dabei kommt die Array-Methode ganz ohne aus (glColorPointer ist etwas ganz anderes).


Zum Thema Byte Order gibt es, wie gesagt, keine Diskussion. Es bleibt drin.

Ansonsten nochmal vielen Dank an alle (besonders Lossy eX), dass ihr euch so viel Zeit nehmt, das Tutorial
mit mir auf Perfektion zu trimmen.

Edit: Ok, es gab noch einen gravierenden Fehler im Selektionscode: "if y > 0 then dec(y);", muss es natürlich
heißen. Nicht dec(x)...

Edit #2:
Ich habe jetzt doch mal das aktuelle Paket hochgeladen, nachdem ich versucht habe, den Code etwas Delphifreundlicher
zu machen. Im wesentlichen habe ich die Defines angepasst, DWord durch LongWord ersetzt und den Kram mit
dem "exit(wert)" geändert.
Es wäre nett, wenn jemand der Delphi hat mal schauen könnte, ob der Code kompiliert und läuft.
Außerdem hat sich noch keiner über den Schwierigkeitsgrad ausgelassen. Ich tendiere zwischen * * und * * *.

Speichereffizienz:
Ah. Okay. Ja jetzt ist mir das klarer. Also, dass du da ein Vergleich zu geometriebasiertem Picking machst. Wobei ich persönlich die Shadererwähnung in den Vorteilen ein bisschen für Augenwischerei halte. Denn ohne Shader hast du die gleichen Vorteile. Shader wiederrum bieten noch mal zusätzliche Vorteile.

Weichgespult:
Um ein Beispiel zu nennen.

Sollte das nicht Bestandteil von Picking sein? Das klingt nach unnatürlich glattem (übertrieben schleimigem) PR Deutsch. Sorry aber du wolltest es direkt.

GL3: ColorPointer ist genau so deprecated wie glColor. Was mich daran nur stört ist, dass ein als Schlecht ausgegeben wird und etwas was eigentlich genau so falsch als gut ausgeschrieben wird. Und wenn du komplett GL3 konform sein wolltest wäre es ein bisschen arg viel. Aber ist wie gesagt nur meine Meinung. Und ich fänds anders aufgezogen besser. Großteil des Teams ist derzeit sowieso auch nicht da. Und die sollten sich das vielleicht auch noch anschauen.

Das versteht sich von selbst. Der Grund dafür, dass ich das Tut im Forum hab ist, dass ihr euren Senf dazugeben könnt.
Und das macht ihr ja auch fleißig ^_^

Mhhm... also Shader bieten eben den Vorteil, dass man sich nicht weiter darum scheren muss, wie die Geometrie
aufgebaut ist (und eben die Sache mit dem Speicher). Das müsste man bei VBOs/VAs in der shaderlosen Variante
schon tun (Displaylisten verbieten sich, da man dann glColor in der Renderschleife aufrufen müsste - s.u.).

Gut, das glColorPointer auch deprecated ist, wusste ich nicht. Es ändert aber im Prinzip kaum etwas an der
grundlegenden Aussage: In GL3 würde man dann eben respective ein alternatives Vertexattribut anbieten...
wobei sich die Problematik in GL3 gar nicht stellt, da man da Shader verwenden muss.

Was ich eben eigentlich in Kapitel 4 sagen will ist, dass die Änderungen in GL3 nicht grundlos geschehen sind - und daher
sollte man auch in GL <3 möglichst darauf achten, nur große zusammenhängende Datenhaufen an die Grafikkarte zu senden.
Dabei sind solche Aktionen wie ein "glColor" in der Renderschleife eben zu vermeiden.
Ich muss mir noch überlegen, wie ich das verständlicher formulieren kann. Offensichtlich wird die eigentliche Intention
ja nicht deutlich :-/
Oder ich lasse das Kapitel 4 ganz raus. Wenn es mehr Missverständnisse aufwirft, als es nützt, ist es ja auch nicht so toll.

Mit den weichgespülten Vorteilen muss ich auch mal gucken. Leider bist du ja der Einzige, der sich richtig über das Tutorial
auslässt. Ich wäre froh, wenn sich da noch wesentlich mehr Leute zu Wort melden würden...

@waran Tja, ach ja mehr Feedback?

dann antworte doch bitte auch mal auf meine unbedeutende Anfänger-Kritik, denn dann habe ich auch Lust weiter Feedback zu machen.

Auch wenn ich nicht der Ober-OpenGL Experte bin. Aber wenn du die ganze Zeit im übertragenen Sinn an Lossy eX's Hals hängst (sorry Lossy eX) und aus deiner Sicht "NUR" und ich sage "NUR" ** - *** Tutorialprobleme mit Ihm lösen willst, hmm... auch ok. (net böse gemeint).

Gerade ich als Anfänger, was habe ich davon wenn zwei Experten sich über die Vorzüge jener und socher Weichspüler Soft- und Hardwareansätze streiten, stehe ich als Neuling der Materie doch vor ganz trivialen Problemen, die natürlich bei einer von Dir vermuteten Sternbewertung von ** - *** geradezu lächerlich wirkt. Wäre nett wenn Ihr mal wieder auf den Boden kommt. Ein Tutorial für Einsteiger und Anfänger, und gerade die werden dann einfach mal nicht gehört (wie's auch in der Politik üblich ist) und kommen dann natürlich auch nicht zum Ziel, weil's einfach langweilig ist für die "Experten" sich mit so einem simplem Kram zu befassen.

Und so sehe ich das im Moment, ungeachtet der Tatsache, dass das Tutorial prinzipell gut ist.

PS: Und ich gehe davon aus, dass wenn ich dieses Posting hier nicht geschrieben hätte würde ich wieder keine Antwort auf meine Kritik bekomen.

_________________
Gruß Andreas (aka DeepCopy) - Sic Luceat Lux

Classified Directive: initialization write in function for finalization, repeat until public case uses begin, if not case type as default, var in virtual override for while, in case of class type type asm until read begin.