ApiDemo에서 CubeRotate를 이용해서 어플을 만들고있습니다.

실행시켜보시는분은 아시겠지만 처음 실행하면 하얀바탕화면에 큐브가 있죠.

그런데 Cube가 있는 하얀바탕 액티비티에 배경화면을 깔아버리니 배경에 Cube가 덮혀버리는 문제가 발생합니다.

다음은 큐브를 뿌려주는 렌더러 클래스입니다. 구글링으로 검색해보고 따라해봐도 어디가 문제인지 모르겠네요.

 private class CubeRenderer implements GLSurfaceView.Renderer {
         public CubeRenderer(boolean useTranslucentBackground) {
          mTranslucentBackground = useTranslucentBackground;
             mCube = new Cube();
         }public void onDrawFrame(GL10 gl) {
             /*
              * Usually, the first thing one might want to do is to clear
              * the screen. The most efficient way of doing this is to use
              * glClear().
              */

              gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

             /*
              * Now we're ready to draw some 3D objects
              */

             gl.glMatrixMode(GL10.GL_MODELVIEW);
             gl.glLoadIdentity();
             gl.glTranslatef(0, 0, -3.0f);
             gl.glRotatef(mAngleX, 0, 1, 0);
             gl.glRotatef(mAngleY, 1, 0, 0);

             gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
             gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

             mCube.draw(gl);
         }
         
         public int[] getConfigSpec() {        
             if (mTranslucentBackground) {      
                     // We want a depth buffer and an alpha buffer      
                     int[] configSpec = {      
                             EGL10.EGL_RED_SIZE,      8,      
                             EGL10.EGL_GREEN_SIZE,    8,      
                             EGL10.EGL_BLUE_SIZE,     8,      
                             EGL10.EGL_ALPHA_SIZE,    8,     
                             EGL10.EGL_DEPTH_SIZE,   16,      
                             EGL10.EGL_NONE      
                     };     
                     return configSpec;      
                 } else {      
                     // We want a depth buffer, don't care about the     
                     // details of the color buffer.      
                     int[] configSpec = {      
                             EGL10.EGL_DEPTH_SIZE,   16,      
                             EGL10.EGL_NONE      
                     };     
                     return configSpec;   
                 }
         }
      
         

         public void onSurfaceChanged(GL10 gl, int width, int height) {
              gl.glViewport(0, 0, width, height);

              /*
               * Set our projection matrix. This doesn't have to be done
               * each time we draw, but usually a new projection needs to
               * be set when the viewport is resized.
               */

              float ratio = (float) width / height;
              gl.glMatrixMode(GL10.GL_PROJECTION);
              gl.glLoadIdentity();
              gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
         }

         public void onSurfaceCreated(GL10 gl, EGLConfig config) {
             /*
              * By default, OpenGL enables features that improve quality
              * but reduce performance. One might want to tweak that
              * especially on software renderer.
              */
             gl.glDisable(GL10.GL_DITHER);

             /*
              * Some one-time OpenGL initialization can be made here
              * probably based on features of this particular context
              */
              gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,
                      GL10.GL_FASTEST);
              
              if (mTranslucentBackground) {
               
                  gl.glClearColor(0,0,0,0);
      
              } else {
      
                  gl.glClearColor(1,1,1,1);
      
              }

              gl.glClearColor(1,1,1,1);
              gl.glEnable(GL10.GL_CULL_FACE);
              gl.glShadeModel(GL10.GL_SMOOTH);
              gl.glEnable(GL10.GL_DEPTH_TEST);
         }
         private Cube mCube;
         public float mAngleX;
         public float mAngleY;
         private boolean mTranslucentBackground;
     }

     private final float TOUCH_SCALE_FACTOR = 180.0f / 320;
     private final float TRACKBALL_SCALE_FACTOR = 36.0f;
     private CubeRenderer mRenderer;
     private float mPreviousX;
     private float mPreviousY;
 }