ShadowTessellator.cpp revision 1240752c44c21632adaf64f6768669ec6d0ebc8c 
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
32namespace android {
33namespace uirenderer {
34
35void 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
65void 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 */
123Vector2 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.
151Vector2 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
163int 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
184void 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