InfoVis: RenderingHandler class Reference

00154 { 00155 int objectsFound = 0; // This will hold the amount of objects clicked 00156 int viewportCoords[4] = {0}; // We need an array to hold our view port coordinates 00157 00158 // This will hold the ID's of the objects we click on. 00159 // We make it an arbitrary number of 32 because openGL also stores other information 00160 // that we don't care about. There is about 4 slots of info for every object ID taken up. 00161 unsigned int selectBuffer[1024] = {0}; 00162 00163 // glSelectBuffer is what we register our selection buffer with. The first parameter 00164 // is the size of our array. The next parameter is the buffer to store the information found. 00165 // More information on the information that will be stored in selectBuffer is further below. 00166 00167 glSelectBuffer(1024, selectBuffer); // Setup our selection buffer to accept object ID's 00168 00169 // This function returns information about many things in OpenGL. We pass in GL_VIEWPORT 00170 // to get the view port coordinates. It saves it like a RECT with {top, left, bottom, right} 00171 00172 glGetIntegerv(GL_VIEWPORT, viewportCoords); // Get the current view port coordinates 00173 00174 // Now we want to get out of our GL_MODELVIEW matrix and start effecting our 00175 // GL_PROJECTION matrix. This allows us to check our X and Y coords against 3D space. 00176 00177 glMatrixMode(GL_PROJECTION); // We want to now effect our projection matrix 00178 00179 glPushMatrix(); // We push on a new matrix so we don't effect our 3D projection 00180 00181 // This makes it so it doesn't change the frame buffer if we render into it, instead, 00182 // a record of the names of primitives that would have been drawn if the render mode was 00183 // GL_RENDER are now stored in the selection array (selectBuffer). 00184 00185 glRenderMode(GL_SELECT); // Allows us to render the objects, but not change the frame buffer 00186 00187 glLoadIdentity(); // Reset our projection matrix 00188 00189 // gluPickMatrix allows us to create a projection matrix that is around our 00190 // cursor. This basically only allows rendering in the region that we specify. 00191 // If an object is rendered into that region, then it saves that objects ID for us (The magic). 00192 // The first 2 parameters are the X and Y position to start from, then the next 2 00193 // are the width and height of the region from the starting point. The last parameter is 00194 // of course our view port coordinates. You will notice we subtract "y" from the 00195 // BOTTOM view port coordinate. We do this to flip the Y coordinates around. The 0 y 00196 // coordinate starts from the bottom, which is opposite to window's coordinates. 00197 // We also give a 2 by 2 region to look for an object in. This can be changed to preference. 00198 00199 gluPickMatrix(x, viewportCoords[3] - y, 2, 2, viewportCoords); 00200 00201 // Next, we just call our normal gluPerspective() function, exactly as we did on startup. 00202 // This is to multiply the perspective matrix by the pick matrix we created up above. 00203 00204 gluPerspective(45.0f,(float)screen_width_/(float)screen_height_,0.1f,150.0f); 00205 00206 glMatrixMode(GL_MODELVIEW); // Go back into our model view matrix 00207 00208 renderScene(); // Now we render into our selective mode to pinpoint clicked objects 00209 00210 // If we return to our normal render mode from select mode, glRenderMode returns 00211 // the number of objects that were found in our specified region (specified in gluPickMatrix()) 00212 00213 objectsFound = glRenderMode(GL_RENDER); // Return to render mode and get the number of objects found 00214 00215 glMatrixMode(GL_PROJECTION); // Put our projection matrix back to normal. 00216 glPopMatrix(); // Stop effecting our projection matrix 00217 00218 glMatrixMode(GL_MODELVIEW); // Go back to our normal model view matrix 00219 00220 // PHEW! That was some stuff confusing stuff. Now we are out of the clear and should have 00221 // an ID of the object we clicked on. objectsFound should be at least 1 if we found an object. 00222 00223 if (objectsFound > 0) 00224 { 00225 // If we found more than one object, we need to check the depth values 00226 // of all the objects found. The object with the LEAST depth value is 00227 // the closest object that we clicked on. Depending on what you are doing, 00228 // you might want ALL the objects that you clicked on (if some objects were 00229 // behind the closest one), but for this tutorial we just care about the one 00230 // in front. So, how do we get the depth value? Well, The selectionBuffer 00231 // holds it. For every object there is 4 values. The first value is 00232 // "the number of names in the name stack at the time of the event, followed 00233 // by the minimum and maximum depth values of all vertices that hit since the 00234 // previous event, then followed by the name stack contents, bottom name first." - MSDN 00235 // The only ones we care about are the minimum depth value (the second value) and 00236 // the object ID that was passed into glLoadName() (This is the fourth value). 00237 // So, [0 - 3] is the first object's data, [4 - 7] is the second object's data, etc... 00238 // Be carefull though, because if you are displaying 2D text in front, it will 00239 // always find that as the lowest object. So make sure you disable text when 00240 // rendering the screen for the object test. I use a flag for RenderScene(). 00241 // So, lets get the object with the lowest depth! 00242 00243 // Set the lowest depth to the first object to start it off. 00244 // 1 is the first object's minimum Z value. 00245 // We use an unsigned int so we don't get a warning with selectBuffer below. 00246 unsigned int lowestDepth = selectBuffer[1]; 00247 00248 // Set the selected object to the first object to start it off. 00249 // 3 is the first object's object ID we passed into glLoadName(). 00250 int selectedObject = selectBuffer[3]; 00251 00252 // Go through all of the objects found, but start at the second one 00253 // for(int i = 1; i < objectsFound; i++) 00254 // { 00255 // // Check if the current objects depth is lower than the current lowest 00256 // // Notice we times i by 4 (4 values for each object) and add 1 for the depth. 00257 // if(selectBuffer[(i * 4) + 1] < lowestDepth) 00258 // { 00259 // // Set the current lowest depth 00260 // lowestDepth = selectBuffer[(i * 4) + 1]; 00261 00262 // // Set the current object ID 00263 // selectedObject = selectBuffer[(i * 4) + 3]; 00264 // } 00265 // } 00266 00267 // Return the selected object 00268 return selectedObject; 00269 } 00270 00271 // We didn't click on any objects so return 0 00272 return 0; 00273 }


Public Member Functions
	RenderingHandler (WindowHandler window_handler, RadialLayout radial_layout, Graph *graph, GLuint screen_width, GLuint screen_height)
	~RenderingHandler ()
void	runMainLoop ()
void	handleKeyPressEvent (SDL_keysym *keysym)
void	renderScene ()
int	RetrieveObjectID (int x, int y)
Protected Member Functions
	RenderingHandler ()
Protected Attributes
WindowHandler *	window_handler_
	This holds the window handler.
RadialLayout *	radial_layout_
	This holds the Radial Layout for it's drawing.
Graph *	graph_
	The graph to render.
GLuint	screen_width_
	The screen width.
GLuint	screen_height_
	The screen height.
bool	is_animation_mode_active_
	Sets the animation mode.

RenderingHandler Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation