Create private properties on GLCanvas for experimentation with 3d

Change-Id: I17772f61efce727cb4c1111f4d97f58c741786b8

7 files changed, 90 insertions, 22 deletions

diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index c023378876eb..9b48881d08f4 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -153,6 +153,12 @@ class GLES20Canvas extends HardwareCanvas {
 
     private static native void nSetName(int renderer, String name);
 
+    public static void setProperty(String name, String value) {
+        nSetProperty(name, value);
+    }
+
+    private static native void nSetProperty(String name, String value);
+
     ///////////////////////////////////////////////////////////////////////////
     // Hardware layers
     ///////////////////////////////////////////////////////////////////////////
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index 964f0d66fd01..d62b1081a021 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -185,6 +185,24 @@ static void android_view_GLES20Canvas_setName(JNIEnv* env,
     }
 }
 
+static void android_view_GLES20Canvas_setProperty(JNIEnv* env,
+        jobject clazz, jstring name, jstring value) {
+    if (!Caches::hasInstance()) {
+        ALOGW("can't set property, no Caches instance");
+        return;
+    }
+
+    if (name == NULL || value == NULL) {
+        ALOGW("can't set prop, null passed");
+    }
+
+    const char* nameCharArray = env->GetStringUTFChars(name, NULL);
+    const char* valueCharArray = env->GetStringUTFChars(value, NULL);
+    Caches::getInstance().setTempProperty(nameCharArray, valueCharArray);
+    env->ReleaseStringUTFChars(name, nameCharArray);
+    env->ReleaseStringUTFChars(name, valueCharArray);
+}
+
 static void android_view_GLES20Canvas_setCountOverdrawEnabled(JNIEnv* env, jobject clazz,
         OpenGLRenderer* renderer, jboolean enabled) {
     renderer->setCountOverdrawEnabled(enabled);
@@ -1011,6 +1029,8 @@ static JNINativeMethod gMethods[] = {
     { "nFinish",            "(I)V",            (void*) android_view_GLES20Canvas_finish },
     { "nSetName",           "(ILjava/lang/String;)V",
             (void*) android_view_GLES20Canvas_setName },
+    { "nSetProperty",           "(Ljava/lang/String;Ljava/lang/String;)V",
+            (void*) android_view_GLES20Canvas_setProperty },
 
     { "nSetCountOverdrawEnabled", "(IZ)V",     (void*) android_view_GLES20Canvas_setCountOverdrawEnabled },
     { "nGetOverdraw",             "(I)F",      (void*) android_view_GLES20Canvas_getOverdraw },
diff --git a/libs/hwui/Caches.cpp b/libs/hwui/Caches.cpp
index 5b751b91d384..2e7990edb78e 100644
--- a/libs/hwui/Caches.cpp
+++ b/libs/hwui/Caches.cpp
@@ -55,6 +55,7 @@ Caches::Caches(): Singleton<Caches>(),
     initProperties();
     initStaticProperties();
     initExtensions();
+    initTempProperties();
 
     mDebugLevel = readDebugLevel();
     ALOGD("Enabling debug mode %d", mDebugLevel);
@@ -676,5 +677,36 @@ TextureVertex* Caches::getRegionMesh() {
     return mRegionMesh;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// Temporary Properties
+///////////////////////////////////////////////////////////////////////////////
+
+void Caches::initTempProperties() {
+    propertyDirtyViewport = false;
+    propertyEnable3d = false;
+    propertyCameraDistance = 1.0f;
+    propertyShadowStrength = 0x3f;
+}
+
+void Caches::setTempProperty(const char* name, const char* value) {
+    ALOGD("setting property %s to %s", name, value);
+    if (!strcmp(name, "enable3d")) {
+        propertyEnable3d = !strcmp(value, "true");
+        propertyDirtyViewport = true;
+        ALOGD("enable3d = %d", propertyEnable3d);
+        return;
+    } else if (!strcmp(name, "cameraDistance")) {
+        propertyCameraDistance = fmin(fmax(atof(value), 0.001), 10);
+        propertyDirtyViewport = true;
+        ALOGD("camera dist multiplier = %.2f", propertyCameraDistance);
+        return;
+    } else if (!strcmp(name, "shadowStrength")) {
+        propertyShadowStrength = atoi(value);
+        ALOGD("shadow strength = 0x%x out of 0xff", propertyShadowStrength);
+        return;
+    }
+    ALOGD("    failed");
+}
+
 }; // namespace uirenderer
 }; // namespace android
diff --git a/libs/hwui/Caches.h b/libs/hwui/Caches.h
index 963965db8300..01e8d8474887 100644
--- a/libs/hwui/Caches.h
+++ b/libs/hwui/Caches.h
@@ -353,6 +353,14 @@ public:
     PFNGLLABELOBJECTEXTPROC setLabel;
     PFNGLGETOBJECTLABELEXTPROC getLabel;
 
+    // TEMPORARY properties
+    void initTempProperties();
+    void setTempProperty(const char* name, const char* value);
+    bool propertyEnable3d;
+    bool propertyDirtyViewport; // flag set when dirtying the viewport
+    float propertyCameraDistance;
+    int propertyShadowStrength;
+
 private:
     enum OverdrawColorSet {
         kColorSet_Default = 0,
diff --git a/libs/hwui/Debug.h b/libs/hwui/Debug.h
index f619205083fd..d6dc6ad2d67c 100644
--- a/libs/hwui/Debug.h
+++ b/libs/hwui/Debug.h
@@ -85,9 +85,6 @@
 // Turn on to highlight drawing batches and merged batches with different colors
 #define DEBUG_MERGE_BEHAVIOR 0
 
-// Turn on to enable 3D support in the renderer (off by default until API for control exists)
-#define DEBUG_ENABLE_3D 0
-
 // Turn on to enable debugging shadow
 #define DEBUG_SHADOW 0
 
diff --git a/libs/hwui/DisplayList.cpp b/libs/hwui/DisplayList.cpp
index c616cd8c349f..de2106c0d2c5 100644
--- a/libs/hwui/DisplayList.cpp
+++ b/libs/hwui/DisplayList.cpp
@@ -310,12 +310,12 @@ void DisplayList::updateMatrix() {
                     mPivotY = mPrevHeight / 2.0f;
                 }
             }
-            if (!DEBUG_ENABLE_3D && (mMatrixFlags & ROTATION_3D) == 0) {
+            if (!Caches::getInstance().propertyEnable3d && (mMatrixFlags & ROTATION_3D) == 0) {
                 mTransformMatrix->setTranslate(mTranslationX, mTranslationY);
                 mTransformMatrix->preRotate(mRotation, mPivotX, mPivotY);
                 mTransformMatrix->preScale(mScaleX, mScaleY, mPivotX, mPivotY);
             } else {
-                if (DEBUG_ENABLE_3D) {
+                if (Caches::getInstance().propertyEnable3d) {
                     mTransform.loadTranslate(mPivotX + mTranslationX, mPivotY + mTranslationY,
                             mTranslationZ);
                     mTransform.rotate(mRotationX, 1, 0, 0);
@@ -420,11 +420,11 @@ void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,
             renderer.translate(mTranslationX, mTranslationY);
             renderer.translateZ(mTranslationZ);
         } else {
-#if DEBUG_ENABLE_3D
-            renderer.concatMatrix(mTransform);
-#else
-            renderer.concatMatrix(mTransformMatrix);
-#endif
+            if (Caches::getInstance().propertyEnable3d) {
+                renderer.concatMatrix(mTransform);
+            } else {
+                renderer.concatMatrix(mTransformMatrix);
+            }
         }
     }
     bool clipToBoundsNeeded = mCaching ? false : mClipToBounds;
@@ -474,12 +474,12 @@ void DisplayList::applyViewPropertyTransforms(mat4& matrix) {
         if (mMatrixFlags == TRANSLATION) {
             matrix.translate(mTranslationX, mTranslationY, mTranslationZ);
         } else {
-#if DEBUG_ENABLE_3D
-            matrix.multiply(mTransform);
-#else
-            mat4 temp(*mTransformMatrix);
-            matrix.multiply(temp);
-#endif
+            if (Caches::getInstance().propertyEnable3d) {
+                matrix.multiply(mTransform);
+            } else {
+                mat4 temp(*mTransformMatrix);
+                matrix.multiply(temp);
+            }
         }
     }
 }
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 578a2517105d..cdef94e29a8e 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -182,10 +182,10 @@ void OpenGLRenderer::setViewport(int width, int height) {
 }
 
 void OpenGLRenderer::initViewport(int width, int height) {
-    float dist = std::max(width, height) * 1.5;
-
-    if (DEBUG_ENABLE_3D) {
+    if (mCaches.propertyEnable3d) {
         // TODO: make view proj app configurable
+        float dist = std::max(width, height) * 1.5;
+        dist *= mCaches.propertyCameraDistance;
         Matrix4 projection;
         projection.loadFrustum(-width / 2, -height / 2, width / 2, height / 2, dist, 0);
         Matrix4 view;
@@ -2081,6 +2081,12 @@ status_t OpenGLRenderer::drawDisplayList(DisplayList* displayList, Rect& dirty,
         int32_t replayFlags) {
     status_t status;
 
+    if (mCaches.propertyDirtyViewport) {
+        // force recalc of view/proj matrices
+        setViewport(mWidth, mHeight);
+        mCaches.propertyDirtyViewport = false;
+    }
+
     // All the usual checks and setup operations (quickReject, setupDraw, etc.)
     // will be performed by the display list itself
     if (displayList && displayList->isRenderable()) {
@@ -3394,9 +3400,8 @@ status_t OpenGLRenderer::drawShadow(const mat4& casterTransform, float casterAlp
     mCaches.enableScissor();
 
     SkPaint paint;
-    paint.setColor(0x3f000000);
-    // Force the draw to use alpha values.
-    paint.setAntiAlias(true);
+    paint.setColor(mCaches.propertyShadowStrength << 24);
+    paint.setAntiAlias(true); // want to use AlphaVertex
 
     VertexBuffer shadowVertexBuffer;
     ShadowTessellator::tessellateAmbientShadow(width, height, casterTransform,