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 #define LOG_TAG "OpenGLRenderer"
     18 #define ATRACE_TAG ATRACE_TAG_VIEW
     19 
     20 #include <math.h>
     21 #include <utils/Log.h>
     22 #include <utils/Trace.h>
     23 #include <utils/Vector.h>
     24 #include <utils/MathUtils.h>
     25 
     26 #include "AmbientShadow.h"
     27 #include "Properties.h"
     28 #include "ShadowTessellator.h"
     29 #include "SpotShadow.h"
     30 #include "Vector.h"
     31 
     32 namespace android {
     33 namespace uirenderer {
     34 
     35 void ShadowTessellator::tessellateAmbientShadow(bool isCasterOpaque,
     36         const Vector3* casterPolygon, int casterVertexCount,
     37         const Vector3& centroid3d, const Rect& casterBounds,
     38         const Rect& localClip, float maxZ, VertexBuffer& shadowVertexBuffer) {
     39     ATRACE_CALL();
     40 
     41     // A bunch of parameters to tweak the shadow.
     42     // TODO: Allow some of these changable by debug settings or APIs.
     43     float heightFactor = 1.0f / 128;
     44     const float geomFactor = 64;
     45 
     46     if (CC_UNLIKELY(Properties::overrideAmbientRatio > 0.0f)) {
     47         heightFactor *= Properties::overrideAmbientRatio;
     48     }
     49 
     50     Rect ambientShadowBounds(casterBounds);
     51     ambientShadowBounds.outset(maxZ * geomFactor * heightFactor);
     52 
     53     if (!localClip.intersects(ambientShadowBounds)) {
     54 #if DEBUG_SHADOW
     55         ALOGD("Ambient shadow is out of clip rect!");
     56 #endif
     57         return;
     58     }
     59 
     60     AmbientShadow::createAmbientShadow(isCasterOpaque, casterPolygon,
     61             casterVertexCount, centroid3d, heightFactor, geomFactor,
     62             shadowVertexBuffer);
     63 }
     64 
     65 void ShadowTessellator::tessellateSpotShadow(bool isCasterOpaque,
     66         const Vector3* casterPolygon, int casterVertexCount, const Vector3& casterCentroid,
     67         const mat4& receiverTransform, const Vector3& lightCenter, int lightRadius,
     68         const Rect& casterBounds, const Rect& localClip, VertexBuffer& shadowVertexBuffer) {
     69     ATRACE_CALL();
     70 
     71     Vector3 adjustedLightCenter(lightCenter);
     72     if (CC_UNLIKELY(Properties::overrideLightPosY > 0)) {
     73         adjustedLightCenter.y = - Properties::overrideLightPosY; // negated since this shifts up
     74     }
     75     if (CC_UNLIKELY(Properties::overrideLightPosZ > 0)) {
     76         adjustedLightCenter.z = Properties::overrideLightPosZ;
     77     }
     78 
     79 #if DEBUG_SHADOW
     80     ALOGD("light center %f %f %f",
     81             adjustedLightCenter.x, adjustedLightCenter.y, adjustedLightCenter.z);
     82 #endif
     83 
     84     // light position (because it's in local space) needs to compensate for receiver transform
     85     // TODO: should apply to light orientation, not just position
     86     Matrix4 reverseReceiverTransform;
     87     reverseReceiverTransform.loadInverse(receiverTransform);
     88     reverseReceiverTransform.mapPoint3d(adjustedLightCenter);
     89 
     90     if (CC_UNLIKELY(Properties::overrideLightRadius > 0)) {
     91         lightRadius = Properties::overrideLightRadius;
     92     }
     93 
     94     // Now light and caster are both in local space, we will check whether
     95     // the shadow is within the clip area.
     96     Rect lightRect = Rect(adjustedLightCenter.x - lightRadius, adjustedLightCenter.y - lightRadius,
     97             adjustedLightCenter.x + lightRadius, adjustedLightCenter.y + lightRadius);
     98     lightRect.unionWith(localClip);
     99     if (!lightRect.intersects(casterBounds)) {
    100 #if DEBUG_SHADOW
    101         ALOGD("Spot shadow is out of clip rect!");
    102 #endif
    103         return;
    104     }
    105 
    106     SpotShadow::createSpotShadow(isCasterOpaque, adjustedLightCenter, lightRadius,
    107             casterPolygon, casterVertexCount, casterCentroid, shadowVertexBuffer);
    108 
    109 #if DEBUG_SHADOW
    110      if(shadowVertexBuffer.getVertexCount() <= 0) {
    111         ALOGD("Spot shadow generation failed %d", shadowVertexBuffer.getVertexCount());
    112      }
    113 #endif
    114 }
    115 
    116 /**
    117  * Calculate the centroid of a 2d polygon.
    118  *
    119  * @param poly The polygon, which is represented in a Vector2 array.
    120  * @param polyLength The length of the polygon in terms of number of vertices.
    121  * @return the centroid of the polygon.
    122  */
    123 Vector2 ShadowTessellator::centroid2d(const Vector2* poly, int polyLength) {
    124     double sumx = 0;
    125     double sumy = 0;
    126     int p1 = polyLength - 1;
    127     double area = 0;
    128     for (int p2 = 0; p2 < polyLength; p2++) {
    129         double x1 = poly[p1].x;
    130         double y1 = poly[p1].y;
    131         double x2 = poly[p2].x;
    132         double y2 = poly[p2].y;
    133         double a = (x1 * y2 - x2 * y1);
    134         sumx += (x1 + x2) * a;
    135         sumy += (y1 + y2) * a;
    136         area += a;
    137         p1 = p2;
    138     }
    139 
    140     Vector2 centroid = poly[0];
    141     if (area != 0) {
    142         centroid = (Vector2){static_cast<float>(sumx / (3 * area)),
    143             static_cast<float>(sumy / (3 * area))};
    144     } else {
    145         ALOGW("Area is 0 while computing centroid!");
    146     }
    147     return centroid;
    148 }
    149 
    150 // Make sure p1 -> p2 is going CW around the poly.
    151 Vector2 ShadowTessellator::calculateNormal(const Vector2& p1, const Vector2& p2) {
    152     Vector2 result = p2 - p1;
    153     if (result.x != 0 || result.y != 0) {
    154         result.normalize();
    155         // Calculate the normal , which is CCW 90 rotate to the delta.
    156         float tempy = result.y;
    157         result.y = result.x;
    158         result.x = -tempy;
    159     }
    160     return result;
    161 }
    162 
    163 int ShadowTessellator::getExtraVertexNumber(const Vector2& vector1,
    164         const Vector2& vector2, float divisor) {
    165     // When there is no distance difference, there is no need for extra vertices.
    166     if (vector1.lengthSquared() == 0 || vector2.lengthSquared() == 0) {
    167         return 0;
    168     }
    169     // The formula is :
    170     // extraNumber = floor(acos(dot(n1, n2)) / (M_PI / EXTRA_VERTEX_PER_PI))
    171     // The value ranges for each step are:
    172     // dot( ) --- [-1, 1]
    173     // acos( )     --- [0, M_PI]
    174     // floor(...)  --- [0, EXTRA_VERTEX_PER_PI]
    175     float dotProduct = vector1.dot(vector2);
    176     // make sure that dotProduct value is in acsof input range [-1, 1]
    177     dotProduct = MathUtils::clamp(dotProduct, -1.0f, 1.0f);
    178     // TODO: Use look up table for the dotProduct to extraVerticesNumber
    179     // computation, if needed.
    180     float angle = acosf(dotProduct);
    181     return (int) floor(angle / divisor);
    182 }
    183 
    184 void ShadowTessellator::checkOverflow(int used, int total, const char* bufferName) {
    185     LOG_ALWAYS_FATAL_IF(used > total, "Error: %s overflow!!! used %d, total %d",
    186             bufferName, used, total);
    187 }
    188 
    189 }; // namespace uirenderer
    190 }; // namespace android
    191