Heyho, hab mal wieder ne kleine Verständnisfrage. Und zwar will ich 2D-Texturarrays anlegen und diese mit mehreren Texturen füllen (ist ja auch Sinn der Sache). Nu hab ich für jede Textur eine Bilddatei (32-Bit tga, tut aber ja nichts zur Sache), die ich mit der SDL auslesen will (Die sind natürlich auch alle gleichgroß). Die für mich einfachste Art und Weise aus den einzelnen Bildern das Texturarray zu machen wäre jetzt, den Speicher für n * x * y Pixel zu reservieren (mit glTexImage3D, wenn man diesem Link folgt, pixels wäre dann bei mir nil), und dann Bild für Bild in den reservierten Speicherbereich zu schreiben - aber...wie?!

Du hast ein Verständnisproblem:
glTexImage3D befüllt direkt den Speicher auf der Grafikkarte.
Du erstellst vorher eine entsprechend große Surface und kopierst die einzelnen Texturen nacheinander (mit entsprechendem Abstand) in die Surface. Und dann überreichst du die Surface als pixels.

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

glTexSubImage3D ist, was du suchen könntest. Aber sind Texturarrays nicht ein bisschen was anderes als 3D-Texturen?

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Erm, ja....du hast natürlich recht, hab mich da verlesen - das ändert aber nichts an der Datenstruktur, wenn ich das richtig verstanden hab. Der Unterschied liegt nur darin, dass bei Arrays nicht zwischen den einzelnen Layern interpoliert wird.

Die Frage, wie man die Sache füllt bleibt aber natürlich. Ionos Vorschlag klingt praktikabel, aber irgendwie wärs mir lieber, die Pixel nacheinander zu schreiben, und nicht den Umweg zu gehen zuerst die Surface zusammenzusetzen und dann rüberzuschieben.

Wie hab ich mir das mit SubImages denn vorzustellen? Aus dem Wiki-Artikel werd ich irgendwie nich so ganz klar...


Edit: Ne, verlesen hab ich mich nicht, zum Füllen benutzt man tatsächlich glTexImage3D...ändert aber ja wie gesagt nichts am Problem...

Du gibst einen Teilbereich der Textur an, im Regelfall bei dir eine Scheibe, und übergibst einen Pointer mit den neuen Bilderdaten. Dann wird die Textur an der Stelle mit den neuen Bilderdaten beschrieben.

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

Ich glaub du denkst zu kompliziert. Du willst ja nur ein Array aus 2D-Texturen.



und dann halt mit einer Schleife, oder seperat die TexturVariablen füllen.

(Ich benutze zwar nicht SDL aber da gibts sicher so eine einfache loadtga-Funktion oder?
und da machst du dann einfach loadtga(*Pfad*, textures[0]); Mehrere Male.

Sag mir wenn ich mich irre

_________________
Ich teile manchmal heimlich durch Null. - Alber Einstein

Und dann hab ich ein Array von Texturen, aber kein Texturearray. Richtig. Bringt mir leider für meine Zwecke nich wirklich was. Ich will halt ein Texturearray, damit ich nur eine Textur binden muss, und via u-Texturkoordinate auf mehrere zugreifen kann.

Das glTexSubImage3D wird vermutlich meckern, weil es sich nich um ne 3D-Textur handelt, oder?

Ich sitz gerade an Ionos' Ansatz...mal sehen, ob das was wird.

Schreib mal bitte was du genau willst.
Denn das SubImage sollte auch gehen.

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

Also...Ich hab nen VBO mit zig verschiedenen Punkten, die nachher alle jeweils ein texturiertes Quad darstellen sollen. Alle Quads gleich groß und gleich ausgerichtet. Die sollen allerdings verschiedene Texturen kriegen und die Texturen sollen gedreht werden können.
Jetzt könnte man sagen "Nimm einfach ne große Textur und pack die versch. Texturen da nebeneinander rein" dann laufe ich aber Gefahr, dass beim Drehen der Textur teile der danebenliegenden Bilder sichtbar werden.
Also klang es für mich nach nem einfachen und effektiven Ansatz, ein 2D_TEXTURE_ARRAY zu erstellen, die Texturen in unterschiedliche Slices zu packen und einfach eine Texturkoordinate zu benutzen, um die Slice anzugeben, die benutzt werden soll. Das unterstützt OpenGL zwar nur via Shader, aber ich wollte eh nen Shader benutzen, damit ich im VBO mit GL_POINTS auskomme und trotzdem Quads rauskriege - außerdem kann ich dann auch gleich die zweite Texturkoordinate für die Drehung benutzen und die Textur für jedes Quad im Shader drehen.

Jetzt scheiter ich aber leider schon daran, dieses blöde Array anzulegen *brumm*

Edit: Werd wohl später heute abend oder morgen im Laufe des Tages mal austesten, ob die SubImage-Sache funktioniert. Aber im Wiki steht halt, das ginge nur bei GL_TEXTURE_3D.

Laut http://developer.download.nvidia.com/opengl/specs/GL_EXT_texture_array.txt geht das ohne Probleme.

Ein Texturearray verhält sich relativ ähnlich zu 3D-Texturen, mit dem Unterschied, dass bei Texture-Arrays nicht zwischen den verschiedenen Ebenen interpoliert wird.
Ich mache das so:

Ich habe vorher die einzelnen Texturen geladen und Pointer auf die Pixel in einem Vector abgelegt (buffers). Dann erstelle ich ein neues Textur-Objekt, binde es an GL_TEXTURE_2D_ARRAY, lass mir den Speicher reservieren und lege die einzelnen Texturen scheibchenweise hinein.

Mein Fragment-Shader dazu sieht folgendermaßen aus:

Hier ist wieder einer der feinen Unterschiede zwischen 3D-Texturen und 2D-Texture-Arrays zu erkennen: Als Sampler braucht man hier nämlich statt sampler3D ein sampler2DArray.

Der Code ist übrigens (fast) copy&paste aus meinem Projekt, funktioniert also ganz sicher.

_________________
Traue keinem Computer, den du nicht aus dem Fenster werfen kannst -- Steve Wozniak