Ich weiß ihr werdet mich dafür hassen ,dass ich hier jetz mit DirectX ankomme, aber darum geht es hier jetz nicht

Folgendes Programmierproblem, das ich zwar gelöst habe , ich aber nicht verstehe, warum es so auf einmal klappt und anders nicht.

Folgendes Problem. Ich habe ein Dynamisches array von Vertices.
In Einer Procedure wird die länge mit SetLength bestimmt , mit Daten gefüllt und über einen Pointer auf den Vertexbuffer, diese Daten dort reingeschrieben.

Beim Rendern kommt leider nur mist bei raus.

Um zu vermeiden, dass ich selbst beim Erstellen der Vertices einen Fehler gemacht habe, habe ich zunächst den dynamischen Array mal statsich gemacht und voila es hat dann geklappt.
Also liegt es am Dynamischen array : der Quellcode sieht wie folgt aus:




Quellcode stimmt , da eben alles mit statischem array funktioniert. nur mit dem dynamischen nicht.

Jetzt hab ich etwas rumgebastelt und alles so umgebaut :


Die Vertices werden nun in einer anderen procedur erstellt (Hier auch dymanisches Array) , dann über ein array _Vertices an die Funktion TD3DHEightmap.GenerateVB übergeben und diese läd das dann in den Vertexbuffer.

komischerweise klappt es so ?! WARUM ?!
beides mal dynamisches Array Vertices nur nicht in der gleichen Procedure ?! ?! ?!
Kann mir das einer erklären ?

Vielen Dank

Simon

Nö. Es wird nur im Laufe des Tages dein Benutzeraccount gelöscht. Quatsch. Wir sind offen für alles. Nur wird man dir bei richtigen DirectX Fragen in einem OpenGL Forum wohl nicht so gut helfen können wie in einem DirectX Forum.

Arrays: Es gibt einen wirklich markannten Unterschied zwischen statischen und dynamischen Arrays. Bei einem statischem Array befinden sich dessen Daten direkt an der Stelle der Variable. Bei einem dynamischen aber handelt es sich um einen Pointer. Dessen Daten liegen aber irgendwo im Heap. Und da zeigt der Pointer hin. Wenn du darauf zugreifst weiß Delphi das und löst den Pointer selbsttätig auf.

Bei einem Befehl wie Move musst du aber einen Speicherbereich übergeben. Bei einem Statischen ist die Variable gleich der Speicherbereich. Deswegen geht das. Bei Dynamischen musst du aber auf das erste Element des Arrays verweisen, da du damit dann explizit den Datenbereich des Arrays meinst. Bei Strings gilt im übrigen das Gleiche. Die sind mit einem dynamischem array of char vergleichbar.

Das mache ich im übrigen grundsätzlich immer so. Egal ob es sich dabei um ein statischen oder dynamisches Array handelt. Ich geben immer genau die Stelle an die ich meine.

Warum die zweite Variante allerdings funktioniert kann ich dir nicht sagen. Denn normal sollte sie die gleichen Einschränkungen haben wie die Erste. Mit anderen Worten das dürfte genau so wenig funktionieren wie die erste Variante. Und das solltest du ändern, da es möglicherweise ein Compilerfehler ist der irgendwann behoben wurde etc. Also ich würde mich nicht darauf verlassen, dass es imme funktionieren wird.

Und wenn du so etwas (Var: array of TD3DLVertex) häufiger brauchst solltest dafür einen extra Typen definieren und diesen benutzen.


PS: Statische Arrays als lokale Variablen liegen auf dem Stack. Da der Stack aber normal auf 1 MB begrenzt ist würdest du so bei größeren Datenmengen einen Stackfehler bekommen. Dynamische liegen im Heap und könnten somit den vollen Speicher des Systems ausnutzen. Das ist in der Praxis zwar nicht möglich aber das ist ein anderes Thema.

Danke für die Antwort. HAb mir Pointern noch nicht so viel am Hut gehabt. alles was ich bisher dazu gefunden habe , war sehr knapp erklärt. zu knapp .

vllt. kennt einer ne gute seite , wo das erklärt ist ?


aber ich hab das jetz wieder so umgeswchrieben und leider kommt schon wieder mist bei raus .. hmpf

Stimmt. Denn SizeOf liefert bei einem statischen Array die Große der Daten, da die Variable alle Daten enthält. Allerdings bei einem dynamischen Array liefert SizeOf den Wert 4, da es sich ja eigentlich um einen Pointer handelt. Und der hat die Größe 4. In 32 Bit Programmen versteht sich.

Die Größenberechnung musst du dann selbst in die Hand nehmen. Aber das ist recht simpel. Und du musst das beim Locken des VBOs auch berücksichtigen.


Ansonsten hat delphi-treff.de recht umfangreiche Tutorials über die Sprache etc. Allerdings gehen diese Tutorials eher nicht unter die Oberfläche. Also wie verschiedene Dinge intern funktionieren. Das ist aber genau das was in diesem Falle wichtig ist. Das ist etwas was man irgendwie alles mal selber erlebt haben muss. Das alles in Tutorials fassen zu wollen wäre zu viel arbeit, da jeder Fall auch ganz speziell ist.



Ich persönlich arbeite bei so etwas mittlerweile lieber komplett per Hand. Also keine dynamischen Arrays sondern direkt den Speicherbereich mit GetMem erstellen und mit FreeMem dann wieder löschen. Aber in deinem Fall geht das auch noch ein Stück einfacher. Denn du kannst auch gleich den Speicherbereich des VBOs benutzen. Anstelle erst selber einen Speicherbereich zu erstellen und die Daten dann rüber zu kopieren. Das Sparrt zu mindest ein mal die Menge des Speichers und die Arbeit des Kopieren.

Das ist dann für Faule, da bei jedem Inc der Pointer um die Größe der Daten (SizeOf(TD3DLVertex)) erhöht wird. So brauche ich mich nur darum kümmern, dass die Eingangsgröße stimmt und die Indexzählung/Berechnung geschieht automatisch. Funktioniert aber nur sofern die Position immer fortlaufend ist. Und das ist wenn ich das gesehen habe bei dir der Fall. Die Variable Size benutze ich deswegen um nicht jedes mal die Größe berechnen zu müssen. Eine Variable spart Rechenleistung und verhindert, dass ich irgendwann mal eine andere Rechnung habe. In diesem Beispiel würde sie nur ein mal benutzt werden aber kann ja auch mehrfach passieren.

Aber das nur Kurz in Sachen Pointer. Die dynamischen Arrays funktionieren genau so gut und vereinfachen manche Dinge auch. Man muss sich nicht um alles selber kümmern.

ah perfekt es funktioniert

Vielen Dank. so langsam steig ich auch hinter die Pointer

einge Frage noch .. Woher weiß Delphi bei Inc(pVertices) das er um SizeOf(TD3DLVertex) weiter gehen muss ?
Weil ich in der Zeile Davor ihn mit der größe beschrieben habe ?

Das funktioniert, weil der Pointer typisiert ist. Also PD3DLVertex = ^TD3DLVertex. Und da weiß der Kompiler wie groß TD3DLVertex ist. Wenn du inc(pByte(PD3DLVertex_Variable)); machen würdest, dann würde der Kompiler den Pointer um 1 Byte erhöhen. Und bei einem "Pointer" (untypisiert) würde der Aufruf sogar fehl schlagen (Kompilerfehler).

ah ok .. also muss ich den Pointer vorher nem best. Typ zuweisen.

bei mir ist er ja noch vom Typ Pointer.


Danke schön