DGL :: Thema anzeigen - > 128 Texturlookups im Fragment Shader anscheinend möglich?

uniform sampler1D fftData;
uniform float fftAvgStep;
varying float texCoord0x;
const float fftdBLog = 3.321928094887362;
const int halfCount = 127;
const float halfCountf = float(halfCount);
const float totalCount = float(halfCount) * 2. + 1.;
const float avgDecay = sqrt(halfCountf / 2.0);
float sqr(float value)
{
return value * value;
}
void main(void)
{
float p = texCoord0x;
float s = fftAvgStep;
float value = texture1D(fftData, p).r;
float sum = value, sqsum = sum * sum, weightSum = 1.;
for (int i = -halfCount; i < 0; i++) {
float coord = p + s * float(i);
float weight = exp(-sqr(float(i-1)/halfCountf) * avgDecay) * step(0., coord);
float tmp = texture1D(fftData, coord).r * weight;
sqsum += tmp * tmp;
sum += tmp;
weightSum += weight;
}
for (int i = 1; i < halfCount; i++) {
float weight = exp(-sqr(float(i+1)/halfCountf) * avgDecay);
float tmp = texture1D(fftData, p + s * float(i)).r * weight;
sqsum += tmp * tmp;
sum += tmp;
weightSum += weight;
}
float rms = sqrt(sqsum / weightSum);
gl_FragColor = vec4(value, rms, 0., 0.));
}

Autor:	Lord Horazont [ Mi Feb 15, 2012 16:17 ]
Betreff des Beitrags:	> 128 Texturlookups im Fragment Shader anscheinend möglich?
Hallöchen, Ich benutze die Grafikkarte, um meine FFT-Daten nachzubereiten. Das ist eine 1024-Pixel breite 1D-Textur mit GL_LUMINANCE32F als Datentyp. Ich bilde den Durchschnitt über 255 Datenpunkte, die um dem aktuellen Punkt herum liegen, das ganze für alle 1024 Punkte. Warum läuft das immer noch flüssig? Das sind immer hin 255 Texturlookups. Oder werden 1D-Lookups mit nur einer Komponente irgendwie optimiert? Oder sind das einfach zu wenig Daten um im Softwaremodus signifikant langsamer zu sein (kann ich herausfinden, ob der Shader in Hardware läuft? Der Shaderlog spuckt keine Nachrichten aus). Hier der Shadercode: Code: uniform sampler1D fftData; uniform float fftAvgStep; varying float texCoord0x; const float fftdBLog = 3.321928094887362; const int halfCount = 127; const float halfCountf = float(halfCount); const float totalCount = float(halfCount) * 2. + 1.; const float avgDecay = sqrt(halfCountf / 2.0); float sqr(float value) { return value * value; } void main(void) { float p = texCoord0x; float s = fftAvgStep; float value = texture1D(fftData, p).r; float sum = value, sqsum = sum * sum, weightSum = 1.; for (int i = -halfCount; i < 0; i++) { float coord = p + s * float(i); float weight = exp(-sqr(float(i-1)/halfCountf) * avgDecay) * step(0., coord); float tmp = texture1D(fftData, coord).r * weight; sqsum += tmp * tmp; sum += tmp; weightSum += weight; } for (int i = 1; i < halfCount; i++) { float weight = exp(-sqr(float(i+1)/halfCountf) * avgDecay); float tmp = texture1D(fftData, p + s * float(i)).r * weight; sqsum += tmp * tmp; sum += tmp; weightSum += weight; } float rms = sqrt(sqsum / weightSum); gl_FragColor = vec4(value, rms, 0., 0.)); } grüße ps: Falls das wichtig sein sollte – geschrieben wird in ein FBO mit nur einem 1×1024 Pixel großen GL_RGBA16F Color Attachment (also kein Depth Attachment oder solche Späße) pps: Wer sich über nicht verwendete Variablen wundert – ich habe ein wenig Code entfernt.

Autor:	Coolcat [ Mi Feb 15, 2012 18:08 ]
Betreff des Beitrags:	Re: > 128 Texturlookups im Fragment Shader anscheinend mögli
Du machst also 2551024 Texturlookups, richtig? Jetzt überlege mal wie viele Texturlookups du machst wenn du bei einer Auflösung von 1280x720 ein Fullscreenquad renderst.Des weiteren kann die Grafikkarte in deinem Fall den Texturcache nutzen. Ein Texturlookup aus dem Cache ist etwa doppelt so schnell wie aus dem normalen Speicher. => Deine Grafikkarte langweilt sich Zitat:* Oder werden 1D-Lookups mit nur einer Komponente irgendwie optimiert? Nein, abgesehen von Caching-Effekten, weil die Texel nebeneinander liegen. (Bei einer 2D-Textur ist das ja nur entweder auf der X oder Y-Achse der Fall...aber nicht bei beiden) Generell ist es aber bei Datentexturen sinnvoll (sofern es die Hardware erlaubt) ein TBO zu benutzen. Dann kannst du direkt mit Integer-Koordinaten auf die Textur zugreifen, du sparst dir die Float-Umwandlung und Interpolation zwischen den Texeln.

Autor:	Lord Horazont [ Mi Feb 15, 2012 18:16 ]
Betreff des Beitrags:	Re: > 128 Texturlookups im Fragment Shader anscheinend mögli
Coolcat hat geschrieben: Generell ist es aber bei Datentexturen sinnvoll (sofern es die Hardware erlaubt) ein TBO zu benutzen. Dann kannst du direkt mit Integer-Koordinaten auf die Textur zugreifen, du sparst dir die Float-Umwandlung und Interpolation zwischen den Texeln. Ja, würde ich gerne – aber ich bin auf eine GeForce 7600 beschränkt. Das Caching erklärt das. Ich hatte früher halt mal nen Blur gebaut und bin schon bei 81 Lookups am Ende gewesen. Ich dachte, es gäbe nen Hardwarelimit was die Anzahl der Lookups betrifft. greetings

Autor:	Coolcat [ Mi Feb 15, 2012 18:54 ]
Betreff des Beitrags:	Re: > 128 Texturlookups im Fragment Shader anscheinend mögli
Nein, die Anzahl der Texturen ist begrenzt, nicht die der Lookups. Bei deinem Blur-Shader hast du sicher 81 Lookups PRO Pixel gemacht....selbst bei 1024x768 Auflösung sind das deutlich mehr als das was du jetzt machst.

DGL https://delphigl.com/forum/

> 128 Texturlookups im Fragment Shader anscheinend möglich? https://delphigl.com/forum/viewtopic.php?f=20&t=10307	Seite 1 von 1

Seite 1 von 1	Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group https://www.phpbb.com/