libs/hwui/ShadowTessellator.cpp

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