void RenderScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); // Reset The matrix
// Position the camera
g_Camera.Look();
// Each frame we calculate the new frustum. In reality you only need to
// calculate the frustum when we move the camera.
g_Frustum.CalculateFrustum();
// Initialize the total node count that is being draw per frame
g_TotalNodesDrawn = 0;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Here we draw the octree, starting with the root node and recursing down each node.
// This time, we pass in the root node and just the original world model. You could
// just store the world in the root node and not have to keep the original data around.
// This is up to you. I like this way better because it's easy, though it could be
// more error prone.
g_Octree.DrawOctree(&g_Octree, &g_World);
// Render the cubed nodes to visualize the octree (in wire frame mode)
if( g_bDisplayNodes )
g_Debug.RenderDebugLines();
// Create a buffer to store the octree information for the title bar
static char strBuffer[255] = {0};
// Display in window mode the current subdivision information. We now display the
// max triangles per node, the max level of subdivision, total end nodes, current nodes drawn
// and frames per second we are receiving.
sprintf(strBuffer, "Triangles: %d Subdivisions: %d EndNodes: %d NodesDraw: %d FPS: %s",
g_MaxTriangles, g_MaxSubdivisions, g_EndNodeCount, g_TotalNodesDrawn, g_strFrameRate);
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Set our window title bar to the subdivision information
SetWindowText(g_hWnd, strBuffer);
// Swap the backbuffers to the foreground
SwapBuffers(g_hDC);
}
void RenderScene()
{
int i = 0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset The matrix
// Tell OpenGL where to look from our camera info
g_Camera.Look();
// Calculate our frustum to check the world data again for PVS and Portal Rendering
g_Frustum.CalculateFrustum();
// Render the level to the screen
g_Level.RenderLevel(g_Camera.Position());
// Swap the backbuffers to the foreground
SwapBuffers(g_hDC);
}
void RenderScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset The matrix
// Give OpenGL our camera position
g_Camera.Look();
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Each frame we calculate the new frustum. In reality you only need to
// calculate the frustum when we move the camera.
g_Frustum.CalculateFrustum();
// Initialize the total node count that is being draw per frame
g_TotalNodesDrawn = 0;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Here we draw the octree, starting with the root node and recursing down each node.
// When we get to each of the end nodes we will draw the vertices assigned to them.
g_Octree.DrawOctree(&g_Octree);
// Render the cube'd nodes to visualize the octree (in wire frame mode)
g_Debug.RenderDebugLines();
SwapBuffers(g_hDC); // Swap the backbuffers to the foreground
char strBuffer[255] = {0}; // Create a character buffer
// To view our octree information I set the window's title bar to the some basic
// information such as the max triangles per node, the max subdivisions,
// total end nodes and the total drawn end nodes that are currently in the frustum.
// Display in window mode the current subdivision information
sprintf(strBuffer, "MaxTriangles: %d MaxSubdivisions: %d TotalEndNodes: %d TotalNodesDraw: %d",
g_MaxTriangles, g_MaxSubdivisions, g_EndNodeCount, g_TotalNodesDrawn);
// Set our window title bar to the subdivision data
SetWindowText(g_hWnd, strBuffer);
}
void RenderScene()
{
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
int spheresRendered = 0; // This will hold how many spheres are being rendered
char strText[255]= {0}; // This will hold the window title info
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset The matrix
// Give OpenGL our camera position
g_Camera.Look();
// We don't need to calculate this every frame, only when the camera view changes.
// I just did it every frame anyway. In this case it isn't a big deal.
g_Frustum.CalculateFrustum(); // Calculate the frustum each frame
// If you are unfamiliar with Quadrics, see the tutorial on Quadrics at www.GameTutorials.com.
// They basically allow you to draw circles and cylinders fast and easily.
GLUquadricObj *pObj = gluNewQuadric(); // Get a Quadric off the stack
// Loop through all of our allowed spheres and render them to the screen if in the frustum.
for(int i = 0; i < g_MaxSpheres; i++) // g_MaxSpheres varies.
{
g_Spheres[i].zPos += SPHERE_SPEED; // Increase the Z position of the sphere.
// Below we check if the sphere needs to be draw or not. If g_bIgnoreFrustum is TRUE,
// it draws it regardless (which is SLOOOooOoW). We just pass in the (X, Y, Z)
// and the radius of the sphere to find out if it is inside of the frustum.
if(g_bIgnoreFrustum || g_Frustum.SphereInFrustum(g_Spheres[i].xPos, g_Spheres[i].yPos, g_Spheres[i].zPos, g_Spheres[i].radius))
{
// Set the sphere's color
glColor3ub(g_Spheres[i].r, g_Spheres[i].g, g_Spheres[i].b);
// Create a new scope before positiong the sphere so we don't effect the other spheres.
glPushMatrix();
// Position the sphere on the screen at it's XYZ position.
glTranslatef(g_Spheres[i].xPos, g_Spheres[i].yPos, g_Spheres[i].zPos);
// Create a sphere with the desired radius chosen in the beginning.
gluSphere(pObj, g_Spheres[i].radius, 20, 20); // Draw the sphere with a radius of 0.5
glPopMatrix(); // Close the scope of this matrix
spheresRendered++; // Increase the amount of spheres rendered
}
// Here we check to see if the sphere went out of our range,
// If so, we need to set it back again with a new random position.
if(g_Spheres[i].zPos > MAX_DISTANCE) {
// Give the sphere a new random position back in the beginning.
g_Spheres[i].xPos = (rand() % (MAX_DISTANCE * 10)) * 0.1f;
g_Spheres[i].yPos = (rand() % (MAX_DISTANCE * 10)) * 0.1f;
g_Spheres[i].zPos = -MAX_DISTANCE; // Send it to the back again.
// Give a 50/50 chance for the sphere to be to the left/right or above/below the XY axis.
// This is because we are centered at the origin
if(rand() % 2) g_Spheres[i].xPos = -g_Spheres[i].xPos;
if(rand() % 2) g_Spheres[i].yPos = -g_Spheres[i].yPos;
}
}
// Since I didn't want to add more code for a rendered font, I decided to just
// render the frustum information in the title bar of the window.
// The information tells you how many spheres were rendered and out of how many.
// Use +/- to increase and decrease the max spheres tested.
sprintf(strText, "www.GameTutorials.com - Spheres Rendered: %d / %d", spheresRendered, g_MaxSpheres);
SetWindowText(g_hWnd, strText); // Change the window title bar
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
SwapBuffers(g_hDC); // Swap the backbuffers to the foreground
gluDeleteQuadric(pObj); // Free the Quadric
}
