Home | History | Annotate | Download | only in hwui
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 /**
     18  * Extra vertices for the corner for smoother corner.
     19  * Only for outer vertices.
     20  * Note that we use such extra memory to avoid an extra loop.
     21  */
     22 // For half circle, we could add EXTRA_VERTEX_PER_PI vertices.
     23 // Set to 1 if we don't want to have any.
     24 #define EXTRA_CORNER_VERTEX_PER_PI 12
     25 
     26 // For the whole polygon, the sum of all the deltas b/t normals is 2 * M_PI,
     27 // therefore, the maximum number of extra vertices will be twice bigger.
     28 #define MAX_EXTRA_CORNER_VERTEX_NUMBER  (2 * EXTRA_CORNER_VERTEX_PER_PI)
     29 
     30 // For each RADIANS_DIVISOR, we would allocate one more vertex b/t the normals.
     31 #define CORNER_RADIANS_DIVISOR (M_PI / EXTRA_CORNER_VERTEX_PER_PI)
     32 
     33 /**
     34  * Extra vertices for the Edge for interpolation artifacts.
     35  * Same value for both inner and outer vertices.
     36  */
     37 #define EXTRA_EDGE_VERTEX_PER_PI 50
     38 
     39 #define MAX_EXTRA_EDGE_VERTEX_NUMBER  (2 * EXTRA_EDGE_VERTEX_PER_PI)
     40 
     41 #define EDGE_RADIANS_DIVISOR  (M_PI / EXTRA_EDGE_VERTEX_PER_PI)
     42 
     43 /**
     44  * Other constants:
     45  */
     46 #define OUTER_ALPHA (0.0f)
     47 
     48 // Once the alpha difference is greater than this threshold, we will allocate extra
     49 // edge vertices.
     50 // If this is set to negative value, then all the edge will be tessellated.
     51 #define ALPHA_THRESHOLD (0.1f / 255.0f)
     52 
     53 #include "AmbientShadow.h"
     54 
     55 #include "ShadowTessellator.h"
     56 #include "Vertex.h"
     57 #include "VertexBuffer.h"
     58 
     59 #include <algorithm>
     60 #include <utils/Log.h>
     61 
     62 namespace android {
     63 namespace uirenderer {
     64 
     65 /**
     66  *  Local utility functions.
     67  */
     68 inline Vector2 getNormalFromVertices(const Vector3* vertices, int current, int next) {
     69     // Convert from Vector3 to Vector2 first.
     70     Vector2 currentVertex = { vertices[current].x, vertices[current].y };
     71     Vector2 nextVertex = { vertices[next].x, vertices[next].y };
     72 
     73     return ShadowTessellator::calculateNormal(currentVertex, nextVertex);
     74 }
     75 
     76 // The input z value will be converted to be non-negative inside.
     77 // The output must be ranged from 0 to 1.
     78 inline float getAlphaFromFactoredZ(float factoredZ) {
     79     return 1.0 / (1 + std::max(factoredZ, 0.0f));
     80 }
     81 
     82 inline int getEdgeExtraAndUpdateSpike(Vector2* currentSpike,
     83         const Vector3& secondVertex, const Vector3& centroid) {
     84     Vector2 secondSpike  = {secondVertex.x - centroid.x, secondVertex.y - centroid.y};
     85     secondSpike.normalize();
     86 
     87     int result = ShadowTessellator::getExtraVertexNumber(secondSpike, *currentSpike,
     88             EDGE_RADIANS_DIVISOR);
     89     *currentSpike = secondSpike;
     90     return result;
     91 }
     92 
     93 // Given the caster's vertex count, compute all the buffers size depending on
     94 // whether or not the caster is opaque.
     95 inline void computeBufferSize(int* totalVertexCount, int* totalIndexCount,
     96         int* totalUmbraCount, int casterVertexCount, bool isCasterOpaque) {
     97     // Compute the size of the vertex buffer.
     98     int outerVertexCount = casterVertexCount * 2 + MAX_EXTRA_CORNER_VERTEX_NUMBER +
     99         MAX_EXTRA_EDGE_VERTEX_NUMBER;
    100     int innerVertexCount = casterVertexCount + MAX_EXTRA_EDGE_VERTEX_NUMBER;
    101     *totalVertexCount = outerVertexCount + innerVertexCount;
    102 
    103     // Compute the size of the index buffer.
    104     *totalIndexCount = 2 * outerVertexCount + 2;
    105 
    106     // Compute the size of the umber buffer.
    107     // For translucent object, keep track of the umbra(inner) vertex in order to draw
    108     // inside. We only need to store the index information.
    109     *totalUmbraCount = 0;
    110     if (!isCasterOpaque) {
    111         // Add the centroid if occluder is translucent.
    112         (*totalVertexCount)++;
    113         *totalIndexCount += 2 * innerVertexCount + 1;
    114         *totalUmbraCount = innerVertexCount;
    115     }
    116 }
    117 
    118 inline bool needsExtraForEdge(float firstAlpha, float secondAlpha) {
    119     return fabsf(firstAlpha - secondAlpha) > ALPHA_THRESHOLD;
    120 }
    121 
    122 /**
    123  * Calculate the shadows as a triangle strips while alpha value as the
    124  * shadow values.
    125  *
    126  * @param isCasterOpaque Whether the caster is opaque.
    127  * @param vertices The shadow caster's polygon, which is represented in a Vector3
    128  *                  array.
    129  * @param vertexCount The length of caster's polygon in terms of number of
    130  *                    vertices.
    131  * @param centroid3d The centroid of the shadow caster.
    132  * @param heightFactor The factor showing the higher the object, the lighter the
    133  *                     shadow.
    134  * @param geomFactor The factor scaling the geometry expansion along the normal.
    135  *
    136  * @param shadowVertexBuffer Return an floating point array of (x, y, a)
    137  *               triangle strips mode.
    138  *
    139  * An simple illustration:
    140  * For now let's mark the outer vertex as Pi, the inner as Vi, the centroid as C.
    141  *
    142  * First project the occluder to the Z=0 surface.
    143  * Then we got all the inner vertices. And we compute the normal for each edge.
    144  * According to the normal, we generate outer vertices. E.g: We generate P1 / P4
    145  * as extra corner vertices to make the corner looks round and smoother.
    146  *
    147  * Due to the fact that the alpha is not linear interpolated along the inner
    148  * edge, when the alpha is different, we may add extra vertices such as P2.1, P2.2,
    149  * V0.1, V0.2 to avoid the visual artifacts.
    150  *
    151  *                                            (P3)
    152  *          (P2)     (P2.1)     (P2.2)         |     ' (P4)
    153  *   (P1)'   |        |           |            |   '
    154  *         ' |        |           |            | '
    155  * (P0)  ------------------------------------------------(P5)
    156  *           | (V0)   (V0.1)    (V0.2)         |(V1)
    157  *           |                                 |
    158  *           |                                 |
    159  *           |               (C)               |
    160  *           |                                 |
    161  *           |                                 |
    162  *           |                                 |
    163  *           |                                 |
    164  *        (V3)-----------------------------------(V2)
    165  */
    166 void AmbientShadow::createAmbientShadow(bool isCasterOpaque,
    167         const Vector3* casterVertices, int casterVertexCount, const Vector3& centroid3d,
    168         float heightFactor, float geomFactor, VertexBuffer& shadowVertexBuffer) {
    169     shadowVertexBuffer.setMeshFeatureFlags(VertexBuffer::kAlpha | VertexBuffer::kIndices);
    170 
    171     // In order to computer the outer vertices in one loop, we need pre-compute
    172     // the normal by the vertex (n - 1) to vertex 0, and the spike and alpha value
    173     // for vertex 0.
    174     Vector2 previousNormal = getNormalFromVertices(casterVertices,
    175             casterVertexCount - 1 , 0);
    176     Vector2 currentSpike = {casterVertices[0].x - centroid3d.x,
    177         casterVertices[0].y - centroid3d.y};
    178     currentSpike.normalize();
    179     float currentAlpha = getAlphaFromFactoredZ(casterVertices[0].z * heightFactor);
    180 
    181     // Preparing all the output data.
    182     int totalVertexCount, totalIndexCount, totalUmbraCount;
    183     computeBufferSize(&totalVertexCount, &totalIndexCount, &totalUmbraCount,
    184             casterVertexCount, isCasterOpaque);
    185     AlphaVertex* shadowVertices =
    186             shadowVertexBuffer.alloc<AlphaVertex>(totalVertexCount);
    187     int vertexBufferIndex = 0;
    188     uint16_t* indexBuffer = shadowVertexBuffer.allocIndices<uint16_t>(totalIndexCount);
    189     int indexBufferIndex = 0;
    190     uint16_t umbraVertices[totalUmbraCount];
    191     int umbraIndex = 0;
    192 
    193     for (int i = 0; i < casterVertexCount; i++)  {
    194         // Corner: first figure out the extra vertices we need for the corner.
    195         const Vector3& innerVertex = casterVertices[i];
    196         Vector2 currentNormal = getNormalFromVertices(casterVertices, i,
    197                 (i + 1) % casterVertexCount);
    198 
    199         int extraVerticesNumber = ShadowTessellator::getExtraVertexNumber(currentNormal,
    200                 previousNormal, CORNER_RADIANS_DIVISOR);
    201 
    202         float expansionDist = innerVertex.z * heightFactor * geomFactor;
    203         const int cornerSlicesNumber = extraVerticesNumber + 1; // Minimal as 1.
    204 #if DEBUG_SHADOW
    205         ALOGD("cornerSlicesNumber is %d", cornerSlicesNumber);
    206 #endif
    207 
    208         // Corner: fill the corner Vertex Buffer(VB) and Index Buffer(IB).
    209         // We fill the inner vertex first, such that we can fill the index buffer
    210         // inside the loop.
    211         int currentInnerVertexIndex = vertexBufferIndex;
    212         if (!isCasterOpaque) {
    213             umbraVertices[umbraIndex++] = vertexBufferIndex;
    214         }
    215         AlphaVertex::set(&shadowVertices[vertexBufferIndex++],
    216                 casterVertices[i].x, casterVertices[i].y,
    217                 currentAlpha);
    218 
    219         const Vector3& innerStart = casterVertices[i];
    220 
    221         // outerStart is the first outer vertex for this inner vertex.
    222         // outerLast is the last outer vertex for this inner vertex.
    223         Vector2 outerStart = {0, 0};
    224         Vector2 outerLast = {0, 0};
    225         // This will create vertices from [0, cornerSlicesNumber] inclusively,
    226         // which means minimally 2 vertices even without the extra ones.
    227         for (int j = 0; j <= cornerSlicesNumber; j++) {
    228             Vector2 averageNormal =
    229                 previousNormal * (cornerSlicesNumber - j) + currentNormal * j;
    230             averageNormal /= cornerSlicesNumber;
    231             averageNormal.normalize();
    232             Vector2 outerVertex;
    233             outerVertex.x = innerVertex.x + averageNormal.x * expansionDist;
    234             outerVertex.y = innerVertex.y + averageNormal.y * expansionDist;
    235 
    236             indexBuffer[indexBufferIndex++] = vertexBufferIndex;
    237             indexBuffer[indexBufferIndex++] = currentInnerVertexIndex;
    238             AlphaVertex::set(&shadowVertices[vertexBufferIndex++], outerVertex.x,
    239                     outerVertex.y, OUTER_ALPHA);
    240 
    241             if (j == 0) {
    242                 outerStart = outerVertex;
    243             } else if (j == cornerSlicesNumber) {
    244                 outerLast = outerVertex;
    245             }
    246         }
    247         previousNormal = currentNormal;
    248 
    249         // Edge: first figure out the extra vertices needed for the edge.
    250         const Vector3& innerNext = casterVertices[(i + 1) % casterVertexCount];
    251         float nextAlpha = getAlphaFromFactoredZ(innerNext.z * heightFactor);
    252         if (needsExtraForEdge(currentAlpha, nextAlpha)) {
    253             // TODO: See if we can / should cache this outer vertex across the loop.
    254             Vector2 outerNext;
    255             float expansionDist = innerNext.z * heightFactor * geomFactor;
    256             outerNext.x = innerNext.x + currentNormal.x * expansionDist;
    257             outerNext.y = innerNext.y + currentNormal.y * expansionDist;
    258 
    259             // Compute the angle and see how many extra points we need.
    260             int extraVerticesNumber = getEdgeExtraAndUpdateSpike(&currentSpike,
    261                     innerNext, centroid3d);
    262 #if DEBUG_SHADOW
    263             ALOGD("extraVerticesNumber %d for edge %d", extraVerticesNumber, i);
    264 #endif
    265             // Edge: fill the edge's VB and IB.
    266             // This will create vertices pair from [1, extraVerticesNumber - 1].
    267             // If there is no extra vertices created here, the edge will be drawn
    268             // as just 2 triangles.
    269             for (int k = 1; k < extraVerticesNumber; k++) {
    270                 int startWeight = extraVerticesNumber - k;
    271                 Vector2 currentOuter =
    272                     (outerLast * startWeight + outerNext * k) / extraVerticesNumber;
    273                 indexBuffer[indexBufferIndex++] = vertexBufferIndex;
    274                 AlphaVertex::set(&shadowVertices[vertexBufferIndex++], currentOuter.x,
    275                         currentOuter.y, OUTER_ALPHA);
    276 
    277                 if (!isCasterOpaque) {
    278                     umbraVertices[umbraIndex++] = vertexBufferIndex;
    279                 }
    280                 Vector3 currentInner =
    281                     (innerStart * startWeight + innerNext * k) / extraVerticesNumber;
    282                 indexBuffer[indexBufferIndex++] = vertexBufferIndex;
    283                 AlphaVertex::set(&shadowVertices[vertexBufferIndex++], currentInner.x,
    284                         currentInner.y,
    285                         getAlphaFromFactoredZ(currentInner.z * heightFactor));
    286             }
    287         }
    288         currentAlpha = nextAlpha;
    289     }
    290 
    291     indexBuffer[indexBufferIndex++] = 1;
    292     indexBuffer[indexBufferIndex++] = 0;
    293 
    294     if (!isCasterOpaque) {
    295         // Add the centroid as the last one in the vertex buffer.
    296         float centroidOpacity =
    297             getAlphaFromFactoredZ(centroid3d.z * heightFactor);
    298         int centroidIndex = vertexBufferIndex;
    299         AlphaVertex::set(&shadowVertices[vertexBufferIndex++], centroid3d.x,
    300                 centroid3d.y, centroidOpacity);
    301 
    302         for (int i = 0; i < umbraIndex; i++) {
    303             // Note that umbraVertices[0] is always 0.
    304             // So the start and the end of the umbra are using the "0".
    305             // And penumbra ended with 0, so a degenerated triangle is formed b/t
    306             // the umbra and penumbra.
    307             indexBuffer[indexBufferIndex++] = umbraVertices[i];
    308             indexBuffer[indexBufferIndex++] = centroidIndex;
    309         }
    310         indexBuffer[indexBufferIndex++] = 0;
    311     }
    312 
    313     // At the end, update the real index and vertex buffer size.
    314     shadowVertexBuffer.updateVertexCount(vertexBufferIndex);
    315     shadowVertexBuffer.updateIndexCount(indexBufferIndex);
    316     shadowVertexBuffer.computeBounds<AlphaVertex>();
    317 
    318     ShadowTessellator::checkOverflow(vertexBufferIndex, totalVertexCount, "Ambient Vertex Buffer");
    319     ShadowTessellator::checkOverflow(indexBufferIndex, totalIndexCount, "Ambient Index Buffer");
    320     ShadowTessellator::checkOverflow(umbraIndex, totalUmbraCount, "Ambient Umbra Buffer");
    321 
    322 #if DEBUG_SHADOW
    323     for (int i = 0; i < vertexBufferIndex; i++) {
    324         ALOGD("vertexBuffer i %d, (%f, %f %f)", i, shadowVertices[i].x, shadowVertices[i].y,
    325                 shadowVertices[i].alpha);
    326     }
    327     for (int i = 0; i < indexBufferIndex; i++) {
    328         ALOGD("indexBuffer i %d, indexBuffer[i] %d", i, indexBuffer[i]);
    329     }
    330 #endif
    331 }
    332 
    333 }; // namespace uirenderer
    334 }; // namespace android
    335