Hallo,

ich beschäftige mich im Moment mit der zweidimensionalen Bildverarbeitung mit OpenGL. Folgendes möchte ich realisieren:

Es existieren verschiedene Module, die einen Eingang und einen Ausgang besitzen. Jedes Modul verarbeitet dabei ein Bild, und zwar mit GLSL, um nette Pixelshader zu realisieren.

Da ich mehr mit den Konzepten von DirectX vertraut bin habe ich folgende Vorstellung wie die allgemeine Struktur aussehen soll:

1. Am Eingang liegt eine Textur.
2. Das Modul rendert diese Textur auf ein Quad in eine zweite Textur und wendet dabei einen Pixelshader an.
3. Die zweite Texture wird in den Ausgang gelegt, den das nächste Modul als Eingang verwendet.

Nun habe ich erfahren das es bei OpenGL auch Funktionen wie glDrawPixels und glReadPixels gibt, die direkt Pixel schreiben und lesen können.

Daher meine Frage. Welches Verfahren ist das schnellste? Sollte man ein RenderToTexture Effekt verwenden wie oben beschrieben oder durch glDrawPixels die Pixel selbstständig kopieren?

Neo

Wenn du die Pixel über GLReadPixels liest weiterverarbeitest und mit GLDrawPixels wieder in die Textur schreibst kannst du dir meiner Meinung nach den Weg über die GraKa sparen, da dann der Prozessor rechnet und die GraKa nur als "Arbeitsspeichererweiterung" genutzt wird, was in meinen Augen weder sinnvoll noch schnell ist.

_________________
Bevor du definierst, was etwas ist, versichere dich seiner Existenz.

glReadPixels ist glaub ich nicht so zu empfehlen. Es ist doch recht langsam. Kommt aber natürlich darauf an für welchen Zweck du die Texturen benötigst. Echtzeit ist mit ReadPixels wohl nicht drinnen.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Am besten die Framebuffer Objekte verwenden.
http://oss.sgi.com/projects/ogl-sample/ ... object.txt

Ein Framebuffer besteht aus einem DepthBuffer und einem oder mehreren ColorBuffern. Das können auch Texturen oder RenderBuffer (IDirect3DSurface9) sein. Man kann dadurch eine ganze Kombination gleichzeitig wechseln.
Mit glFramebufferTexture2DEXT und glFramebufferRenderbufferEXT kann man jeweils Texturen oder RenderBuffer als Depth oder ColorBuffer einstellen. Also wie SetRenderTarget und SetDepthStencilSurface.
In dem Text zu der Extension sind Beispiele.

Vielen Dank für die bisherigen Antworten.

Damit ist das Verfahren also ähnlich wie in DirectX, das man Texturen verwendet in die man rendert. Das direkte Schreiben in die Textur bzw. das Lesen mit ReadPixels sollte dann womöglich vermieden werden. Diese Verfahren werden eh nur am Anfang und am Ende der Verarbeitungskette verwendet. Zwischendrin wird die komplette Verarbeitung durch Shader angestrebt.

Viele Module benötigen lediglich eine Möglichkeit in einen Buffer zu rendern der durch einen Pixelshader (oder eben Fragmentshader) manipulierbar ist. Benötigt man dafür in OpenGL eine Textur die auf ein Quad gemappt wird oder sind auch die von LarsMiddendorf angesprochenen RenderBuffer möglich, die erst ganz zum Schluss von einem Modul in den Framebuffer geblittet werden?

Neo

Eine letzte Frage habe ich noch:

Ich habe mich jetzt mehr mit den Framebuffer Objekten beschäftigt und man liest an vielen Stellen, dass das der beste Weg ist um im Moment Offscreen Rendering zu bewerkstelligen.

Nun kann man mit dem Framebuffer Objekten entweder Texturen oder RenderBuffer verwenden. Welche Option wäre in meinem Fall, wo es nur um die Verarbeitung von 2D Bildern geht, am effektivsten.

Verwende ich Texturen, benötige ich ein Quad, worauf ich die Textur mappe, um Textur 1 in Textur 2 zu kopieren. Ist diese Annahme korrekt?
Verwende ich RenderBuffer, wie kommen die Pixel von einem Buffer in den nächsten Buffer. Verwende ich dafür glCopyPixels?

Ich bedanke mich schonmal für die Antworten.

Neo

Renderbuffer sind iirc im wesentlichen nur dafür da, dass in sie gezeichnet wird, insofern wirst du mit texturen wohl glücklicher. Und ein Quad zu zeichnen auf das die gemapt wird dürfte wohl kein großes Problem darstellen

Da muß man gegenüber D3D aufpassen. Die Texturekoordinaten sind um einen halben Texel verschoben, d.h. das hängt von der Auflösung ab. Die Richtung weiß ich aber jetzt nicht auswendig.

Vielen Dank für die Antworten, ihr habt mir schon sehr weit geholfen.

Jetzt habe ich nur noch eine letzte Performancefrage.

Wie bereits erwähnt existieren bei mir Module, die einzeln in eigene Texturen rendern, die dann an das nächste Modul weitergereicht werden. Meine Frage ist nun, sollte jedes Modul ein eigenes Framebufferobjekt verwenden, oder ist es performanter wenn ein globales Framebufferobjekt existiert, das alle Module verwenden, und lediglich ihre Texturen in diesem Objekt anders binden?

Neo