Refactor drawing desktop.

remoting/android/java/src/org/chromium/chromoting/CardboardDesktopRenderer.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chromoting;
 
 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.Point;
 import android.graphics.PointF;
 import android.opengl.GLES20;
 import android.opengl.Matrix;
 
 import com.google.vrtoolkit.cardboard.CardboardView;
 import com.google.vrtoolkit.cardboard.Eye;
 import com.google.vrtoolkit.cardboard.HeadTransform;
 import com.google.vrtoolkit.cardboard.Viewport;
 
 import org.chromium.base.Log;
@@ skipping 20 matching lines @@
     private static final float DESKTOP_POSITION_Y = 0.0f;
     private static final float DESKTOP_POSITION_Z = -2.0f;
     private static final float HALF_SKYBOX_SIZE = 100.0f;
     private static final float VIEW_POSITION_MIN = -1.0f;
     private static final float VIEW_POSITION_MAX = 3.0f;
 
     // Allows user to click even when looking outside the desktop
     // but within edge margin.
     private static final float EDGE_MARGIN = 0.1f;
 
-    // Fix the desktop height and adjust width accordingly.
-    private static final float HALF_DESKTOP_HEIGHT = 1.0f;
-
     // Distance to move camera each time.
     private static final float CAMERA_MOTION_STEP = 0.5f;
 
-    private static final FloatBuffer DESKTOP_TEXTURE_COORDINATES = makeFloatBuffer(new float[] {
-            // Texture coordinate data.
-            0.0f, 0.0f,
-            0.0f, 1.0f,
-            1.0f, 0.0f,
-            0.0f, 1.0f,
-            1.0f, 1.0f,
-            1.0f, 0.0f
-    });
-
     private static final FloatBuffer SKYBOX_POSITION_COORDINATES = makeFloatBuffer(new float[] {
             -HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  // (0) Top-left near
             HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  // (1) Top-right near
             -HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  // (2) Bottom-left near
             HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE,  // (3) Bottom-right near
             -HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE,  // (4) Top-left far
             HALF_SKYBOX_SIZE,  HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE,  // (5) Top-right far
             -HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE,  // (6) Bottom-left far
             HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE, -HALF_SKYBOX_SIZE  // (7) Bottom-right far
     });
@@ skipping 17 matching lines @@
 
             // Top
             5, 1, 4,
             4, 1, 0,
 
             // Bottom
             6, 2, 7,
             7, 2, 3
     });
 
-    private static final String DESKTOP_VERTEX_SHADER =
-            "uniform mat4 u_CombinedMatrix;"
-            + "attribute vec4 a_Position;"
-            + "attribute vec2 a_TexCoordinate;"
-            + "varying vec2 v_TexCoordinate;"
-            + "void main() {"
-            + "  v_TexCoordinate = a_TexCoordinate;"
-            + "  gl_Position = u_CombinedMatrix * a_Position;"
-            + "}";
-
-    private static final String DESKTOP_FRAGMENT_SHADER =
-            "precision highp float;"
-            + "uniform sampler2D u_Texture;"
-            + "varying vec2 v_TexCoordinate;"
-            + "const float borderWidth = 0.002;"
-            + "void main() {"
-            + "  if (v_TexCoordinate.x > (1.0 - borderWidth) || v_TexCoordinate.x < borderWidth"
-            + "      || v_TexCoordinate.y > (1.0 - borderWidth)"
-            + "      || v_TexCoordinate.y < borderWidth) {"
-            + "    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);"
-            + "  } else {"
-            + "    gl_FragColor = texture2D(u_Texture, v_TexCoordinate);"
-            + "  }"
-            + "}";
-
     private static final String SKYBOX_VERTEX_SHADER =
             "uniform mat4 u_CombinedMatrix;"
             + "attribute vec3 a_Position;"
             + "varying vec3 v_Position;"
             + "void main() {"
             + "  v_Position = a_Position;"
             // Make sure to convert from the right-handed coordinate system of the
             // world to the left-handed coordinate system of the cube map, otherwise,
             // our cube map will still work but everything will be flipped.
             + "  v_Position.z = -v_Position.z;"
@@ skipping 20 matching lines @@
         "https://dl.google.com/chrome-remote-desktop/android-assets/room_back.png",
         "https://dl.google.com/chrome-remote-desktop/android-assets/room_front.png"
     };
 
     private static final String[] SKYBOX_IMAGE_NAMES = new String[] {
         "skybox_left", "skybox_right", "skybox_bottom", "skybox_top", "skybox_back", "skybox_front"
     };
 
     private final Activity mActivity;
 
-    private float mHalfDesktopWidth;
     private float mCameraPosition;
 
     // Lock to allow multithreaded access to mCameraPosition.
     private Object mCameraPositionLock = new Object();
 
     private float[] mCameraMatrix;
     private float[] mViewMatrix;
     private float[] mProjectionMatrix;
 
     // Make matrix member variable to avoid unnecessary initialization.
     private float[] mDesktopModelMatrix;
     private float[] mDesktopCombinedMatrix;
     private float[] mEyePointModelMatrix;
     private float[] mEyePointCombinedMatrix;
     private float[] mSkyboxModelMatrix;
     private float[] mSkyboxCombinedMatrix;
 
     // Direction that user is looking towards.
     private float[] mForwardVector;
 
     // Eye position in desktop.
     private float[] mEyePositionVector;
 
-    private int mDesktopCombinedMatrixHandle;
-    private int mPositionHandle;
-    private int mTextureDataHandle;
-    private int mTextureUniformHandle;
-    private int mTextureCoordinateHandle;
-    private int mProgramHandle;
-    private int mDesktopVertexShaderHandle;
-    private int mDesktopFragmentShaderHandle;
     private int mSkyboxVertexShaderHandle;
     private int mSkyboxFragmentShaderHandle;
     private int mSkyboxProgramHandle;
     private int mSkyboxPositionHandle;
     private int mSkyboxCombinedMatrixHandle;
     private int mSkyboxTextureUnitHandle;
     private int mSkyboxTextureDataHandle;
+    private CardboardActivityDesktop mDesktop;
     private CardboardActivityEyePoint mEyePoint;
 
     // Flag to indicate whether reload the desktop texture or not.
     private boolean mReloadTexture;
 
     /** Lock to allow multithreaded access to mReloadTexture. */
     private Object mReloadTextureLock = new Object();
 
     // Lock for eye position related operations.
-    // This protects access to mEyePositionVector as well as mDesktop{Height/Width}Pixels.
+    // This protects access to mEyePositionVector.
     private Object mEyePositionLock = new Object();
 
-    private int mDesktopHeightPixels;
-    private int mDesktopWidthPixels;
-
-    private FloatBuffer mDesktopCoordinates;
-
     // Flag to signal that the skybox images are fully decoded and should be loaded
     // into the OpenGL textures.
     private boolean mLoadSkyboxImagesTexture;
 
     // Lock to allow multithreaded access to mLoadSkyboxImagesTexture.
     private Object mLoadSkyboxImagesTextureLock = new Object();
 
     private ChromotingDownloadManager mDownloadManager;
 
     public CardboardDesktopRenderer(Activity activity) {
@@ skipping 44 matching lines @@
     public void onSurfaceCreated(EGLConfig config) {
         // Set the background clear color to black.
         GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
         // Use culling to remove back faces.
         GLES20.glEnable(GLES20.GL_CULL_FACE);
 
         // Enable depth testing.
         GLES20.glEnable(GLES20.GL_DEPTH_TEST);
 
-        // Set handles for desktop drawing.
-        mDesktopVertexShaderHandle =
-                ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, DESKTOP_VERTEX_SHADER);
-        mDesktopFragmentShaderHandle =
-                ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, DESKTOP_FRAGMENT_SHADER);
-        mProgramHandle = ShaderHelper.createAndLinkProgram(mDesktopVertexShaderHandle,
-                mDesktopFragmentShaderHandle, new String[] {"a_Position", "a_TexCoordinate"});
-        mDesktopCombinedMatrixHandle =
-                GLES20.glGetUniformLocation(mProgramHandle, "u_CombinedMatrix");
-        mTextureUniformHandle = GLES20.glGetUniformLocation(mProgramHandle, "u_Texture");
-        mPositionHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_Position");
-        mTextureCoordinateHandle = GLES20.glGetAttribLocation(mProgramHandle, "a_TexCoordinate");
-        mTextureDataHandle = TextureHelper.createTextureHandle();
-
         // Set handlers for skybox drawing.
         GLES20.glEnable(GLES20.GL_TEXTURE_CUBE_MAP);
         mSkyboxVertexShaderHandle =
                 ShaderHelper.compileShader(GLES20.GL_VERTEX_SHADER, SKYBOX_VERTEX_SHADER);
         mSkyboxFragmentShaderHandle =
                 ShaderHelper.compileShader(GLES20.GL_FRAGMENT_SHADER, SKYBOX_FRAGMENT_SHADER);
         mSkyboxProgramHandle = ShaderHelper.createAndLinkProgram(mSkyboxVertexShaderHandle,
                 mSkyboxFragmentShaderHandle,
                 new String[] {"a_Position", "u_CombinedMatrix", "u_TextureUnit"});
         mSkyboxPositionHandle =
                 GLES20.glGetAttribLocation(mSkyboxProgramHandle, "a_Position");
         mSkyboxCombinedMatrixHandle =
                 GLES20.glGetUniformLocation(mSkyboxProgramHandle, "u_CombinedMatrix");
         mSkyboxTextureUnitHandle =
                 GLES20.glGetUniformLocation(mSkyboxProgramHandle, "u_TextureUnit");
         mSkyboxTextureDataHandle = TextureHelper.createTextureHandle();
 
+        mDesktop = new CardboardActivityDesktop();
         mEyePoint = new CardboardActivityEyePoint();
     }
 
     @Override
     public void onSurfaceChanged(int width, int height) {
     }
 
     @Override
     public void onNewFrame(HeadTransform headTransform) {
         // Position the eye at the origin.
@@ skipping 11 matching lines @@
 
         // Set our up vector. This is where our head would be pointing were we holding the camera.
         float upX = 0.0f;
         float upY = 1.0f;
         float upZ = 0.0f;
 
         Matrix.setLookAtM(mCameraMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
 
         headTransform.getForwardVector(mForwardVector, 0);
         getLookingPosition();
-        maybeLoadTexture(mTextureDataHandle);
+        maybeLoadDesktopTexture();
         maybeLoadCubeMapAndCleanImages(mSkyboxTextureDataHandle);
     }
 
     @Override
     public void onDrawEye(Eye eye) {
         GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
 
         // Apply the eye transformation to the camera.
         Matrix.multiplyMM(mViewMatrix, 0, eye.getEyeView(), 0, mCameraMatrix, 0);
 
         mProjectionMatrix = eye.getPerspective(Z_NEAR, Z_FAR);
 
         drawSkybox();
         drawDesktop();
         drawEyePoint();
     }
 
     @Override
     public void onRendererShutdown() {
-        GLES20.glDeleteShader(mDesktopVertexShaderHandle);
-        GLES20.glDeleteShader(mDesktopFragmentShaderHandle);
+        mDesktop.cleanup();
         mEyePoint.cleanup();
         GLES20.glDeleteShader(mSkyboxVertexShaderHandle);
         GLES20.glDeleteShader(mSkyboxFragmentShaderHandle);
-        GLES20.glDeleteTextures(1, new int[] {mTextureDataHandle}, 0);
         GLES20.glDeleteTextures(1, new int[] {mSkyboxTextureDataHandle}, 0);
         mActivity.runOnUiThread(new Runnable() {
             public void run() {
                 mDownloadManager.close();
             }
         });
     }
 
     @Override
     public void onFinishFrame(Viewport viewport) {
     }
 
     private void drawDesktop() {
-        GLES20.glUseProgram(mProgramHandle);
+        if (!mDesktop.hasVideoFrame()) {
+            // This can happen if the client is connected, but a complete
+            // video frame has not yet been decoded.
+            return;
+        }
 
-         // Translate the desktop model.
+
         Matrix.setIdentityM(mDesktopModelMatrix, 0);
         Matrix.translateM(mDesktopModelMatrix, 0, DESKTOP_POSITION_X,
                 DESKTOP_POSITION_Y, DESKTOP_POSITION_Z);
 
         // Pass in Model View Matrix and Model View Project Matrix.
         Matrix.multiplyMM(mDesktopCombinedMatrix, 0, mViewMatrix, 0, mDesktopModelMatrix, 0);
         Matrix.multiplyMM(mDesktopCombinedMatrix, 0, mProjectionMatrix,
                 0, mDesktopCombinedMatrix, 0);
+        mDesktop.setCombinedMatrix(mDesktopCombinedMatrix);
 
-        // Pass in model view project matrix.
-        GLES20.glUniformMatrix4fv(mDesktopCombinedMatrixHandle, 1, false,
-                mDesktopCombinedMatrix, 0);
-
-        if (mDesktopCoordinates == null) {
-            // This can happen if the client is connected, but a complete video frame has not yet
-            // been decoded.
-            return;
-        }
-        // Pass in the desktop position.
-        GLES20.glVertexAttribPointer(mPositionHandle, POSITION_DATA_SIZE, GLES20.GL_FLOAT, false,
-                0, mDesktopCoordinates);
-        GLES20.glEnableVertexAttribArray(mPositionHandle);
-
-        // Pass in texture coordinate.
-        GLES20.glVertexAttribPointer(mTextureCoordinateHandle, TEXTURE_COORDINATE_DATA_SIZE,
-                GLES20.GL_FLOAT, false, 0, DESKTOP_TEXTURE_COORDINATES);
-        GLES20.glEnableVertexAttribArray(mTextureCoordinateHandle);
-
-        // Pass in texture data.
-        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
-        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureDataHandle);
-        GLES20.glUniform1i(mTextureUniformHandle, 0);
-
-        // Draw the desktop.
-        int totalPointNumber = 6;
-        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, totalPointNumber);
+        mDesktop.draw();
     }
 
     private void drawEyePoint() {
         if (!isLookingAtDesktop()) {
             return;
         }
 
-        float eyePointX = clamp(mEyePositionVector[0], -mHalfDesktopWidth,
-                mHalfDesktopWidth);
-        float eyePointY = clamp(mEyePositionVector[1], -HALF_DESKTOP_HEIGHT,
-                HALF_DESKTOP_HEIGHT);
+        float eyePointX = clamp(mEyePositionVector[0], -mDesktop.getHalfWidth(),
+                mDesktop.getHalfWidth());
+        float eyePointY = clamp(mEyePositionVector[1], -mDesktop.getHalfHeight(),
+                mDesktop.getHalfHeight());
         Matrix.setIdentityM(mEyePointModelMatrix, 0);
         Matrix.translateM(mEyePointModelMatrix, 0, -eyePointX, -eyePointY,
                 DESKTOP_POSITION_Z);
         Matrix.multiplyMM(mEyePointCombinedMatrix, 0, mViewMatrix, 0, mEyePointModelMatrix, 0);
         Matrix.multiplyMM(mEyePointCombinedMatrix, 0, mProjectionMatrix,
                 0, mEyePointCombinedMatrix, 0);
 
         mEyePoint.setCombinedMatrix(mEyePointCombinedMatrix);
         mEyePoint.draw();
     }
@@ skipping 19 matching lines @@
         GLES20.glDrawElements(GLES20.GL_TRIANGLES, 36, GLES20.GL_UNSIGNED_BYTE,
                 SKYBOX_INDICES_BYTE_BUFFER);
     }
 
     /**
      * Returns coordinates in units of pixels in the desktop bitmap.
      * This can be called on any thread.
      */
     public PointF getMouseCoordinates() {
         PointF result = new PointF();
+        Point shapePixels = mDesktop.getShapePixels();
+        int heightPixels = shapePixels.x;
+        int widthPixels = shapePixels.y;
+
         synchronized (mEyePositionLock) {
             // Due to the coordinate direction, we only have to inverse x.
-            result.x = (-mEyePositionVector[0] + mHalfDesktopWidth)
-                    / (2 * mHalfDesktopWidth) * mDesktopWidthPixels;
-            result.y = (mEyePositionVector[1] + HALF_DESKTOP_HEIGHT)
-                    / (2 * HALF_DESKTOP_HEIGHT) * mDesktopHeightPixels;
-            result.x = clamp(result.x, 0, mDesktopWidthPixels);
-            result.y = clamp(result.y, 0, mDesktopHeightPixels);
+            result.x = (-mEyePositionVector[0] + mDesktop.getHalfWidth())
+                    / (2 * mDesktop.getHalfWidth()) * widthPixels;
+            result.y = (mEyePositionVector[1] + mDesktop.getHalfHeight())
+                    / (2 * mDesktop.getHalfHeight()) * heightPixels;
+            result.x = clamp(result.x, 0, widthPixels);
+            result.y = clamp(result.y, 0, heightPixels);
         }
         return result;
     }
 
     /**
      * Returns the passed in value if it resides within the specified range (inclusive).  If not,
      * it will return the closest boundary from the range.  The ordering of the boundary values
      * does not matter.
      *
      * @param value The value to be compared against the range.
@@ skipping 37 matching lines @@
             }
         }
     }
 
     /**
      * Return true if user is looking at the desktop.
      * This method can be called on any thread.
      */
     public boolean isLookingAtDesktop() {
         synchronized (mEyePositionLock) {
-            return Math.abs(mEyePositionVector[0]) <= (mHalfDesktopWidth + EDGE_MARGIN)
-                && Math.abs(mEyePositionVector[1]) <= (HALF_DESKTOP_HEIGHT + EDGE_MARGIN);
+            return Math.abs(mEyePositionVector[0]) <= (mDesktop.getHalfWidth() + EDGE_MARGIN)
+                && Math.abs(mEyePositionVector[1]) <= (mDesktop.getHalfHeight() + EDGE_MARGIN);
         }
     }
 
     /**
      * Return true if user is looking at the space to the left of the desktop.
      * This method can be called on any thread.
      */
     public boolean isLookingLeftOfDesktop() {
         synchronized (mEyePositionLock) {
-            return mEyePositionVector[0] >= (mHalfDesktopWidth + EDGE_MARGIN);
+            return mEyePositionVector[0] >= (mDesktop.getHalfWidth() + EDGE_MARGIN);
         }
     }
 
     /**
      * Return true if user is looking at the space to the right of the desktop.
      * This method can be called on any thread.
      */
     public boolean isLookingRightOfDesktop() {
         synchronized (mEyePositionLock) {
-            return mEyePositionVector[0] <= -(mHalfDesktopWidth + EDGE_MARGIN);
+            return mEyePositionVector[0] <= -(mDesktop.getHalfWidth() + EDGE_MARGIN);
         }
     }
 
     /**
      * Return true if user is looking at the space above the desktop.
      * This method can be called on any thread.
      */
     public boolean isLookingAboveDesktop() {
         synchronized (mEyePositionLock) {
-            return mEyePositionVector[1] <= -(HALF_DESKTOP_HEIGHT + EDGE_MARGIN);
+            return mEyePositionVector[1] <= -(mDesktop.getHalfHeight() + EDGE_MARGIN);
         }
     }
 
     /**
      * Return true if user is looking at the space below the desktop.
      * This method can be called on any thread.
      */
     public boolean isLookingBelowDesktop() {
         synchronized (mEyePositionLock) {
-            return mEyePositionVector[1] >= (HALF_DESKTOP_HEIGHT + EDGE_MARGIN);
+            return mEyePositionVector[1] >= (mDesktop.getHalfHeight() + EDGE_MARGIN);
         }
     }
 
     /**
      * Get position on desktop where user is looking at.
      */
     private void getLookingPosition() {
         synchronized (mEyePositionLock) {
             if (Math.abs(mForwardVector[2]) < 0.00001f) {
                 mEyePositionVector[0] = Math.signum(mForwardVector[0]) * Float.MAX_VALUE;
                 mEyePositionVector[1] = Math.signum(mForwardVector[1]) * Float.MAX_VALUE;
             } else {
                 mEyePositionVector[0] = mForwardVector[0] * DESKTOP_POSITION_Z / mForwardVector[2];
                 mEyePositionVector[1] = mForwardVector[1] * DESKTOP_POSITION_Z / mForwardVector[2];
             }
             mEyePositionVector[2] = DESKTOP_POSITION_Z;
         }
     }
 
     /**
-     * Link desktop texture with textureDataHandle if {@link mReloadTexture} is true.
+     * Link desktop texture with {@link CardboardActivityDesktop} if {@link mReloadTexture} is true.
      * @param textureDataHandle the handle we want attach texture to
      */
-    private void maybeLoadTexture(int textureDataHandle) {
+    private void maybeLoadDesktopTexture() {
         synchronized (mReloadTextureLock) {
             if (!mReloadTexture) {
                 return;
             }
         }
 
         // TODO(shichengfeng): Record the time desktop drawing takes.
         Bitmap bitmap = JniInterface.getVideoFrame();
 
         if (bitmap == null) {
             // This can happen if the client is connected, but a complete video frame has not yet
             // been decoded.
             return;
         }
 
-        synchronized (mEyePositionLock) {
-            mDesktopHeightPixels = bitmap.getHeight();
-            mDesktopWidthPixels = bitmap.getWidth();
-        }
-
-        updateDesktopCoordinatesBuffer(bitmap);
-        TextureHelper.linkTexture(textureDataHandle, bitmap);
+        mDesktop.updateVideoFrameData(bitmap);
 
         synchronized (mReloadTextureLock) {
             mReloadTexture = false;
         }
     }
 
     /**
      * Convert float array to a FloatBuffer for use in OpenGL calls.
      */
-    private static FloatBuffer makeFloatBuffer(float[] data) {
+    public static FloatBuffer makeFloatBuffer(float[] data) {
         FloatBuffer result = ByteBuffer
                 .allocateDirect(data.length * BYTE_PER_FLOAT)
                 .order(ByteOrder.nativeOrder()).asFloatBuffer();
         result.put(data).position(0);
         return result;
     }
 
     /**
-     *  Update the desktop coordinates based on the new bitmap. Note here we fix the
-     *  height of the desktop and vary width accordingly.
-     */
-    private void updateDesktopCoordinatesBuffer(Bitmap bitmap) {
-        int width = bitmap.getWidth();
-        int height = bitmap.getHeight();
-        float newHalfDesktopWidth = width * HALF_DESKTOP_HEIGHT / height;
-        if (Math.abs(mHalfDesktopWidth - newHalfDesktopWidth) > 0.0001) {
-            mHalfDesktopWidth = newHalfDesktopWidth;
-            mDesktopCoordinates = makeFloatBuffer(new float[] {
-                // Desktop model coordinates.
-                -mHalfDesktopWidth, HALF_DESKTOP_HEIGHT, 0.0f,
-                -mHalfDesktopWidth, -HALF_DESKTOP_HEIGHT, 0.0f,
-                mHalfDesktopWidth, HALF_DESKTOP_HEIGHT, 0.0f,
-                -mHalfDesktopWidth, -HALF_DESKTOP_HEIGHT, 0.0f,
-                mHalfDesktopWidth, -HALF_DESKTOP_HEIGHT, 0.0f,
-                mHalfDesktopWidth, HALF_DESKTOP_HEIGHT, 0.0f
-            });
-        }
-    }
-
-    /**
      * Decode all skybox images to Bitmap files and return them.
      * Only call this method when we have complete skybox images.
      * @throws DecodeFileException if BitmapFactory fails to decode file.
      */
     private Bitmap[] decodeSkyboxImages() throws DecodeFileException {
         Bitmap[] result = new Bitmap[SKYBOX_IMAGE_NAMES.length];
         String fileDirectory = mDownloadManager.getDownloadDirectory();
         for (int i = 0; i < SKYBOX_IMAGE_NAMES.length; i++) {
             result[i] = BitmapFactory.decodeFile(fileDirectory + "/" + SKYBOX_IMAGE_NAMES[i]);
             if (result[i] == null) {
@@ skipping 28 matching lines @@
             image.recycle();
         }
     }
 
     /**
      * Exception when BitmapFactory fails to decode file.
      */
     private static class DecodeFileException extends Exception {
     }
 }