title: Problem drawing a sphere in OPENGL ES
body: <p>I've been trying to create my own sphere using OpenGL ES and I followed the math described here <a href="http://www.math.montana.edu/frankw/ccp/multiworld/multipleIVP/spherical/learn.htm" rel="noreferrer">http://www.math.montana.edu/frankw/ccp/multiworld/multipleIVP/spherical/learn.htm</a></p>
  
  <p>However when I draw the sphere (just the vertices), just half of the sphere is been drawn. Can you please point to me what is the exact problem in the code that I am giving below:</p>
  
  <pre><code>public class Sphere {
  
      static private FloatBuffer sphereVertex;
      static private FloatBuffer sphereNormal;
      static float sphere_parms[]=new float[3];
  
      double mRaduis;
      double mStep;
      float mVertices[];
      private static double DEG = Math.PI/180;
      int mPoints;
  
      /**
       * The value of step will define the size of each facet as well as the number of facets
       *  
       * @param radius
       * @param step
       */
  
      public Sphere( float radius, double step) {
          this.mRaduis = radius;
          this.mStep = step;
          sphereVertex = FloatBuffer.allocate(40000);
          mPoints = build();
          Log.d("ALIS CHECK!!!!!!", " COUNT:" + mPoints);
      }
  
      public void draw(GL10 gl) {
          gl.glFrontFace(GL10.GL_CW);
          gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
          gl.glVertexPointer(3, GL10.GL_FLOAT, 0, sphereVertex);
  
          gl.glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
          gl.glDrawArrays(GL10.GL_POINTS, 0, mPoints);
          gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
      }
  
      private int build() {
  
          /**
           * x = p * sin(phi) * cos(theta)
           * y = p * sin(phi) * sin(theta)
           * z = p * cos(phi)
           */
          double dTheta = mStep * DEG;
          double dPhi = dTheta;
          int points = 0;
  
          for(double phi = -(Math.PI/2); phi &lt;= Math.PI/2; phi+=dPhi) {
              //for each stage calculating the slices
              for(double theta = 0.0; theta &lt;= (Math.PI * 2); theta+=dTheta) {
                  sphereVertex.put((float) (mRaduis * Math.sin(phi) * Math.cos(theta)) );
                  sphereVertex.put((float) (mRaduis * Math.sin(phi) * Math.sin(theta)) );
                  sphereVertex.put((float) (mRaduis * Math.cos(phi)) );
                  points++;
  
              }
          }
          sphereVertex.position(0);
          return points;
      }
  }
  </code></pre>
  
  <p>Also here is my renderer class:</p>
  
  <pre><code>/**
   * These values are used to rotate the image by a certain value
   */
  private float xRot;
  private float yRot;
  
  public void setxRot(float xRot) {
      this.xRot += xRot;
  }
  
  public void setyRot(float yRot) {
      this.yRot += yRot;
  }
  
  public GLViewRenderer(Context ctx) {
      //initialize our 3D triangle here
      mSphere = new Sphere(1, 25);
      //Initializing the rate counter object
      //This will help us in calculating the frames per second
      fpsCalculator = new RateCounter(TAG);
      fpsCalculator.start();
  }
  
  public void onSurfaceCreated(GL10 gl, EGLConfig config) {
      //initialize all the things required for openGL configurations
      gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);    
  
      gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST); 
  }
  
  public void onDrawFrame(GL10 gl) {
      if(fpsCalculator != null) 
          fpsCalculator.countOnce();
  
      //write the drawing code needed
      gl.glClear(GL10.GL_COLOR_BUFFER_BIT);   
      gl.glLoadIdentity();
  
      /**
       * Change this value in z if you want to see the image zoomed in
       */
      gl.glTranslatef(0.0f, 0.0f, -5.0f); 
  
      gl.glRotatef(xRot, 0.0f, 1.0f, 0.0f);
      gl.glRotatef(yRot, 1.0f, 0.0f, 0.0f);
      mSphere.draw(gl);
  }
  
  public void onSurfaceChanged(GL10 gl, int width, int height) {
      if(height == 0) {                       
          height = 1;                         
      }
  
      gl.glViewport(0, 0, width, height); 
      gl.glMatrixMode(GL10.GL_PROJECTION);
      gl.glLoadIdentity();                
  
      //Calculate The Aspect Ratio Of The Window
      GLU.gluPerspective(gl, 45.0f, (float)width / (float)height, 0.1f, 100.0f);
  
      gl.glMatrixMode(GL10.GL_MODELVIEW);     //Select The Modelview Matrix
      gl.glLoadIdentity();                    //Reset The Modelview Matrix
  }
  
  /**
   * Used to stop the FPS counter
   */
  public void pause() {
      if(fpsCalculator != null)
          fpsCalculator.stop();
  }
  </code></pre>
  
  <p>}</p>
  
  <p>I'd really appreciate some help on this.</p>
  
  <p>P.S: I tried changing CW to CCW still no luck
  Thanks</p>