Texturspeicher über Shader aktualisieren?

Was der Titel sagt. Ist es möglich, eine Textur über einen glsl-Shader zu aktualisieren? Etwas wie :

//Read
vec4 Pixel = texture2D(TextureID,gl_TexCoord[TextureIndex].st);

//Write to texture memory ?
vec4 NewPixel = Pixel + vec4(0.0,0.0,0.0,AlphaPatch);

// ?? How to write back to texture memory ??
texture2D(TextureID,gl_TexCoord[TextureIndex].st) = NewPixel; 

??

Sie möchten eine Textur an einen Shader binden und dann in diese Textur rendern. Ich könnte kilometerlange Dokumentationsspezifikationen von OpenGL durchspucken, aber ich werde das Gefühl geben, das mir mein Bauch gibt:

Ich denke nicht, dass das möglich ist.

Was ich jedoch weiß, ist möglich, dass Sie ein Frame Buffer Object (FBO) erstellen und darauf rendern. Zunächst müssen Sie einen FBO generieren und ihm eine Textur mit derselben Größe wie die zu aktualisierende hinzufügen.

GLuint fbo_handle, fbo_texture_handle;

GLuint texture_width = GetTextureWidth();
GLuint texture_height = GetTextureWidth();

// generate texture

glGenTextures(1, &fbo_texture_handle);
glBindTexture(GL_TEXTURE_2D, fbo_texture_handle);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texture_width, texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);

// generate framebuffer

glGenFrameBuffers(1, &fbo_handle);
glBindFrameBuffer(GL_FRAMEBUFFER, fbo_handle);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo_texture_handle, 0);

GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
    LOG_ERROR("Could not validate framebuffer);
}

glBindFramebuffer(GL_FRAMEBUFFER, 0);

Wenn Sie Ihre Textur aktualisieren möchten, müssen Sie die folgenden Schritte ausführen.

Zuerst fügen Sie den FBO hinzu:

glBindFramebuffer(GL_FRAMEBUFFER, fbo_handle);

glPushAttrib(GL_VIEWPORT_BIT);
glViewport(0, 0, texture_width, texture_height);

Jetzt können Sie ein Vollbild-Quad mit einem Shader rendern, der die aktualisierte Farbe ausgibt:

vec4 frag_texture = texture2D(TextureID, gl_TexCoord[TextureIndex].st);

vec4 frag_updated = frag_texture + vec4(0.0, 0.0, 0.0, AlphaPatch);

gl_FragData[0] = frag_updated;

Und dann müssen Sie den resultierenden Framebuffer in die ursprüngliche Textur kopieren.

glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_handle);
glBindTexture(GL_TEXTURE_2D, original_texture_handle);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texture_width, texture_height);

glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);

glPopAttrib();

Sie sollten jedoch Folgendes berücksichtigen:

• Wie oft aktualisieren Sie diese Textur?
• Wenn Sie es nicht bei jedem Frame aktualisieren müssen, ist diese Methode die Geschwindigkeitsstrafe wert?
• Können Sie mehrere Versionen dieser Textur generieren und zwischen ihnen wechseln?
• Gibt es einen anderen Weg, um den gleichen Effekt zu erzielen?

Wenn Ihre Hardware dies unterstützt, können Sie mit der Erweiterung GL_ARB_shader_image_load_store in eine Textur schreiben.

Ja, es ist möglich, Textur / ImageLoad sind zum Lesen und ImageStore zum Schreiben.