Build layer damage bounds for shadows

bug:15538815

Change-Id: I703afeb7e31c28002bd1aff9ce448ec8cdc4e70d

libs/hwui/AmbientShadow.cpp

@@ -136,6 +136,7 @@ void AmbientShadow::createAmbientShadow(bool isCasterOpaque,
         }
     }
     shadowVertexBuffer.setMode(mode);
+    shadowVertexBuffer.computeBounds<AlphaVertex>();
 
 #if DEBUG_SHADOW
     for (int i = 0; i < SHADOW_VERTEX_COUNT; i++) {

libs/hwui/PathTessellator.cpp

@@ -794,16 +794,6 @@ void PathTessellator::tessellatePath(const SkPath &path, const SkPaint* paint,
     vertexBuffer.setBounds(bounds);
 }
 
-static void expandRectToCoverVertex(Rect& rect, float x, float y) {
-    rect.left = fminf(rect.left, x);
-    rect.top = fminf(rect.top, y);
-    rect.right = fmaxf(rect.right, x);
-    rect.bottom = fmaxf(rect.bottom, y);
-}
-static void expandRectToCoverVertex(Rect& rect, const Vertex& vertex) {
-    expandRectToCoverVertex(rect, vertex.x, vertex.y);
-}
-
 template <class TYPE>
 static void instanceVertices(VertexBuffer& srcBuffer, VertexBuffer& dstBuffer,
         const float* points, int count, Rect& bounds) {
@@ -814,7 +804,7 @@ static void instanceVertices(VertexBuffer& srcBuffer, VertexBuffer& dstBuffer,
     dstBuffer.alloc<TYPE>(numPoints * verticesPerPoint + (numPoints - 1) * 2);
 
     for (int i = 0; i < count; i += 2) {
-        expandRectToCoverVertex(bounds, points[i + 0], points[i + 1]);
+        bounds.expandToCoverVertex(points[i + 0], points[i + 1]);
         dstBuffer.copyInto<TYPE>(srcBuffer, points[i + 0], points[i + 1]);
     }
     dstBuffer.createDegenerateSeparators<TYPE>(verticesPerPoint);
@@ -896,8 +886,8 @@ void PathTessellator::tessellateLines(const float* points, int count, const SkPa
         }
 
         // calculate bounds
-        expandRectToCoverVertex(bounds, tempVerticesData[0]);
-        expandRectToCoverVertex(bounds, tempVerticesData[1]);
+        bounds.expandToCoverVertex(tempVerticesData[0].x, tempVerticesData[0].y);
+        bounds.expandToCoverVertex(tempVerticesData[1].x, tempVerticesData[1].y);
     }
 
     // since multiple objects tessellated into buffer, separate them with degen tris

libs/hwui/Rect.h

@@ -241,6 +241,13 @@ public:
         bottom = ceilf(bottom);
     }
 
+    void expandToCoverVertex(float x, float y) {
+        left = fminf(left, x);
+        top = fminf(top, y);
+        right = fmaxf(right, x);
+        bottom = fmaxf(bottom, y);
+    }
+
     void dump(const char* label = NULL) const {
         ALOGD("%s[l=%f t=%f r=%f b=%f]", label ? label : "Rect", left, top, right, bottom);
     }

libs/hwui/SpotShadow.cpp

@@ -508,6 +508,7 @@ void SpotShadow::createSpotShadow(bool isCasterOpaque, const Vector3* poly,
     computeSpotShadow(isCasterOpaque, light, lightVertexCount, lightCenter, poly,
             polyLength, retStrips);
     retStrips.setMode(VertexBuffer::kTwoPolyRingShadow);
+    retStrips.computeBounds<AlphaVertex>();
 }
 
 /**

libs/hwui/TessellationCache.cpp

@@ -273,8 +273,6 @@ static void tessellateShadows(
             isCasterOpaque, casterPolygon, casterVertexCount,
             *drawTransform, lightCenter, lightRadius, casterBounds, *localClip,
             spotBuffer);
-
-    // TODO: set ambientBuffer & spotBuffer's bounds for correct layer damage
 }
 
 class ShadowProcessor : public TaskProcessor<TessellationCache::vertexBuffer_pair_t*> {

libs/hwui/VertexBuffer.h

@@ -62,6 +62,8 @@ public:
         mVertexCount = vertexCount;
         mByteCount = mVertexCount * sizeof(TYPE);
         mReallocBuffer = mBuffer = (void*)new TYPE[vertexCount];
+        memset(mBuffer, 0, sizeof(TYPE) * vertexCount);
+
         mCleanupMethod = &(cleanup<TYPE>);
 
         return (TYPE*)mBuffer;
@@ -79,6 +81,24 @@ public:
         }
     }
 
+    /**
+     * Brute force bounds computation, used only if the producer of this
+     * vertex buffer can't determine bounds more simply/efficiently
+     */
+    template <class TYPE>
+    void computeBounds() {
+        if (!mVertexCount) {
+            mBounds.setEmpty();
+            return;
+        }
+        TYPE* current = (TYPE*)mBuffer;
+        TYPE* end = current + mVertexCount;
+        mBounds.set(current->x, current->y, current->x, current->y);
+        for (; current < end; current++) {
+            mBounds.expandToCoverVertex(current->x, current->y);
+        }
+    }
+
     const void* getBuffer() const { return mBuffer; }
     const Rect& getBounds() const { return mBounds; }
     unsigned int getVertexCount() const { return mVertexCount; }