Tag an alle hier,
erstmal Gratulation an die meiner Meinung nach sehr gut gemachten Tutorials und
eigentlich generell an die Seite hier ...
... ich hab nach längerer Zeit wieder einmal ein Problem will auch nicht lange
um den heißen Brei rumreden und komme deshalb mal gleich zum Thema.
Ich bin nun bei Tutorial 8 und habe mit dem Verständnis für folgendes ein Problem ...

Wieso sind die Konstanten im meinem unteren Beispiel als Array angegeben und wieso
verändert sich deren Eigenschaft wenn ich z.B. bei @mat_specular[0] statt der null eine
1,2 oder 3 nehme ???

Ich könnte das ja verstehen wenn ich die Konstanten so deklariert hätte das mat_specular[0]
andere R,G,B,A-Werte hat als mat_specular[1] ... usw.
Also jedes Feld eines jeweiligen Arrays andere Werte zuweise damit sie bei einem Aufruf
unterschiedliche Eigenschaften aufweisen.
Für mich sieht das untere Beispiel aus wie ein Array dessen Werte alle gleich sind.
Das untere Beispiel rendert in etwa das erste Bild aus Tutorial 8. Versteht mich nicht
falsch es klappt alles Wunderbar nur ich hasse es Sachen zu machen die ich nicht verstehe.
Wenn ich sie nicht verstehe schreibe ich einfach nur ohne Sinn ab und das bringt nichts.
Also ...
Wieso ändert sich dennoch der Wert der Konstanten im Array ???

_________________
Es ist ein großer Vorteil im Leben, die Fehler, aus denen man
lernen kann, möglichst früh zu begehen.

Da du dein Array als Pointer übergibst, indiziert die 0 (oder je nach dem was du da einsetzt) dein erstes Element. Wenn du also dein komplettes Array übergeben willst, musst du dort eine 0 einsetzen. (bei einer 1 wäre dann der y wert plötzlich der x wert und der z wert der y wert, ginge man von vektoren aus)

mfg

Boah ... öhm ...
Naja das versteh ich so nicht ganz.
Also würde das heißen bei z.B.


zeige ich mit

auf die ganzen Werte R,G,B,A ...
... und mit

nur noch auf G,B,A ...
... und mit

nur noch auf B,A ...
usw.

Oder meinst du das jetzt anders ???

_________________
Es ist ein großer Vorteil im Leben, die Fehler, aus denen man
lernen kann, möglichst früh zu begehen.

Ja, genau das meint Seth. Das ganze ist übrigens noch schlimmer da du nicht auf G, B, A sondern auch auf den Speicherbereich hinter dem Array zeigst und somit wild im Speicher rumgelesen wird.

_________________
Steppity,✲steppity,✴step,❆step,✳step!
❆ ❄ ❄ ❄ ❅ ❄ ❆ ❄ ❅ ❄ ❅ ❄ ❅ ❄ ❄
❅ ☃ ❄ ❄ ❄ ❅ ❄ ❄ ❄ ❅ ❄ ☃ ❄ ❆ ❄ ❄

Klingt ja nicht gerade sehr nach Perfomance ...
Aber wo ließt er denn wild im Speicher rum ???
Ich seh nicht das ein Zeiger im Array auf ein nicht
belegten Platz zeigt zumal doch das Programm dann garnicht
compiliert werden müsste.
Da meckert doch Delphi dann immer ...


@mat_specular[x]

0 steht für alle Werte als "Farbmischung" nehmen. (R,G,B,A)
1 ohne Alpha Wert (R,G,B)
2 ohne blau (R,G)
... und ...
3 nur rot (R)

Halt von dem jeweiligen Konstantenwert ...
... oder ???

_________________
Es ist ein großer Vorteil im Leben, die Fehler, aus denen man
lernen kann, möglichst früh zu begehen.

Wenn du nicht den Pointer auf das erste Element nimmst, sondern auf das Zweite, kann OpenGL das ja nicht wissen und denkt so, dass nach dem angegebenen Element im Array
noch 3 kommen. Wenn du also @mat_specular[1] angibst, nimmt OpenGL deinen G Wert intern als R Wert, und deinen B Wert als G Wert.

Wenn OpenGL dann den A Wert haben will, ist dein Array aber schon zu Ende. Das bedeutet, dass einfach die nächste Adresse im Speicher benutzt wird. Was da drin steht kann dir aber leider keiner sagen.

Kurz und knapp: OpenGL weiß nicht, ob du den Pointer an der Stelle 0, 1, 2 oder 3 benutzt hast (im Array mat_specular[x] ).
Hast du nicht die 0 genommen, nimmt OpenGL trotzdem die nächsten 3 Adressen im Speicher, die danach kommen.

Delphi meckert das nicht an, da die Funktion ja nur einen Pointer auf einen GlFloat erwartet. Der Rest passiert dann in der DLL.

Achsoooo ...
Also heißt das , dass man generell nur die 0 verwenden sollte oder
das jeweilige Array so erweitern das man 1,2,3 ... benutzen kann.
Zum Beispiel


Dann könnte ich doch auch ...

@mat_ambient[0]
@mat_ambient[1]
@mat_ambient[2]
@mat_ambient[3]

... angeben
Nun greift er nicht mehr einfach irgendwo in
den Speicher da das Array ja bis dahin geht.



Ist das nun richtig so oder hab ich doch noch was nicht kapiert ???

_________________
Es ist ein großer Vorteil im Leben, die Fehler, aus denen man
lernen kann, möglichst früh zu begehen.

Du kannst das Array natürlich so groß machen wie du das möchtest aber du solltest immer bedenken, dass glMaterialfv 4 Werte erwartet. Und die nacheinander im Speicher liegen müssen.

Wenn du jetzt allerdings [0] und [1] übergibst dann übergibst du überlappende Bereiche. Also zu erst ein mal den ersten Wert und OpenGL nimmt sich 3 Weitere die danach im Speicher lieben. Und bei [1] übergibst du den zweiten Wert und OpenGL nimmt sich noch 3 darauf folgende Werte.

Das bekommst OpenGL bei [0].
[0], [1], [2], [3], [4], [5], [6], [7]

Das bekommst OpenGL bei [1]
[0], [1], [2], [3], [4], [5], [6], [7]

Um es zu erreichen, dass sich die Bereiche nicht überlappen müsstest du also [0] und [4] übergeben. Denn [4] liegt direkt nach den ersten 4 Werten. Und du musst dann dafür sorgen, dass nach [4] noch 3 Werte liegen. Ansonsten kann es passieren, dass OpenGL auf etwas falschen zugreift oder sogar Fehler wirft.

Gut , na dann weis ich ja jetzt wie das genau funktioniert.
Ich bedanke mich bei eurer schnellen und ausführlichen Hilfe
und sag schonmal bis zum nächsten mal .

_________________
Es ist ein großer Vorteil im Leben, die Fehler, aus denen man
lernen kann, möglichst früh zu begehen.