GLfloat *sphereColors, *sphereNormals, *sphereVertices;
GLuint *sphereIndices;
int count;


// from last class...  
GLuint CreateSphereDisplayList( void )
{
   GLuint sphereListID = glGenLists(1);
   glNewList( sphereListID, GL_COMPILE );
   CreateSphere( 1.0, 10 );  
   glEndList( );
   return sphereListID;
}

// Creates and populates a vertex array containing a sphere
//    (Note this is NOT the most efficient vertex array, since
//    duplicated vertices are duplicated, rather than storing
//    once and repeatedly indexing the same array!)
void CreateSphereArray(double r,int n)
{
   int i,j;
   double theta1,theta2,theta3;
   double e[3],p[3];
   int arrayIndex = 0;

   if (r < 0) return;
   if (n < 4) return;

   sphereColors =   (GLfloat *)malloc( 4 * ((n/2) * (n+1) * 2) * sizeof(GLfloat) );
   sphereNormals =  (GLfloat *)malloc( 3 * ((n/2) * (n+1) * 2) * sizeof(GLfloat) );
   sphereVertices = (GLfloat *)malloc( 3 * ((n/2) * (n+1) * 2) * sizeof(GLfloat) );

   for (j=0;j<n/2;j++) {
      theta1 = j * 2 * M_PI / n - M_PI/2;
      theta2 = (j + 1) * 2 * M_PI / n - M_PI/2;

      for (i=0;i<=n;i++) {
         theta3 = i * 2 * M_PI / n;

         e[0] = -cos(theta2) * cos(theta3); e[1] = -sin(theta2); e[2] = -cos(theta2) * sin(theta3);
         p[0] = r * e[0]; p[1] = r * e[1]; p[2] = r * e[2];

	 sphereNormals[3*arrayIndex+0] = e[0];        // glNormal3f( e[0],e[1],e[2] );
         sphereNormals[3*arrayIndex+1] = e[1];        //  
         sphereNormals[3*arrayIndex+2] = e[2];        //

         sphereColors[4*arrayIndex+0] = 0.5*e[0]+0.5; // glColor4d( 0.5*e[0]+0.5,
         sphereColors[4*arrayIndex+1] = 0.5*e[1]+0.5; //            0.5*e[1]+0.5,
         sphereColors[4*arrayIndex+2] = 0.5*e[2]+0.5; //            0.5*e[2]+0.5, 
         sphereColors[4*arrayIndex+3] = r/sqrt(3.0);  //            r/sqrt(3.0) );

         sphereVertices[3*arrayIndex+0] = p[0];       // glVertex3d(p[0],p[1],p[2]);       
         sphereVertices[3*arrayIndex+1] = p[1];       //
         sphereVertices[3*arrayIndex+2] = p[2];       //
         arrayIndex++;

         e[0] = -cos(theta1) * cos(theta3); e[1] = -sin(theta1); e[2] = -cos(theta1) * sin(theta3);
         p[0] = r * e[0]; p[1] = r * e[1]; p[2] = r * e[2];

	 sphereNormals[3*arrayIndex+0] = e[0];        // glNormal3f( e[0],e[1],e[2] );
         sphereNormals[3*arrayIndex+1] = e[1];        //  
         sphereNormals[3*arrayIndex+2] = e[2];        //

         sphereColors[4*arrayIndex+0] = 0.5*e[0]+0.5; // glColor4d( 0.5*e[0]+0.5,
         sphereColors[4*arrayIndex+1] = 0.5*e[1]+0.5; //            0.5*e[1]+0.5,
         sphereColors[4*arrayIndex+2] = 0.5*e[2]+0.5; //            0.5*e[2]+0.5, 
         sphereColors[4*arrayIndex+3] = r/sqrt(3.0);  //            r/sqrt(3.0) );

         sphereVertices[3*arrayIndex+0] = p[0];       // glVertex3d(p[0],p[1],p[2]);       
         sphereVertices[3*arrayIndex+1] = p[1];       //
         sphereVertices[3*arrayIndex+2] = p[2];       //
         arrayIndex++;
      }
   }
   count = arrayIndex;
}


void display( void )
{

   // ... standard setup stuff, like clear screen...

   // Setup the location of the sphere
   // Setup the color of the sphere.

   if (usingDisplayList)
       glCallList( sphereListID );
   else if (usingVertexArray) {
       glEnableClientState( GL_COLOR_ARRAY );
       glEnableClientState( GL_VERTEX_ARRAY );
       glEnableClientState( GL_NORMAL_ARRAY );

       glColorPointer( 4, GL_FLOAT, 0, sphereColors );
       glNormalPointer( 3, GL_FLOAT, 0, sphereNormals );
       glVertexPointer( 3, GL_FLOAT, 0, sphereVertices );

       glDrawArrays( GL_TRIANGLE_STRIP, 0, count);
       glDisableClientState( GL_COLOR_ARRAY );
       glDisableClientState( GL_VERTEX_ARRAY );
       glDisableClientState( GL_NORMAL_ARRAY );
   } else
       CreateSphere( 1.0, 10 );

   // ... do standard per-frame cleanup ...
  
}