spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Hallo,
ich bin auf der Suche nach einer Implementierung der Fast Fourier Transformation in einem Shader.
Leider habe ich durch meine Projektumgebung die Einschränkung, dass ein Compute Shader nicht verwendet werden kann, aber nach eigenen Recherchen sollte sich das Problem auch über Texturen im Fragment Shader lösen lassen.
Nun habe ich schon einige Beispiele gefunden, die aber fest in einer OpenGl Umgebung verwurzelt sind, da mein Projekt aber in x3d laufen muss, fällt eine Portierung schwierig.
Cuda und OpenCl implementiert über ein Java Script wäre eine andere Möglichkeit, besser wäre es aber, wenn ich die FFT direkt im Shader bewältigen könnte.
Hat damit schon einer Erfahrungen gesammelt? Gibt es vielleciht ein gutes Beispiel, welches nicht auf OpenGl basiert?

Gruß, Flo

Ich möchte das ganze im Rahmen einer grafischen Simulation nutzen, Shader werden also bereits verwendet.
Es würde daher den Overhead erheblich reduzieren, wenn ich nicht noch extra Cuda oder ähnliches einbinden müsste.

Die Umgebung der des Programms sieht so aus:
Darstellung über die beschreibende Sprache x3d (leider Vorgabe),
Shader werden in der x3d Umgebung aufgerufen, Vertex-, Geometry- und Fragmentshader sind möglich, als Sprache kann glsl, cg und hlsl genutz werden.
Alle weiteren Berechnungen müssen über Script, also Javascript oder Java-Klasse implementiert werden.

Im Moment benutze ich JTransform als Java Klasse, also eine reine CPU basierte Lösung.
Die erstellte FFT wird nicht mehr verändert, sondern direkt als Texture an meinen Vertex Shader übergeben, falls das irgendwie helfen sollte.

Falls das ganze im Shader nicht so einfach möglich ist, bin ich für alle anderen Lösungsansätze natürlich auch sehr dankbar!

@Schrompf:
Vielen Dank, da werde ich mich spätestens nächste Woche mal einlesen. Mal schauen, wie gut ich den Lösungsansatz auf meine Umgebung übertragen kann.

@dot:
Es handelt sich dabei um ein Wellenspektrum für eine Ozeandarstellung, die ich im Moment mit Java berechne.
Die Größe beträgt Momentan 256x256, soll aber nach Möglichkeit größer werden.
Durch Berechnen der Inversen FFT bekomme ich ein Höhenfeld, welches ich in einer Textur speicher und im Vertex shader lade, um die Vertizes zu verschieben.
Ich hoffe, du kannst dir nun zumindest grob etwas darunter vorstellen.

Ich habe erst einmal Cuda in die Anwendung integriert, das Ergebnis hatte ich mir allerdings anders vorgestellt.
Hier mal ein kleiner Benchmark:

Umgebung:
- Zwei Unterprogramme, Berechnung einmal auf CPU Basis (JTransform), einmal auf GPU Basis (JCuda), welche sich bis auf kleine Anpassungen nicht voneinander unterscheiden.
- Beide laufen mit double Präzision und 2D
- Es werden pro Unterprogrammdurchlauf 3 iFFT hintereinander durchgeführt und die Zeit gemessen
- Notebook: i7-4710HQ, 8GB Ram, GTX 860m, Windows 10 64bit

Input 512²:
CPU: 7-16 ms
GPU: 16-32 ms

Input 1024²:
CPU: 31-47 ms
GPU: 47-63 ms

Input 2048²:
CPU: 141-156 ms
GPU: 234-250 ms

Die richtige Grafikkarte wird belastet, aber nur mit etwa 8%.
Erklären kann ich mir die Ergebnisse nur damit, dass der Datentransfer zur Grafikkarte derart langsam ist, dass jeglicher Performance-Vorteil aufgefressen wird.

Kommt das sonst ungefähr hin, oder sind 10-20ms bei 1024² auch sonst viel zu langsam? (Java kann hier natürlich auch nicht so schnell sein, wie c).