ShadowTessellator.cpp revision edaecc1db0584fa017822dfc2da0c968b53967e6
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 24#include "AmbientShadow.h" 25#include "Caches.h" 26#include "ShadowTessellator.h" 27#include "SpotShadow.h" 28 29namespace android { 30namespace uirenderer { 31 32void ShadowTessellator::tessellateAmbientShadow(bool isCasterOpaque, 33 const Vector3* casterPolygon, int casterVertexCount, 34 const Vector3& centroid3d, const Rect& casterBounds, 35 const Rect& localClip, float maxZ, VertexBuffer& shadowVertexBuffer) { 36 ATRACE_CALL(); 37 38 // A bunch of parameters to tweak the shadow. 39 // TODO: Allow some of these changable by debug settings or APIs. 40 float heightFactor = 1.0f / 128; 41 const float geomFactor = 64; 42 43 Caches& caches = Caches::getInstance(); 44 if (CC_UNLIKELY(caches.propertyAmbientRatio > 0.0f)) { 45 heightFactor *= caches.propertyAmbientRatio; 46 } 47 48 Rect ambientShadowBounds(casterBounds); 49 ambientShadowBounds.outset(maxZ * geomFactor * heightFactor); 50 51 if (!localClip.intersects(ambientShadowBounds)) { 52#if DEBUG_SHADOW 53 ALOGD("Ambient shadow is out of clip rect!"); 54#endif 55 return; 56 } 57 58 AmbientShadow::createAmbientShadow(isCasterOpaque, casterPolygon, 59 casterVertexCount, centroid3d, heightFactor, geomFactor, 60 shadowVertexBuffer); 61} 62 63void ShadowTessellator::tessellateSpotShadow(bool isCasterOpaque, 64 const Vector3* casterPolygon, int casterVertexCount, const Vector3& casterCentroid, 65 const mat4& receiverTransform, const Vector3& lightCenter, int lightRadius, 66 const Rect& casterBounds, const Rect& localClip, VertexBuffer& shadowVertexBuffer) { 67 ATRACE_CALL(); 68 69 Caches& caches = Caches::getInstance(); 70 71 Vector3 adjustedLightCenter(lightCenter); 72 if (CC_UNLIKELY(caches.propertyLightPosY > 0)) { 73 adjustedLightCenter.y = - caches.propertyLightPosY; // negated since this shifts up 74 } 75 if (CC_UNLIKELY(caches.propertyLightPosZ > 0)) { 76 adjustedLightCenter.z = caches.propertyLightPosZ; 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(caches.propertyLightDiameter > 0)) { 91 lightRadius = caches.propertyLightDiameter; 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 116void ShadowTessellator::generateShadowIndices(uint16_t* shadowIndices) { 117 int currentIndex = 0; 118 const int rays = SHADOW_RAY_COUNT; 119 // For the penumbra area. 120 for (int layer = 0; layer < 2; layer ++) { 121 int baseIndex = layer * rays; 122 for (int i = 0; i < rays; i++) { 123 shadowIndices[currentIndex++] = i + baseIndex; 124 shadowIndices[currentIndex++] = rays + i + baseIndex; 125 } 126 // To close the loop, back to the ray 0. 127 shadowIndices[currentIndex++] = 0 + baseIndex; 128 // Note this is the same as the first index of next layer loop. 129 shadowIndices[currentIndex++] = rays + baseIndex; 130 } 131 132#if DEBUG_SHADOW 133 if (currentIndex != MAX_SHADOW_INDEX_COUNT) { 134 ALOGW("vertex index count is wrong. current %d, expected %d", 135 currentIndex, MAX_SHADOW_INDEX_COUNT); 136 } 137 for (int i = 0; i < MAX_SHADOW_INDEX_COUNT; i++) { 138 ALOGD("vertex index is (%d, %d)", i, shadowIndices[i]); 139 } 140#endif 141} 142 143/** 144 * Calculate the centroid of a 2d polygon. 145 * 146 * @param poly The polygon, which is represented in a Vector2 array. 147 * @param polyLength The length of the polygon in terms of number of vertices. 148 * @return the centroid of the polygon. 149 */ 150Vector2 ShadowTessellator::centroid2d(const Vector2* poly, int polyLength) { 151 double sumx = 0; 152 double sumy = 0; 153 int p1 = polyLength - 1; 154 double area = 0; 155 for (int p2 = 0; p2 < polyLength; p2++) { 156 double x1 = poly[p1].x; 157 double y1 = poly[p1].y; 158 double x2 = poly[p2].x; 159 double y2 = poly[p2].y; 160 double a = (x1 * y2 - x2 * y1); 161 sumx += (x1 + x2) * a; 162 sumy += (y1 + y2) * a; 163 area += a; 164 p1 = p2; 165 } 166 167 Vector2 centroid = poly[0]; 168 if (area != 0) { 169 centroid = (Vector2){static_cast<float>(sumx / (3 * area)), 170 static_cast<float>(sumy / (3 * area))}; 171 } else { 172 ALOGW("Area is 0 while computing centroid!"); 173 } 174 return centroid; 175} 176 177// Make sure p1 -> p2 is going CW around the poly. 178Vector2 ShadowTessellator::calculateNormal(const Vector2& p1, const Vector2& p2) { 179 Vector2 result = p2 - p1; 180 if (result.x != 0 || result.y != 0) { 181 result.normalize(); 182 // Calculate the normal , which is CCW 90 rotate to the delta. 183 float tempy = result.y; 184 result.y = result.x; 185 result.x = -tempy; 186 } 187 return result; 188} 189/** 190 * Test whether the polygon is order in clockwise. 191 * 192 * @param polygon the polygon as a Vector2 array 193 * @param len the number of points of the polygon 194 */ 195bool ShadowTessellator::isClockwise(const Vector2* polygon, int len) { 196 if (len < 2 || polygon == NULL) { 197 return true; 198 } 199 double sum = 0; 200 double p1x = polygon[len - 1].x; 201 double p1y = polygon[len - 1].y; 202 for (int i = 0; i < len; i++) { 203 204 double p2x = polygon[i].x; 205 double p2y = polygon[i].y; 206 sum += p1x * p2y - p2x * p1y; 207 p1x = p2x; 208 p1y = p2y; 209 } 210 return sum < 0; 211} 212 213bool ShadowTessellator::isClockwisePath(const SkPath& path) { 214 SkPath::Iter iter(path, false); 215 SkPoint pts[4]; 216 SkPath::Verb v; 217 218 Vector<Vector2> arrayForDirection; 219 while (SkPath::kDone_Verb != (v = iter.next(pts))) { 220 switch (v) { 221 case SkPath::kMove_Verb: 222 arrayForDirection.add((Vector2){pts[0].x(), pts[0].y()}); 223 break; 224 case SkPath::kLine_Verb: 225 arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()}); 226 break; 227 case SkPath::kQuad_Verb: 228 arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()}); 229 arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()}); 230 break; 231 case SkPath::kCubic_Verb: 232 arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()}); 233 arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()}); 234 arrayForDirection.add((Vector2){pts[3].x(), pts[3].y()}); 235 break; 236 default: 237 break; 238 } 239 } 240 241 return isClockwise(arrayForDirection.array(), arrayForDirection.size()); 242} 243 244void ShadowTessellator::reverseVertexArray(Vertex* polygon, int len) { 245 int n = len / 2; 246 for (int i = 0; i < n; i++) { 247 Vertex tmp = polygon[i]; 248 int k = len - 1 - i; 249 polygon[i] = polygon[k]; 250 polygon[k] = tmp; 251 } 252} 253 254int ShadowTessellator::getExtraVertexNumber(const Vector2& vector1, 255 const Vector2& vector2, float divisor) { 256 // When there is no distance difference, there is no need for extra vertices. 257 if (vector1.lengthSquared() == 0 || vector2.lengthSquared() == 0) { 258 return 0; 259 } 260 // The formula is : 261 // extraNumber = floor(acos(dot(n1, n2)) / (M_PI / EXTRA_VERTEX_PER_PI)) 262 // The value ranges for each step are: 263 // dot( ) --- [-1, 1] 264 // acos( ) --- [0, M_PI] 265 // floor(...) --- [0, EXTRA_VERTEX_PER_PI] 266 float dotProduct = vector1.dot(vector2); 267 // TODO: Use look up table for the dotProduct to extraVerticesNumber 268 // computation, if needed. 269 float angle = acosf(dotProduct); 270 return (int) floor(angle / divisor); 271} 272 273void ShadowTessellator::checkOverflow(int used, int total, const char* bufferName) { 274 LOG_ALWAYS_FATAL_IF(used > total, "Error: %s overflow!!! used %d, total %d", 275 bufferName, used, total); 276} 277 278}; // namespace uirenderer 279}; // namespace android 280