ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 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" |
Chris Craik | 87f9df8 | 2014-03-07 14:34:42 -0800 | [diff] [blame] | 18 | #define ATRACE_TAG ATRACE_TAG_VIEW |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 19 | |
| 20 | #include <math.h> |
| 21 | #include <utils/Log.h> |
Chris Craik | 87f9df8 | 2014-03-07 14:34:42 -0800 | [diff] [blame] | 22 | #include <utils/Trace.h> |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 23 | |
| 24 | #include "AmbientShadow.h" |
| 25 | #include "ShadowTessellator.h" |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 26 | #include "SpotShadow.h" |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 27 | |
| 28 | namespace android { |
| 29 | namespace uirenderer { |
| 30 | |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 31 | template<typename T> |
| 32 | static inline T max(T a, T b) { |
| 33 | return a > b ? a : b; |
| 34 | } |
| 35 | |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 36 | VertexBufferMode ShadowTessellator::tessellateAmbientShadow(bool isCasterOpaque, |
| 37 | const Vector3* casterPolygon, int casterVertexCount, |
ztenghui | af6f7ed | 2014-03-18 17:25:49 -0700 | [diff] [blame^] | 38 | const Vector3& centroid3d, const Rect& casterBounds, |
| 39 | const Rect& localClip, float maxZ, VertexBuffer& shadowVertexBuffer) { |
Chris Craik | 87f9df8 | 2014-03-07 14:34:42 -0800 | [diff] [blame] | 40 | ATRACE_CALL(); |
| 41 | |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 42 | // A bunch of parameters to tweak the shadow. |
| 43 | // TODO: Allow some of these changable by debug settings or APIs. |
Chris Craik | 726118b | 2014-03-07 18:27:49 -0800 | [diff] [blame] | 44 | const float heightFactor = 1.0f / 128; |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 45 | const float geomFactor = 64; |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 46 | |
ztenghui | af6f7ed | 2014-03-18 17:25:49 -0700 | [diff] [blame^] | 47 | Rect ambientShadowBounds(casterBounds); |
| 48 | ambientShadowBounds.outset(maxZ * geomFactor * heightFactor); |
| 49 | |
| 50 | if (!localClip.intersects(ambientShadowBounds)) { |
| 51 | #if DEBUG_SHADOW |
| 52 | ALOGD("Ambient shadow is out of clip rect!"); |
| 53 | #endif |
| 54 | return kVertexBufferMode_OnePolyRingShadow; |
| 55 | } |
| 56 | |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 57 | return AmbientShadow::createAmbientShadow(isCasterOpaque, casterPolygon, |
| 58 | casterVertexCount, centroid3d, heightFactor, geomFactor, |
| 59 | shadowVertexBuffer); |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 60 | |
| 61 | } |
| 62 | |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 63 | VertexBufferMode ShadowTessellator::tessellateSpotShadow(bool isCasterOpaque, |
| 64 | const Vector3* casterPolygon, int casterVertexCount, |
ztenghui | cc3c256 | 2014-01-17 10:34:10 -0800 | [diff] [blame] | 65 | const Vector3& lightPosScale, const mat4& receiverTransform, |
ztenghui | af6f7ed | 2014-03-18 17:25:49 -0700 | [diff] [blame^] | 66 | int screenWidth, int screenHeight, const Rect& casterBounds, |
| 67 | const Rect& localClip, VertexBuffer& shadowVertexBuffer) { |
Chris Craik | 87f9df8 | 2014-03-07 14:34:42 -0800 | [diff] [blame] | 68 | ATRACE_CALL(); |
| 69 | |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 70 | // A bunch of parameters to tweak the shadow. |
| 71 | // TODO: Allow some of these changable by debug settings or APIs. |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 72 | int maximal = max(screenWidth, screenHeight); |
ztenghui | cc3c256 | 2014-01-17 10:34:10 -0800 | [diff] [blame] | 73 | Vector3 lightCenter(screenWidth * lightPosScale.x, screenHeight * lightPosScale.y, |
| 74 | maximal * lightPosScale.z); |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 75 | #if DEBUG_SHADOW |
| 76 | ALOGD("light center %f %f %f", lightCenter.x, lightCenter.y, lightCenter.z); |
| 77 | #endif |
Chris Craik | 3197cde | 2014-01-16 14:03:39 -0800 | [diff] [blame] | 78 | |
| 79 | // light position (because it's in local space) needs to compensate for receiver transform |
| 80 | // TODO: should apply to light orientation, not just position |
| 81 | Matrix4 reverseReceiverTransform; |
| 82 | reverseReceiverTransform.loadInverse(receiverTransform); |
| 83 | reverseReceiverTransform.mapPoint3d(lightCenter); |
| 84 | |
ztenghui | cc3c256 | 2014-01-17 10:34:10 -0800 | [diff] [blame] | 85 | const float lightSize = maximal / 4; |
Chris Craik | 726118b | 2014-03-07 18:27:49 -0800 | [diff] [blame] | 86 | const int lightVertexCount = 8; |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 87 | |
ztenghui | af6f7ed | 2014-03-18 17:25:49 -0700 | [diff] [blame^] | 88 | // Now light and caster are both in local space, we will check whether |
| 89 | // the shadow is within the clip area. |
| 90 | Rect lightRect = Rect(lightCenter.x - lightSize, lightCenter.y - lightSize, |
| 91 | lightCenter.x + lightSize, lightCenter.y + lightSize); |
| 92 | lightRect.unionWith(localClip); |
| 93 | if (!lightRect.intersects(casterBounds)) { |
| 94 | #if DEBUG_SHADOW |
| 95 | ALOGD("Spot shadow is out of clip rect!"); |
| 96 | #endif |
| 97 | return kVertexBufferMode_OnePolyRingShadow; |
| 98 | } |
| 99 | |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 100 | VertexBufferMode mode = SpotShadow::createSpotShadow(isCasterOpaque, |
| 101 | casterPolygon, casterVertexCount, lightCenter, lightSize, |
| 102 | lightVertexCount, shadowVertexBuffer); |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 103 | |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 104 | #if DEBUG_SHADOW |
| 105 | if(shadowVertexBuffer.getVertexCount() <= 0) { |
| 106 | ALOGD("Spot shadow generation failed %d", shadowVertexBuffer.getVertexCount()); |
| 107 | } |
| 108 | #endif |
| 109 | return mode; |
ztenghui | 7b4516e | 2014-01-07 10:42:55 -0800 | [diff] [blame] | 110 | } |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 111 | |
| 112 | void ShadowTessellator::generateShadowIndices(uint16_t* shadowIndices) { |
| 113 | int currentIndex = 0; |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 114 | const int rays = SHADOW_RAY_COUNT; |
| 115 | // For the penumbra area. |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 116 | for (int layer = 0; layer < 2; layer ++) { |
| 117 | int baseIndex = layer * rays; |
| 118 | for (int i = 0; i < rays; i++) { |
| 119 | shadowIndices[currentIndex++] = i + baseIndex; |
| 120 | shadowIndices[currentIndex++] = rays + i + baseIndex; |
| 121 | } |
| 122 | // To close the loop, back to the ray 0. |
| 123 | shadowIndices[currentIndex++] = 0 + baseIndex; |
| 124 | // Note this is the same as the first index of next layer loop. |
| 125 | shadowIndices[currentIndex++] = rays + baseIndex; |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 126 | } |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 127 | |
| 128 | #if DEBUG_SHADOW |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 129 | if (currentIndex != MAX_SHADOW_INDEX_COUNT) { |
| 130 | ALOGW("vertex index count is wrong. current %d, expected %d", |
| 131 | currentIndex, MAX_SHADOW_INDEX_COUNT); |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 132 | } |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 133 | for (int i = 0; i < MAX_SHADOW_INDEX_COUNT; i++) { |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 134 | ALOGD("vertex index is (%d, %d)", i, shadowIndices[i]); |
| 135 | } |
| 136 | #endif |
| 137 | } |
| 138 | |
| 139 | /** |
| 140 | * Calculate the centroid of a 2d polygon. |
| 141 | * |
| 142 | * @param poly The polygon, which is represented in a Vector2 array. |
| 143 | * @param polyLength The length of the polygon in terms of number of vertices. |
| 144 | * @return the centroid of the polygon. |
| 145 | */ |
| 146 | Vector2 ShadowTessellator::centroid2d(const Vector2* poly, int polyLength) { |
| 147 | double sumx = 0; |
| 148 | double sumy = 0; |
| 149 | int p1 = polyLength - 1; |
| 150 | double area = 0; |
| 151 | for (int p2 = 0; p2 < polyLength; p2++) { |
| 152 | double x1 = poly[p1].x; |
| 153 | double y1 = poly[p1].y; |
| 154 | double x2 = poly[p2].x; |
| 155 | double y2 = poly[p2].y; |
| 156 | double a = (x1 * y2 - x2 * y1); |
| 157 | sumx += (x1 + x2) * a; |
| 158 | sumy += (y1 + y2) * a; |
| 159 | area += a; |
| 160 | p1 = p2; |
| 161 | } |
| 162 | |
| 163 | Vector2 centroid = poly[0]; |
| 164 | if (area != 0) { |
| 165 | centroid = Vector2(sumx / (3 * area), sumy / (3 * area)); |
| 166 | } else { |
ztenghui | 50ecf84 | 2014-03-11 16:52:30 -0700 | [diff] [blame] | 167 | ALOGW("Area is 0 while computing centroid!"); |
ztenghui | 63d41ab | 2014-02-14 13:13:41 -0800 | [diff] [blame] | 168 | } |
| 169 | return centroid; |
| 170 | } |
| 171 | |
ztenghui | 55bfb4e | 2013-12-03 10:38:55 -0800 | [diff] [blame] | 172 | }; // namespace uirenderer |
| 173 | }; // namespace android |