Hi Leute,
(ich weiß nicht genau ob es hier in der OpenGL-Kategorie oder Allgemein-Katergorie richtig ist, also tut mir Leid fals ich hier falsch bin )
ich erarbeite mir meinen Raytracer von grundauf neu, damals waren Optimierungen extrem schwer umzusetzen, was mich dazu veranlasste (ist das ein richtiges Wort? o_O ) die Struktur zu ändern, bzw. das Projekt noch mal von Null zu beginnen. Da ja Grafikkarten heutzutage an und für sich recht gut geeignet sind um Berechnungen zu parallelisiern und man (fast) immer mehr-kern-Systeme hat, hab ich alles auf Threads ausgebaut, nun will ich OpenGL nutzen um Berechnungen zu parallelisiern. OGL unterstützt ja nun leider nicht Multithreading, was mich zu meiner eigentlichen Frage bringt:

Was macht mehr Sinn: Für jeden Thread einen eigenen Kontext erstellen oder aber die Synchronize-Methode verwenden und den Primärthread alle OpenGL-relevanten Routinen ausführen zu lassen?

cuz
bubble

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Ähm...du willst die Grafikkarte rechnen lassen? Dann macht es keinen Sinn die CPU parallel arbeiten zu lassen. Die Grafikkarte kann nur einen Kontext gleichzeitig bearbeiten. Außerdem dürfte ja die Grafikkarte den Hauptteil der Arbeit übernehmen und die CPU sich eigentlich langweilen.

=> Es sollte immer nur einen Thread geben der OpenGL benutzt.

_________________
Yeah!

Kann man auf Grafikkarten parallel rechnen lassen? Also gezielt?

Geht das vielleicht mit OpenCL?

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

Was meinst du warum Grafikkarten im Vergleich zum Software-Renderer so schnell sind: Eine Grafikkarte arbeitet hoch-parallel, z.B. die GeForce GTX 295 hat 2 GPUs mit jeweils 240 Kernen. Dafür sind die Kerne aber sehr auf die Grafikverarbeitung spezialisiert und für sich alleine genommen natürlich wesentlich langsamer als ein CPU-Kern.
Oder was ist genau die Frage?

_________________
Yeah!

Öhm ... Ich weiß zwar DAS man die GPU via OpenGL rechnen lassen kann, aber ich weiß leider nicht WIE >_<'
also wie kann ich das bewerkstelligen?

(ich werd gleich mal den Titel des Themas ändern)

Zur Parallelisierung dann auch noch eine Frage, macht das OpenGL bzw. der Treiber oder was auch immer alleine oder muss man das selbst noch einstellen?

cuz bubble

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Wenn du das wirklich über OpenGL (und nicht über spezielle Sprachen für diesen Zweck wie OpenCL oder CUDA) machen willst musst du deine Berechnung geschickt in einen oder mehrere normale Rendervorgänge verpacken. Dein Endergebnis findet sich dann am Ende in einem FBO oder VBO (*). Ohne Shader geht hier natürlich gar nichts, das sollte klar sein. Als Beispiel kannst du die Artikel GLSL_Partikel und GLSL_Partikel_2 nehmen.


Das macht die Grafikkarte alleine, du musst dich nicht darum kümmern. Allerdings musst du natürlich dafür sorgen das deine Anwendung auch wirklich parallel ausgeführt werden kann. Wenn du beispielsweise versuchst eine Million GL_POINTS mit additivem Blending in einen 1x1 Pixel großen FBO zu rendern, wirst du feststellen das dies ziemlich langsam ist. Das liegt daran, dass Schreibzugriffe auf eine Speicherzelle nicht parallel ausgeführt werden können.

Generell ist es sinnvoll sich sehr gut mit den Möglichkeiten einer modernen Grafikkarte aus zu kennen. Das betrifft z.B. Floating-Point-Texturen, Instancing, MRT und allgemein den Aufbau der Rendering-Pipeline.

(*) Mit Transform-Feedback kann man in ein VBO schreiben.

_________________
Yeah!

Ich hab mir mal die ganzen Links angeguckt, und ich muss sagen: ich bin verwirrt >_<'

Wenn ich mich recht erinnere ist doch der Fragmentshader und der Pixelshader das selbe oder?

Auf allen Links werden Shader Versionen >2.0 verwendet, da ich nun aber ein recht altes Notebook hab, hab ich gradmal Vertex- und Pixel-Shader 2.0, dadurch fallen auf jedenfall Transform-Feedback und GLSL Partikel 2 auf jedenfall Weg, da meine Shaderversionen einfach inkompatibel sind. GLSL Partikel: Genau das selbse PixelShader 3.0

Gibt es eine Variante die Ergebnisse des Shaders "Abzufangen" um mit ihnen zu arbeiten?

cuz bubble

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Ja, unter DirectX heißt der Fragmentshader halt Pixelshader.


Ja, das FramebufferObject (FBO). Das erlaubt es einfach in eine Textur statt in den Framebuffer zu rendern. Die Textur kannst du dann in den Hauptspeicher kopieren. Sollte auch mit ShaderModell 2.0 funktionieren.

_________________
Yeah!

Der erste Artikel braucht nur deshalb Shader 3.0, weil er den Texturlookup im Vertexshader benutzt. Alles andere geht auch mit Shader 2.0.

_________________
Yeah!

Eine Frage hab ich dennoch, diesmal aber wieder was den Fragmentshader angeht:

Mein Frag.-Shader kann laut "OpenGL Extensions Viewer" maximal 512 Unifroms übergeben, mein Raytracer soll ja nun aber irgendwann mal komplexe Meshes darstellen können, die dann wiederum auf Garantie mehr als 512 Dreiecke hat. Wie kann ich dieses Problem lösen?

cuz
bubble

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Zum ersten handelt es sich um Uniform-Vektoren, also du hast maximal 512 vec4 uniforms. Desweiteren kannst du Float-Texturen benutzen, zumindest wenn deine Hardware GL_ARB_texture_float oder ggf. einen Vorgänger davon kann.

_________________
Yeah!

T___T GL_ARB_texture_float wird nicht unterstützt ....
Bei google find ich nichts über Vorgänger
ich Liste mal alle Extensions die was damit zu tun haben könnten mit "texture" auf die ich hab:
GL_ARB_texture_env_add
GL_ARB_texture_env_combine
GL_ARB_texture_env_crossbar
GL_ARB_texture_env_dot3
GL_ARB_texture_mirrored_repeat
GL_ARB_texture_rectangle
GL_ATI_texture_env_combine3
GL_EXT_texture_object

Kann man auch ein komplettes VBO übergeben eigene Records erstellen und diese dann mit uniform übergeben?

Ich hab übrigens eine ATI X1250 falls das irgendwie hilfreich sein sollte...

cuz
bubble

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Das geht mit TextureBufferObjects, aber das braucht Shader 4.0

Der Vorgänger von GL_ARB_texture_float ist GL_ATI_texture_float. Du kannst aber versuchen Floating-Point-Zahlen durch Fixed-Point-Zahlen zu simulieren:

Damit kannst du Zahlen zwischen -32768 und 32767 mit einer Genauigkeit hinter dem Komma von 4-5 Dezimalstellen darstellen. Da sollte reichen, da du diese Darstellung ja nur zum laden der Daten brauchst, rechnen kannst du im Shader mit echten Floats und das Ergebnis des Raytracings sind ja eh nur Farbwerte.

_________________
Yeah!

Okay, dass müsst ich mit der Wertespanne eigentlich hinbekommen, das einzige was mir im moment noch Probleme bereitet ist der Framebuffer...

Also Fehlermeldungen kommen keine (auch nich durch gluErrorString(glGetError)) aber ich kann auch trotzdem nix sehen T__T

Hier mal mein Code zum rendern:



GL_TEXTURE_2D ist natürlich aktiviert

_________________
Wenn Worte nichts als Worte sind,
dann müssen's Steine sein!
Solange - bis sie pleite sind - schmeißt Fensterscheiben ein!
- Fidl Kunterbunt -

Sind ModelView und Projection-Matrix auf Identity gesetzt?
Was sagt glCheckFramebufferStatusEXT ?

_________________
Yeah!