summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libs/hwui/AmbientShadow.cpp306
-rw-r--r--libs/hwui/AmbientShadow.h57
-rw-r--r--libs/hwui/Android.mk2
-rw-r--r--libs/hwui/Caches.cpp4
-rw-r--r--libs/hwui/Caches.h8
-rw-r--r--libs/hwui/Debug.h3
-rw-r--r--libs/hwui/OpenGLRenderer.cpp23
-rw-r--r--libs/hwui/PathTessellator.h75
-rw-r--r--libs/hwui/ShadowTessellator.cpp73
-rw-r--r--libs/hwui/ShadowTessellator.h37
-rw-r--r--libs/hwui/VertexBuffer.h102
11 files changed, 595 insertions, 95 deletions
diff --git a/libs/hwui/AmbientShadow.cpp b/libs/hwui/AmbientShadow.cpp
new file mode 100644
index 0000000..923571e
--- /dev/null
+++ b/libs/hwui/AmbientShadow.cpp
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "OpenGLRenderer"
+
+#include <math.h>
+#include <utils/Log.h>
+
+#include "AmbientShadow.h"
+#include "Vertex.h"
+
+namespace android {
+namespace uirenderer {
+
+/**
+ * Calculate the shadows as a triangle strips while alpha value as the
+ * shadow values.
+ *
+ * @param vertices The shadow caster's polygon, which is represented in a Vector3
+ * array.
+ * @param vertexCount The length of caster's polygon in terms of number of
+ * vertices.
+ * @param rays The number of rays shooting out from the centroid.
+ * @param layers The number of rings outside the polygon.
+ * @param strength The darkness of the shadow, the higher, the darker.
+ * @param heightFactor The factor showing the higher the object, the lighter the
+ * shadow.
+ * @param geomFactor The factor scaling the geometry expansion along the normal.
+ *
+ * @param shadowVertexBuffer Return an floating point array of (x, y, a)
+ * triangle strips mode.
+ */
+void AmbientShadow::createAmbientShadow(const Vector3* vertices, int vertexCount,
+ int rays, int layers, float strength, float heightFactor, float geomFactor,
+ VertexBuffer& shadowVertexBuffer) {
+
+ // Validate the inputs.
+ if (strength <= 0 || heightFactor <= 0 || layers <= 0 || rays <= 0
+ || geomFactor <= 0) {
+#if DEBUG_SHADOW
+ ALOGE("Invalid input for createAmbientShadow(), early return!");
+#endif
+ return;
+ }
+ int rings = layers + 1;
+ int size = rays * rings;
+ Vector2 centroid;
+ calculatePolygonCentroid(vertices, vertexCount, centroid);
+
+ Vector2 dir[rays];
+ float rayDist[rays];
+ float rayHeight[rays];
+ calculateRayDirections(rays, dir);
+
+ // Calculate the length and height of the points along the edge.
+ //
+ // The math here is:
+ // Intersect each ray (starting from the centroid) with the polygon.
+ for (int i = 0; i < rays; i++) {
+ int edgeIndex;
+ float edgeFraction;
+ float rayDistance;
+ calculateIntersection(vertices, vertexCount, centroid, dir[i], edgeIndex,
+ edgeFraction, rayDistance);
+ rayDist[i] = rayDistance;
+ if (edgeIndex < 0 || edgeIndex >= vertexCount) {
+#if DEBUG_SHADOW
+ ALOGE("Invalid edgeIndex!");
+#endif
+ edgeIndex = 0;
+ }
+ float h1 = vertices[edgeIndex].z;
+ float h2 = vertices[((edgeIndex + 1) % vertexCount)].z;
+ rayHeight[i] = h1 + edgeFraction * (h2 - h1);
+ }
+
+ // The output buffer length basically is roughly rays * layers, but since we
+ // need triangle strips, so we need to duplicate vertices to accomplish that.
+ const int shadowVertexCount = (2 + rays + ((layers) * 2 * (rays + 1)));
+ AlphaVertex* shadowVertices = shadowVertexBuffer.alloc<AlphaVertex>(shadowVertexCount);
+
+ // Calculate the vertex of the shadows.
+ //
+ // The math here is:
+ // Along the edges of the polygon, for each intersection point P (generated above),
+ // calculate the normal N, which should be perpendicular to the edge of the
+ // polygon (represented by the neighbor intersection points) .
+ // Shadow's vertices will be generated as : P + N * scale.
+ int currentIndex = 0;
+ for (int r = 0; r < layers; r++) {
+ int firstInLayer = currentIndex;
+ for (int i = 0; i < rays; i++) {
+
+ Vector2 normal(1.0f, 0.0f);
+ calculateNormal(rays, i, dir, rayDist, normal);
+
+ float opacity = strength * (0.5f) / (1 + rayHeight[i] / heightFactor);
+
+ // The vertex should be start from rayDist[i] then scale the
+ // normalizeNormal!
+ Vector2 intersection = dir[i] * rayDist[i] + centroid;
+
+ // Use 2 rings' vertices to complete one layer's strip
+ for (int j = r; j < (r + 2); j++) {
+ float jf = j / (float)(rings - 1);
+
+ float expansionDist = rayHeight[i] / heightFactor * geomFactor * jf;
+ AlphaVertex::set(&shadowVertices[currentIndex],
+ intersection.x + normal.x * expansionDist,
+ intersection.y + normal.y * expansionDist,
+ (1 - jf) * opacity);
+ currentIndex++;
+ }
+ }
+
+ // From one layer to the next, we need to duplicate the vertex to
+ // continue as a single strip.
+ shadowVertices[currentIndex] = shadowVertices[firstInLayer];
+ currentIndex++;
+ shadowVertices[currentIndex] = shadowVertices[firstInLayer + 1];
+ currentIndex++;
+ }
+
+ // After all rings are done, we need to jump into the polygon.
+ // In order to keep everything in a strip, we need to duplicate the last one
+ // of the rings and the first one inside the polygon.
+ int lastInRings = currentIndex - 1;
+ shadowVertices[currentIndex] = shadowVertices[lastInRings];
+ currentIndex++;
+
+ // We skip one and fill it back after we finish the internal triangles.
+ currentIndex++;
+ int firstInternal = currentIndex;
+
+ // Combine the internal area of the polygon into a triangle strip, too.
+ // The basic idea is zig zag between the intersection points.
+ // 0 -> (n - 1) -> 1 -> (n - 2) ...
+ for (int k = 0; k < rays; k++) {
+ int i = k / 2;
+ if ((k & 1) == 1) { // traverse the inside in a zig zag pattern for strips
+ i = rays - i - 1;
+ }
+ float cast = rayDist[i] * (1 + rayHeight[i] / heightFactor);
+ float opacity = strength * (0.5f) / (1 + rayHeight[i] / heightFactor);
+ float t = rayDist[i];
+
+ AlphaVertex::set(&shadowVertices[currentIndex], dir[i].x * t + centroid.x,
+ dir[i].y * t + centroid.y, opacity);
+ currentIndex++;
+ }
+
+ currentIndex = firstInternal - 1;
+ shadowVertices[currentIndex] = shadowVertices[firstInternal];
+}
+
+/**
+ * Calculate the centroid of a given polygon.
+ *
+ * @param vertices The shadow caster's polygon, which is represented in a
+ * straight Vector3 array.
+ * @param vertexCount The length of caster's polygon in terms of number of vertices.
+ *
+ * @param centroid Return the centroid of the polygon.
+ */
+void AmbientShadow::calculatePolygonCentroid(const Vector3* vertices, int vertexCount,
+ Vector2& centroid) {
+ float sumx = 0;
+ float sumy = 0;
+ int p1 = vertexCount - 1;
+ float area = 0;
+ for (int p2 = 0; p2 < vertexCount; p2++) {
+ float x1 = vertices[p1].x;
+ float y1 = vertices[p1].y;
+ float x2 = vertices[p2].x;
+ float y2 = vertices[p2].y;
+ float a = (x1 * y2 - x2 * y1);
+ sumx += (x1 + x2) * a;
+ sumy += (y1 + y2) * a;
+ area += a;
+ p1 = p2;
+ }
+
+ if (area == 0) {
+#if DEBUG_SHADOW
+ ALOGE("Area is 0!");
+#endif
+ centroid.x = vertices[0].x;
+ centroid.y = vertices[0].y;
+ } else {
+ centroid.x = sumx / (3 * area);
+ centroid.y = sumy / (3 * area);
+ }
+}
+
+/**
+ * Generate an array of rays' direction vectors.
+ *
+ * @param rays The number of rays shooting out from the centroid.
+ * @param dir Return the array of ray vectors.
+ */
+void AmbientShadow::calculateRayDirections(int rays, Vector2* dir) {
+ float deltaAngle = 2 * M_PI / rays;
+
+ for (int i = 0; i < rays; i++) {
+ dir[i].x = sinf(deltaAngle * i);
+ dir[i].y = cosf(deltaAngle * i);
+ }
+}
+
+/**
+ * Calculate the intersection of a ray hitting the polygon.
+ *
+ * @param vertices The shadow caster's polygon, which is represented in a
+ * Vector3 array.
+ * @param vertexCount The length of caster's polygon in terms of number of vertices.
+ * @param start The starting point of the ray.
+ * @param dir The direction vector of the ray.
+ *
+ * @param outEdgeIndex Return the index of the segment (or index of the starting
+ * vertex) that ray intersect with.
+ * @param outEdgeFraction Return the fraction offset from the segment starting
+ * index.
+ * @param outRayDist Return the ray distance from centroid to the intersection.
+ */
+void AmbientShadow::calculateIntersection(const Vector3* vertices, int vertexCount,
+ const Vector2& start, const Vector2& dir, int& outEdgeIndex,
+ float& outEdgeFraction, float& outRayDist) {
+ float startX = start.x;
+ float startY = start.y;
+ float dirX = dir.x;
+ float dirY = dir.y;
+ // Start the search from the last edge from poly[len-1] to poly[0].
+ int p1 = vertexCount - 1;
+
+ for (int p2 = 0; p2 < vertexCount; p2++) {
+ float p1x = vertices[p1].x;
+ float p1y = vertices[p1].y;
+ float p2x = vertices[p2].x;
+ float p2y = vertices[p2].y;
+
+ // The math here is derived from:
+ // f(t, v) = p1x * (1 - t) + p2x * t - (startX + dirX * v) = 0;
+ // g(t, v) = p1y * (1 - t) + p2y * t - (startY + dirY * v) = 0;
+ float div = (dirX * (p1y - p2y) + dirY * p2x - dirY * p1x);
+ if (div != 0) {
+ float t = (dirX * (p1y - startY) + dirY * startX - dirY * p1x) / (div);
+ if (t > 0 && t <= 1) {
+ float t2 = (p1x * (startY - p2y)
+ + p2x * (p1y - startY)
+ + startX * (p2y - p1y)) / div;
+ if (t2 > 0) {
+ outEdgeIndex = p1;
+ outRayDist = t2;
+ outEdgeFraction = t;
+ return;
+ }
+ }
+ }
+ p1 = p2;
+ }
+ return;
+};
+
+/**
+ * Calculate the normal at the intersection point between a ray and the polygon.
+ *
+ * @param rays The total number of rays.
+ * @param currentRayIndex The index of the ray which the normal is based on.
+ * @param dir The array of the all the rays directions.
+ * @param rayDist The pre-computed ray distances array.
+ *
+ * @param normal Return the normal.
+ */
+void AmbientShadow::calculateNormal(int rays, int currentRayIndex,
+ const Vector2* dir, const float* rayDist, Vector2& normal) {
+ int preIndex = (currentRayIndex - 1 + rays) % rays;
+ int postIndex = (currentRayIndex + 1) % rays;
+ Vector2 p1 = dir[preIndex] * rayDist[preIndex];
+ Vector2 p2 = dir[postIndex] * rayDist[postIndex];
+
+ // Now the V (deltaX, deltaY) is the vector going CW around the poly.
+ Vector2 delta = p2 - p1;
+ if (delta.length() != 0) {
+ delta.normalize();
+ // Calculate the normal , which is CCW 90 rotate to the V.
+ // 90 degrees CCW about z-axis: (x, y, z) -> (-y, x, z)
+ normal.x = -delta.y;
+ normal.y = delta.x;
+ }
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/AmbientShadow.h b/libs/hwui/AmbientShadow.h
new file mode 100644
index 0000000..079bdb7
--- /dev/null
+++ b/libs/hwui/AmbientShadow.h
@@ -0,0 +1,57 @@
+
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HWUI_AMBIENT_SHADOW_H
+#define ANDROID_HWUI_AMBIENT_SHADOW_H
+
+#include "Debug.h"
+#include "Vector.h"
+#include "VertexBuffer.h"
+
+namespace android {
+namespace uirenderer {
+
+/**
+ * AmbientShadow is used to calculate the ambient shadow value around a polygon.
+ *
+ * TODO: calculateIntersection() now is O(N*M), where N is the number of
+ * polygon's vertics and M is the number of rays. In fact, by staring tracing
+ * the vertex from the previous intersection, the algorithm can be O(N + M);
+ */
+class AmbientShadow {
+public:
+ static void createAmbientShadow(const Vector3* poly, int polyLength, int rays,
+ int layers, float strength, float heightFactor, float geomFactor,
+ VertexBuffer& shadowVertexBuffer);
+
+private:
+ static void calculatePolygonCentroid(const Vector3* poly, int len, Vector2& centroid);
+
+ static void calculateRayDirections(int rays, Vector2* dir);
+
+ static void calculateIntersection(const Vector3* poly, int nbVertices,
+ const Vector2& start, const Vector2& dir, int& outEdgeIndex,
+ float& outEdgeFraction, float& outRayDist);
+
+ static void calculateNormal(int rays, int currentRayIndex, const Vector2* dir,
+ const float* rayDist, Vector2& normal);
+}; // AmbientShadow
+
+}; // namespace uirenderer
+}; // namespace android
+
+#endif // ANDROID_HWUI_AMBIENT_SHADOW_H
diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk
index 1f37925..962d726 100644
--- a/libs/hwui/Android.mk
+++ b/libs/hwui/Android.mk
@@ -10,6 +10,7 @@ ifeq ($(USE_OPENGL_RENDERER),true)
thread/TaskManager.cpp \
font/CacheTexture.cpp \
font/Font.cpp \
+ AmbientShadow.cpp \
AssetAtlas.cpp \
FontRenderer.cpp \
GammaFontRenderer.cpp \
@@ -37,6 +38,7 @@ ifeq ($(USE_OPENGL_RENDERER),true)
ProgramCache.cpp \
RenderBufferCache.cpp \
ResourceCache.cpp \
+ ShadowTessellator.cpp \
SkiaColorFilter.cpp \
SkiaShader.cpp \
Snapshot.cpp \
diff --git a/libs/hwui/Caches.cpp b/libs/hwui/Caches.cpp
index f8d3589..5b751b9 100644
--- a/libs/hwui/Caches.cpp
+++ b/libs/hwui/Caches.cpp
@@ -473,7 +473,7 @@ bool Caches::unbindPixelBuffer() {
// Meshes and textures
///////////////////////////////////////////////////////////////////////////////
-void Caches::bindPositionVertexPointer(bool force, GLvoid* vertices, GLsizei stride) {
+void Caches::bindPositionVertexPointer(bool force, const GLvoid* vertices, GLsizei stride) {
if (force || vertices != mCurrentPositionPointer || stride != mCurrentPositionStride) {
GLuint slot = currentProgram->position;
glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
@@ -482,7 +482,7 @@ void Caches::bindPositionVertexPointer(bool force, GLvoid* vertices, GLsizei str
}
}
-void Caches::bindTexCoordsVertexPointer(bool force, GLvoid* vertices, GLsizei stride) {
+void Caches::bindTexCoordsVertexPointer(bool force, const GLvoid* vertices, GLsizei stride) {
if (force || vertices != mCurrentTexCoordsPointer || stride != mCurrentTexCoordsStride) {
GLuint slot = currentProgram->texCoords;
glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
diff --git a/libs/hwui/Caches.h b/libs/hwui/Caches.h
index f8f2284..963965d 100644
--- a/libs/hwui/Caches.h
+++ b/libs/hwui/Caches.h
@@ -208,13 +208,13 @@ public:
* Binds an attrib to the specified float vertex pointer.
* Assumes a stride of gMeshStride and a size of 2.
*/
- void bindPositionVertexPointer(bool force, GLvoid* vertices, GLsizei stride = gMeshStride);
+ void bindPositionVertexPointer(bool force, const GLvoid* vertices, GLsizei stride = gMeshStride);
/**
* Binds an attrib to the specified float vertex pointer.
* Assumes a stride of gMeshStride and a size of 2.
*/
- void bindTexCoordsVertexPointer(bool force, GLvoid* vertices, GLsizei stride = gMeshStride);
+ void bindTexCoordsVertexPointer(bool force, const GLvoid* vertices, GLsizei stride = gMeshStride);
/**
* Resets the vertex pointers.
@@ -379,9 +379,9 @@ private:
GLuint mCurrentBuffer;
GLuint mCurrentIndicesBuffer;
GLuint mCurrentPixelBuffer;
- void* mCurrentPositionPointer;
+ const void* mCurrentPositionPointer;
GLsizei mCurrentPositionStride;
- void* mCurrentTexCoordsPointer;
+ const void* mCurrentTexCoordsPointer;
GLsizei mCurrentTexCoordsStride;
bool mTexCoordsArrayEnabled;
diff --git a/libs/hwui/Debug.h b/libs/hwui/Debug.h
index 79afad1..f619205 100644
--- a/libs/hwui/Debug.h
+++ b/libs/hwui/Debug.h
@@ -88,6 +88,9 @@
// Turn on to enable 3D support in the renderer (off by default until API for control exists)
#define DEBUG_ENABLE_3D 0
+// Turn on to enable debugging shadow
+#define DEBUG_SHADOW 0
+
#if DEBUG_INIT
#define INIT_LOGD(...) ALOGD(__VA_ARGS__)
#else
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 79df520..578a251 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -36,7 +36,9 @@
#include "Fence.h"
#include "PathTessellator.h"
#include "Properties.h"
+#include "ShadowTessellator.h"
#include "Vector.h"
+#include "VertexBuffer.h"
namespace android {
namespace uirenderer {
@@ -2579,7 +2581,7 @@ status_t OpenGLRenderer::drawVertexBuffer(const VertexBuffer& vertexBuffer, SkPa
setupDrawColorFilterUniforms();
setupDrawShaderUniforms();
- void* vertices = vertexBuffer.getBuffer();
+ const void* vertices = vertexBuffer.getBuffer();
bool force = mCaches.unbindMeshBuffer();
mCaches.bindPositionVertexPointer(true, vertices, isAA ? gAlphaVertexStride : gVertexStride);
mCaches.resetTexCoordsVertexPointer();
@@ -3393,22 +3395,13 @@ status_t OpenGLRenderer::drawShadow(const mat4& casterTransform, float casterAlp
SkPaint paint;
paint.setColor(0x3f000000);
+ // Force the draw to use alpha values.
paint.setAntiAlias(true);
- VertexBuffer vertexBuffer;
- {
- //TODO: populate vertex buffer with better shadow geometry.
- Vector3 pivot(width/2, height/2, 0.0f);
- casterTransform.mapPoint3d(pivot);
-
- float zScaleFactor = 0.5 + 0.0005f * pivot.z;
-
- SkPath path;
- path.addRect(pivot.x - width * zScaleFactor, pivot.y - height * zScaleFactor,
- pivot.x + width * zScaleFactor, pivot.y + height * zScaleFactor);
- PathTessellator::tessellatePath(path, &paint, mSnapshot->transform, vertexBuffer);
- }
- return drawVertexBuffer(vertexBuffer, &paint);
+ VertexBuffer shadowVertexBuffer;
+ ShadowTessellator::tessellateAmbientShadow(width, height, casterTransform,
+ shadowVertexBuffer);
+ return drawVertexBuffer(shadowVertexBuffer, &paint);
}
status_t OpenGLRenderer::drawColorRects(const float* rects, int count, int color,
diff --git a/libs/hwui/PathTessellator.h b/libs/hwui/PathTessellator.h
index e0044e8..236658d 100644
--- a/libs/hwui/PathTessellator.h
+++ b/libs/hwui/PathTessellator.h
@@ -22,84 +22,11 @@
#include "Matrix.h"
#include "Rect.h"
#include "Vertex.h"
+#include "VertexBuffer.h"
namespace android {
namespace uirenderer {
-class VertexBuffer {
-public:
- VertexBuffer():
- mBuffer(0),
- mVertexCount(0),
- mCleanupMethod(NULL)
- {}
-
- ~VertexBuffer() {
- if (mCleanupMethod) mCleanupMethod(mBuffer);
- }
-
- /**
- This should be the only method used by the PathTessellator. Subsequent calls to alloc will
- allocate space within the first allocation (useful if you want to eventually allocate
- multiple regions within a single VertexBuffer, such as with PathTessellator::tesselateLines()
- */
- template <class TYPE>
- TYPE* alloc(int vertexCount) {
- if (mVertexCount) {
- TYPE* reallocBuffer = (TYPE*)mReallocBuffer;
- // already have allocated the buffer, re-allocate space within
- if (mReallocBuffer != mBuffer) {
- // not first re-allocation, leave space for degenerate triangles to separate strips
- reallocBuffer += 2;
- }
- mReallocBuffer = reallocBuffer + vertexCount;
- return reallocBuffer;
- }
- mVertexCount = vertexCount;
- mReallocBuffer = mBuffer = (void*)new TYPE[vertexCount];
- mCleanupMethod = &(cleanup<TYPE>);
-
- return (TYPE*)mBuffer;
- }
-
- template <class TYPE>
- void copyInto(const VertexBuffer& srcBuffer, float xOffset, float yOffset) {
- int verticesToCopy = srcBuffer.getVertexCount();
-
- TYPE* dst = alloc<TYPE>(verticesToCopy);
- TYPE* src = (TYPE*)srcBuffer.getBuffer();
-
- for (int i = 0; i < verticesToCopy; i++) {
- TYPE::copyWithOffset(&dst[i], src[i], xOffset, yOffset);
- }
- }
-
- void* getBuffer() const { return mBuffer; } // shouldn't be const, since not a const ptr?
- unsigned int getVertexCount() const { return mVertexCount; }
-
- template <class TYPE>
- void createDegenerateSeparators(int allocSize) {
- TYPE* end = (TYPE*)mBuffer + mVertexCount;
- for (TYPE* degen = (TYPE*)mBuffer + allocSize; degen < end; degen += 2 + allocSize) {
- memcpy(degen, degen - 1, sizeof(TYPE));
- memcpy(degen + 1, degen + 2, sizeof(TYPE));
- }
- }
-
-private:
- template <class TYPE>
- static void cleanup(void* buffer) {
- delete[] (TYPE*)buffer;
- }
-
- void* mBuffer;
- unsigned int mVertexCount;
-
- void* mReallocBuffer; // used for multi-allocation
-
- void (*mCleanupMethod)(void*);
-};
-
class PathTessellator {
public:
static void expandBoundsForStroke(SkRect& bounds, const SkPaint* paint);
diff --git a/libs/hwui/ShadowTessellator.cpp b/libs/hwui/ShadowTessellator.cpp
new file mode 100644
index 0000000..49a3d2c
--- /dev/null
+++ b/libs/hwui/ShadowTessellator.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "OpenGLRenderer"
+
+#include <math.h>
+#include <utils/Log.h>
+
+#include "AmbientShadow.h"
+#include "ShadowTessellator.h"
+
+namespace android {
+namespace uirenderer {
+
+// TODO: Support path as the input of the polygon instead of the rect's width
+// and height.
+void ShadowTessellator::tessellateAmbientShadow(float width, float height,
+ const mat4& casterTransform, VertexBuffer& shadowVertexBuffer) {
+
+ Vector3 pivot(width / 2, height / 2, 0.0f);
+ casterTransform.mapPoint3d(pivot);
+
+ // TODO: The zScaleFactor need to be mapped to the screen.
+ float zScaleFactor = 0.5;
+ Rect blockRect(pivot.x - width * zScaleFactor, pivot.y - height * zScaleFactor,
+ pivot.x + width * zScaleFactor, pivot.y + height * zScaleFactor);
+
+ // Generate the caster's polygon from the rect.
+ // TODO: support arbitrary polygon, and the z value need to be computed
+ // according to the transformation for each vertex.
+ const int vertexCount = 4;
+ Vector3 polygon[vertexCount];
+ polygon[0].x = blockRect.left;
+ polygon[0].y = blockRect.top;
+ polygon[0].z = pivot.z;
+ polygon[1].x = blockRect.right;
+ polygon[1].y = blockRect.top;
+ polygon[1].z = pivot.z;
+ polygon[2].x = blockRect.right;
+ polygon[2].y = blockRect.bottom;
+ polygon[2].z = pivot.z;
+ polygon[3].x = blockRect.left;
+ polygon[3].y = blockRect.bottom;
+ polygon[3].z = pivot.z;
+
+ // A bunch of parameters to tweak the shadow.
+ // TODO: Allow some of these changable by debug settings or APIs.
+ const int rays = 120;
+ const int layers = 2;
+ const float strength = 0.5;
+ const float heightFactor = 120;
+ const float geomFactor = 60;
+
+ AmbientShadow::createAmbientShadow(polygon, vertexCount, rays, layers, strength,
+ heightFactor, geomFactor, shadowVertexBuffer);
+
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/ShadowTessellator.h b/libs/hwui/ShadowTessellator.h
new file mode 100644
index 0000000..05cb00c
--- /dev/null
+++ b/libs/hwui/ShadowTessellator.h
@@ -0,0 +1,37 @@
+
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HWUI_SHADOW_TESSELLATOR_H
+#define ANDROID_HWUI_SHADOW_TESSELLATOR_H
+
+#include "Debug.h"
+#include "Matrix.h"
+
+namespace android {
+namespace uirenderer {
+
+class ShadowTessellator {
+public:
+ static void tessellateAmbientShadow(float width, float height,
+ const mat4& casterTransform, VertexBuffer& shadowVertexBuffer);
+
+}; // ShadowTessellator
+
+}; // namespace uirenderer
+}; // namespace android
+
+#endif // ANDROID_HWUI_SHADOW_TESSELLATOR_H
diff --git a/libs/hwui/VertexBuffer.h b/libs/hwui/VertexBuffer.h
new file mode 100644
index 0000000..8b6872e
--- /dev/null
+++ b/libs/hwui/VertexBuffer.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HWUI_VERTEX_BUFFER_H
+#define ANDROID_HWUI_VERTEX_BUFFER_H
+
+
+namespace android {
+namespace uirenderer {
+
+class VertexBuffer {
+public:
+ VertexBuffer():
+ mBuffer(0),
+ mVertexCount(0),
+ mCleanupMethod(NULL)
+ {}
+
+ ~VertexBuffer() {
+ if (mCleanupMethod) mCleanupMethod(mBuffer);
+ }
+
+ /**
+ This should be the only method used by the Tessellator. Subsequent calls to
+ alloc will allocate space within the first allocation (useful if you want to
+ eventually allocate multiple regions within a single VertexBuffer, such as
+ with PathTessellator::tesselateLines())
+ */
+ template <class TYPE>
+ TYPE* alloc(int vertexCount) {
+ if (mVertexCount) {
+ TYPE* reallocBuffer = (TYPE*)mReallocBuffer;
+ // already have allocated the buffer, re-allocate space within
+ if (mReallocBuffer != mBuffer) {
+ // not first re-allocation, leave space for degenerate triangles to separate strips
+ reallocBuffer += 2;
+ }
+ mReallocBuffer = reallocBuffer + vertexCount;
+ return reallocBuffer;
+ }
+ mVertexCount = vertexCount;
+ mReallocBuffer = mBuffer = (void*)new TYPE[vertexCount];
+ mCleanupMethod = &(cleanup<TYPE>);
+
+ return (TYPE*)mBuffer;
+ }
+
+ template <class TYPE>
+ void copyInto(const VertexBuffer& srcBuffer, float xOffset, float yOffset) {
+ int verticesToCopy = srcBuffer.getVertexCount();
+
+ TYPE* dst = alloc<TYPE>(verticesToCopy);
+ TYPE* src = (TYPE*)srcBuffer.getBuffer();
+
+ for (int i = 0; i < verticesToCopy; i++) {
+ TYPE::copyWithOffset(&dst[i], src[i], xOffset, yOffset);
+ }
+ }
+
+ const void* getBuffer() const { return mBuffer; }
+ unsigned int getVertexCount() const { return mVertexCount; }
+
+ template <class TYPE>
+ void createDegenerateSeparators(int allocSize) {
+ TYPE* end = (TYPE*)mBuffer + mVertexCount;
+ for (TYPE* degen = (TYPE*)mBuffer + allocSize; degen < end; degen += 2 + allocSize) {
+ memcpy(degen, degen - 1, sizeof(TYPE));
+ memcpy(degen + 1, degen + 2, sizeof(TYPE));
+ }
+ }
+
+private:
+ template <class TYPE>
+ static void cleanup(void* buffer) {
+ delete[] (TYPE*)buffer;
+ }
+
+ void* mBuffer;
+ unsigned int mVertexCount;
+
+ void* mReallocBuffer; // used for multi-allocation
+
+ void (*mCleanupMethod)(void*);
+};
+
+}; // namespace uirenderer
+}; // namespace android
+
+#endif // ANDROID_HWUI_VERTEX_BUFFER_H
generated by cgit v1.1 at 2025-01-27 19:35:15 +0000