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.PointF;
@@ skipping 82 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 44 matching lines @@
     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.
     private Object mEyePositionLock = new Object();
 
     private int mDesktopHeightPixels;
     private int mDesktopWidthPixels;
 
     private FloatBuffer mDesktopCoordinates;

[Lambros, 2015/08/19 23:17:28]

I think this should be moved into the CardboardActivityDesktop class.

[shichengfeng, 2015/08/20 01:02:54]

Done.

 
     // 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;
 
@@ skipping 45 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 (mDesktopCoordinates == null) {

[Lambros, 2015/08/19 23:17:28]

mDesktopCoordinates is no longer used in this method, so this seems like the
wrong thing to test.

The test should be based on whether a desktop frame has been received and loaded
into OpenGL. Probably makes sense to move the test inside the mDesktop object,
like:
mDesktop.hasDesktopImage()
or something like that?

[shichengfeng, 2015/08/20 01:02:53]

Done.

+            // 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,
@@ skipping 160 matching lines @@
                 mEyePositionVector[1] = mForwardVector[1] * DESKTOP_POSITION_Z / mForwardVector[2];
             }
             mEyePositionVector[2] = DESKTOP_POSITION_Z;
         }
     }
 
     /**
      * Link desktop texture with textureDataHandle 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.setTexture(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) {

[Lambros, 2015/08/19 23:17:28]

Move this inside CardboardActivityDesktop as well.

[shichengfeng, 2015/08/20 01:02:53]

Done.

         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
             });
+            mDesktop.setPosition(mDesktopCoordinates);
         }
     }
 
     /**
      * 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];
@@ skipping 32 matching lines @@
             image.recycle();
         }
     }
 
     /**
      * Exception when BitmapFactory fails to decode file.
      */
     private static class DecodeFileException extends Exception {
     }
 }