OpenGL: Retrieving floating point computation results from the GPU - opengl

Question

In a nutshell
In a single shader pass I'm applying a couple of different model transformation matrices in the Vertex Shader and writing the results into different position vectors.
Then I do some simple arithmetic with the different results in the Vertex Shader.
//Vertex Shader
in layout(location=0) vec3 position;
in layout(location=1) vec3 vertexColor;
...
out vec3 result1;
out vec3 result2;
out vec3 result3;
out vec3 color;
void main()
{
gl_Position = transformationMatrix * vec4(position, 1.0);
vec4 pos1 = transformationMatrix1 * vec4(position, 1.0);
vec4 pos2 = transformationMatrix2 * vec4(position, 1.0);
...
result1 = pos1.xyz * pos2.xyz / 0.012313879834;
result2 = (pos2.xyz + pos1.xyz) * 1.5;
result3 = ....;
color = vertexColor;
}
The results of that math I want to pass through the Fragment Shader (so the values are interpolated nicely like colors are) ...
// Fragment shader
in vec3 color;
in vec3 result1;
in vec3 result2;
in vec3 result3;
layout(location = 0) out vec4 theColor;
layout(location = 1) out vec3 output1;
layout(location = 2) out vec3 output2;
layout(location = 3) out vec3 output3;
void main()
{
theColor = vec4(color, 1.0);
output1 = result1;
output2 = result2;
}
... to finally read them back, so that I can continue working with the data on the CPU. I need the data read back to be precise (float 32) and optimally not normalized to [0, 1].
Regarding this I have a couple of questions:
Initially I thought it would be possible to facilitate this using the GL_COLOR_ATTACHMENTi, but I haven't been able to figure out how. Is it possible? If so, how would I go about it?
How would a solution using the Image Load/Store functionality since OpenGL 4.2 look like? Are there potential pitfalls that I need to be aware of?
EDIT: I got it to work with the Color Attachments after all. See below for a solution that worked for me.

Answer 1

Found a solution to work with the Color Attachments after all. The client-side code looks like the following, the Shaders didn't need any change iirc:
void initializeGL()
{
....
// Generate textures.
glGenTextures(3, textures.data());
for (GLuint id : textureIds)
{
// Bind texture and specify size and nature ...
glBindTexture(GL_TEXTURE_2D, id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, m_width, m_height, 0, GL_RGB, GL_FLOAT, nullptr);
}
glBindTexture(GL_TEXTURE_2D, 0);
....
// Attach texture images to Framebuffer.
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, otherTextureId, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, textureIds[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, textureIds[1], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D, textureIds[2], 0);
// Specify color buffers that will be written to.
const GLenum buffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3};
glDrawBuffers(4, buffers);
....
}
void renderGL()
{
....
// Copy images into corresponding buffers in the main memory.
glReadBuffer(GL_COLOR_ATTACHMENT1);
glReadPixels(0, 0, m_width, m_height, GL_RGB, GL_FLOAT, texture1.data());
glReadBuffer(GL_COLOR_ATTACHMENT2);
glReadPixels(0, 0, m_width, m_height, GL_RGB, GL_FLOAT, texture2.data());
glReadBuffer(GL_COLOR_ATTACHMENT3);
glReadPixels(0, 0, m_width, m_height, GL_RGB, GL_FLOAT, texture3.data());
....
}
Any feedback would still be appreciated.