ShadowTessellator.cpp revision 2507c34d91bb0d722b6012e85cb47387b2aa6873 
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
25#include "AmbientShadow.h"
26#include "Properties.h"
27#include "ShadowTessellator.h"
28#include "SpotShadow.h"
29#include "Vector.h"
30
31namespace android {
32namespace uirenderer {
33
34void ShadowTessellator::tessellateAmbientShadow(bool isCasterOpaque,
35        const Vector3* casterPolygon, int casterVertexCount,
36        const Vector3& centroid3d, const Rect& casterBounds,
37        const Rect& localClip, float maxZ, VertexBuffer& shadowVertexBuffer) {
38    ATRACE_CALL();
39
40    // A bunch of parameters to tweak the shadow.
41    // TODO: Allow some of these changable by debug settings or APIs.
42    float heightFactor = 1.0f / 128;
43    const float geomFactor = 64;
44
45    if (CC_UNLIKELY(Properties::overrideAmbientRatio > 0.0f)) {
46        heightFactor *= Properties::overrideAmbientRatio;
47    }
48
49    Rect ambientShadowBounds(casterBounds);
50    ambientShadowBounds.outset(maxZ * geomFactor * heightFactor);
51
52    if (!localClip.intersects(ambientShadowBounds)) {
53#if DEBUG_SHADOW
54        ALOGD("Ambient shadow is out of clip rect!");
55#endif
56        return;
57    }
58
59    AmbientShadow::createAmbientShadow(isCasterOpaque, casterPolygon,
60            casterVertexCount, centroid3d, heightFactor, geomFactor,
61            shadowVertexBuffer);
62}
63
64void ShadowTessellator::tessellateSpotShadow(bool isCasterOpaque,
65        const Vector3* casterPolygon, int casterVertexCount, const Vector3& casterCentroid,
66        const mat4& receiverTransform, const Vector3& lightCenter, int lightRadius,
67        const Rect& casterBounds, const Rect& localClip, VertexBuffer& shadowVertexBuffer) {
68    ATRACE_CALL();
69
70    Vector3 adjustedLightCenter(lightCenter);
71    if (CC_UNLIKELY(Properties::overrideLightPosY > 0)) {
72        adjustedLightCenter.y = - Properties::overrideLightPosY; // negated since this shifts up
73    }
74    if (CC_UNLIKELY(Properties::overrideLightPosZ > 0)) {
75        adjustedLightCenter.z = Properties::overrideLightPosZ;
76    }
77
78#if DEBUG_SHADOW
79    ALOGD("light center %f %f %f",
80            adjustedLightCenter.x, adjustedLightCenter.y, adjustedLightCenter.z);
81#endif
82
83    // light position (because it's in local space) needs to compensate for receiver transform
84    // TODO: should apply to light orientation, not just position
85    Matrix4 reverseReceiverTransform;
86    reverseReceiverTransform.loadInverse(receiverTransform);
87    reverseReceiverTransform.mapPoint3d(adjustedLightCenter);
88
89    if (CC_UNLIKELY(Properties::overrideLightRadius > 0)) {
90        lightRadius = Properties::overrideLightRadius;
91    }
92
93    // Now light and caster are both in local space, we will check whether
94    // the shadow is within the clip area.
95    Rect lightRect = Rect(adjustedLightCenter.x - lightRadius, adjustedLightCenter.y - lightRadius,
96            adjustedLightCenter.x + lightRadius, adjustedLightCenter.y + lightRadius);
97    lightRect.unionWith(localClip);
98    if (!lightRect.intersects(casterBounds)) {
99#if DEBUG_SHADOW
100        ALOGD("Spot shadow is out of clip rect!");
101#endif
102        return;
103    }
104
105    SpotShadow::createSpotShadow(isCasterOpaque, adjustedLightCenter, lightRadius,
106            casterPolygon, casterVertexCount, casterCentroid, shadowVertexBuffer);
107
108#if DEBUG_SHADOW
109     if(shadowVertexBuffer.getVertexCount() <= 0) {
110        ALOGD("Spot shadow generation failed %d", shadowVertexBuffer.getVertexCount());
111     }
112#endif
113}
114
115/**
116 * Calculate the centroid of a 2d polygon.
117 *
118 * @param poly The polygon, which is represented in a Vector2 array.
119 * @param polyLength The length of the polygon in terms of number of vertices.
120 * @return the centroid of the polygon.
121 */
122Vector2 ShadowTessellator::centroid2d(const Vector2* poly, int polyLength) {
123    double sumx = 0;
124    double sumy = 0;
125    int p1 = polyLength - 1;
126    double area = 0;
127    for (int p2 = 0; p2 < polyLength; p2++) {
128        double x1 = poly[p1].x;
129        double y1 = poly[p1].y;
130        double x2 = poly[p2].x;
131        double y2 = poly[p2].y;
132        double a = (x1 * y2 - x2 * y1);
133        sumx += (x1 + x2) * a;
134        sumy += (y1 + y2) * a;
135        area += a;
136        p1 = p2;
137    }
138
139    Vector2 centroid = poly[0];
140    if (area != 0) {
141        centroid = (Vector2){static_cast<float>(sumx / (3 * area)),
142            static_cast<float>(sumy / (3 * area))};
143    } else {
144        ALOGW("Area is 0 while computing centroid!");
145    }
146    return centroid;
147}
148
149// Make sure p1 -> p2 is going CW around the poly.
150Vector2 ShadowTessellator::calculateNormal(const Vector2& p1, const Vector2& p2) {
151    Vector2 result = p2 - p1;
152    if (result.x != 0 || result.y != 0) {
153        result.normalize();
154        // Calculate the normal , which is CCW 90 rotate to the delta.
155        float tempy = result.y;
156        result.y = result.x;
157        result.x = -tempy;
158    }
159    return result;
160}
161/**
162 * Test whether the polygon is order in clockwise.
163 *
164 * @param polygon the polygon as a Vector2 array
165 * @param len the number of points of the polygon
166 */
167bool ShadowTessellator::isClockwise(const Vector2* polygon, int len) {
168    if (len < 2 || polygon == nullptr) {
169        return true;
170    }
171    double sum = 0;
172    double p1x = polygon[len - 1].x;
173    double p1y = polygon[len - 1].y;
174    for (int i = 0; i < len; i++) {
175
176        double p2x = polygon[i].x;
177        double p2y = polygon[i].y;
178        sum += p1x * p2y - p2x * p1y;
179        p1x = p2x;
180        p1y = p2y;
181    }
182    return sum < 0;
183}
184
185bool ShadowTessellator::isClockwisePath(const SkPath& path) {
186    SkPath::Iter iter(path, false);
187    SkPoint pts[4];
188    SkPath::Verb v;
189
190    Vector<Vector2> arrayForDirection;
191    while (SkPath::kDone_Verb != (v = iter.next(pts))) {
192            switch (v) {
193            case SkPath::kMove_Verb:
194                arrayForDirection.add((Vector2){pts[0].x(), pts[0].y()});
195                break;
196            case SkPath::kLine_Verb:
197                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
198                break;
199            case SkPath::kConic_Verb:
200            case SkPath::kQuad_Verb:
201                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
202                arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()});
203                break;
204            case SkPath::kCubic_Verb:
205                arrayForDirection.add((Vector2){pts[1].x(), pts[1].y()});
206                arrayForDirection.add((Vector2){pts[2].x(), pts[2].y()});
207                arrayForDirection.add((Vector2){pts[3].x(), pts[3].y()});
208                break;
209            default:
210                break;
211            }
212    }
213
214    return isClockwise(arrayForDirection.array(), arrayForDirection.size());
215}
216
217void ShadowTessellator::reverseVertexArray(Vertex* polygon, int len) {
218    int n = len / 2;
219    for (int i = 0; i < n; i++) {
220        Vertex tmp = polygon[i];
221        int k = len - 1 - i;
222        polygon[i] = polygon[k];
223        polygon[k] = tmp;
224    }
225}
226
227int ShadowTessellator::getExtraVertexNumber(const Vector2& vector1,
228        const Vector2& vector2, float divisor) {
229    // When there is no distance difference, there is no need for extra vertices.
230    if (vector1.lengthSquared() == 0 || vector2.lengthSquared() == 0) {
231        return 0;
232    }
233    // The formula is :
234    // extraNumber = floor(acos(dot(n1, n2)) / (M_PI / EXTRA_VERTEX_PER_PI))
235    // The value ranges for each step are:
236    // dot( ) --- [-1, 1]
237    // acos( )     --- [0, M_PI]
238    // floor(...)  --- [0, EXTRA_VERTEX_PER_PI]
239    float dotProduct = vector1.dot(vector2);
240    // TODO: Use look up table for the dotProduct to extraVerticesNumber
241    // computation, if needed.
242    float angle = acosf(dotProduct);
243    return (int) floor(angle / divisor);
244}
245
246void ShadowTessellator::checkOverflow(int used, int total, const char* bufferName) {
247    LOG_ALWAYS_FATAL_IF(used > total, "Error: %s overflow!!! used %d, total %d",
248            bufferName, used, total);
249}
250
251}; // namespace uirenderer
252}; // namespace android
253