void Sphere::BuildSimpleSphere()
{
	float phiStep = PI / m_NumStacks;

	// Don't count the poles as rings.
	int numRings = m_NumStacks - 1;

	// Compute Vertices for each stack ring.
	for( int i = 1; i <= numRings; ++i )
	{
		float phi = i * phiStep;
		
		// Vertices of ring
		float thetaStep = 2.0f * PI / m_NumSlices;
		for( int j = 0; j <= m_NumSlices; ++j )
		{
			float theta = j * thetaStep;

			// Need to possibly fix up the normal and texture co-ords because of  - (m_Radius/2) due to centering the sphere
			NiPoint3 pos;
			pos.x = (m_Radius * sinf(phi) * cosf(theta)) - (m_Radius/2);
			pos.y = (m_Radius * cosf(phi)) - (m_Radius/2);
			pos.z = (m_Radius * sinf(phi) * sinf(theta));

			NiPoint3 normal = pos;
			normal.UnitizeVector(normal);

			NiPoint2 uv;
			uv.x = theta / (2.0f * PI);
			uv.y = phi / PI;

			m_Vertices.push_back(pos);
			m_Normals.push_back(normal);
			m_UVs.push_back(uv);
		}
	}

	// Poles: note that there will be texture coordinate distortion
	m_Vertices.push_back( NiPoint3((0.0f) - (m_Radius/2), (-m_Radius) - (m_Radius/2), 0.0f) );
	m_Vertices.push_back( NiPoint3((0.0f) - (m_Radius/2), (m_Radius) - (m_Radius/2), 0.0f) );

	m_Normals.push_back( NiPoint3(0.0f, -1.0f, 0.0f) );
	m_Normals.push_back( NiPoint3(0.0f, 1.0f, 0.0f) );

	m_UVs.push_back( NiPoint2(0.0f, 1.0f) );
	m_UVs.push_back( NiPoint2(0.0f, 0.0f) );

	int northPoleIndex = (int)m_Vertices.size() - 1;
	int southPoleIndex = (int)m_Vertices.size() - 2;

	int numRingVertices = m_NumSlices + 1;

	// Compute indices for inner stacks (not connected to poles).
	for(int i = 0; i < m_NumStacks - 2; ++i)
	{
		for(int j = 0; j < m_NumSlices; ++j)
		{
			m_Indices.push_back(i * numRingVertices + j);
			m_Indices.push_back(i * numRingVertices + j + 1);
			m_Indices.push_back((i + 1) * numRingVertices + j);

			m_Indices.push_back((i + 1)  *numRingVertices + j);
			m_Indices.push_back(i * numRingVertices + j + 1);
			m_Indices.push_back((i + 1)  *numRingVertices + j + 1);
		}
	}

	// Compute indices for top stack.  The top stack was written 
	// first to the vertex buffer.
	for(int i = 0; i < m_NumSlices; ++i)
	{
		m_Indices.push_back(northPoleIndex);
		m_Indices.push_back(i  +1);
		m_Indices.push_back(i);
	}

	// Compute indices for bottom stack.  The bottom stack was written
	// last to the vertex buffer, so we need to offset to the index
	// of first vertex in the last ring.
	int baseIndex = (numRings - 1) * numRingVertices;
	for(UINT i = 0; i < m_NumSlices; ++i)
	{
		m_Indices.push_back(southPoleIndex);
		m_Indices.push_back(baseIndex + i);
		m_Indices.push_back(baseIndex + i + 1);
	}
}