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