Using glFeedbackBuffer

For quite some time I had no idea what glFeedbackBuffer was, or even that it existed. I discovered it one day and found how incredibly useful it is.

The FeedbackBuffer lets you get feedback from OpenGL (yeah, go figure?). What does this mean? Say you want to know the exact screen coordinates of where something will be rendered in your 3d world. There's no accurate way to calculate this, because the player could be anywhere in the game and see it from any angle. But thanks to FeedbackBuffer we can find out with no calculations at all.

What it does is it tells OpenGL to *not* render something to the screen. Instead, it "pretends" to render it, meaning it calculates where it will be on screen, because OGL has to know where to draw each pixel, and then gives us feedback on where it was placed. This can also be used to figure out what color something was rendered at, even after light calculations were made. Neat, huh?

This tutorial won't cover getting colors like I just mentioned, but maybe I'll do one if you request it enough. Hint hint.

 

The Source Code

Ok, lets get to it. First we have to make a variable through which OpenGL returns our information.

GLfloat buf[4];

Second step is to tell OpenGL how we want to use the FeedbackBuffer. We have to do this before we set our RenderMode to FeedbackBuffer, otherwise we get an error. Use this line of code to do it:

glFeedbackBuffer(4, GL_3D, (float *)buf);

What do these parameters do?

• • The "4" tells OGL how many values to return. While we only want x, y, and z coordinates, FeedbackBuffer needs one other value for some reason. Wierd, yes, but all I know is this extra value doesn't matter.
  • "GL_3D" means that we want to get the 3d coordinates of what will be rendered. Note that instead of returning an actual Z coordinate value, it returns a floating point decimal between 0 and 1, 0 meaning close to the viewer and 1 meaning far away from the viewer.
  • "(float *)buf" gives OpenGL the pointer to our return buffer.

Now lets turn on Feedback:

glRenderMode(GL_FEEDBACK);

Now we can do stuff to get feedback. A good way to do this is to simply render a point at the spot we want to test.

 

glBegin(GL_POINTS);

	glVertex3f(x, y, z);

glEnd();

Finally, lets turn off Feedback and set our RenderMode back to GL_RENDER:

glRenderMode(GL_RENDER);

Move on to see how to use this feedback.

How to use glFeedbackBuffer's Feedback

After we render anything while in GL_FEEDBACK, our variable buf is updated with the new information.

 

• • buf[0] = extra variable (mentioned earlier), unused
  • buf[1] = X screen coordinate of the object rendered
  • buf[2] = Y screen coordinate
  • buf[3] = Z value (between 0 and 1, 0 being close to the viewer)

The Z value represents how OpenGL does Z Buffer, or Depth Testing. Since glFeedbackBuffer pretends to render things to the screen, we can see how Depth Testing actually works. What it does is, each time anything is rendered to the screen, OpenGL stores it's Depth value (between 0 and 1) and keeps track of it. Next time it has to render something to that pixel, it checks if the new pixel to be rendered has a different Z value. If the new value is greater (farther away) than the stored pixel value, it won't render the pixel. Otherwise, it renders it and stores the new value in the Depth Buffer.

 

http://users.polytech.unice.fr/~buffa/cours/synthese_image/DOCS/Tutoriaux/glGameDeveloppers/view.cgi-V=tutorial_glfeedback&S=3.htm