#include <math.h>
#include <utils/Log.h>
+#include <utils/Vector.h>
#include "AmbientShadow.h"
#include "Vertex.h"
Vector2 centroid;
calculatePolygonCentroid(vertices, vertexCount, centroid);
- Vector2 dir[rays];
+ Vector<Vector2> dir; // TODO: use C++11 unique_ptr
+ dir.setCapacity(rays);
float rayDist[rays];
float rayHeight[rays];
- calculateRayDirections(rays, dir);
+ calculateRayDirections(rays, dir.editArray());
// Calculate the length and height of the points along the edge.
//
for (int i = 0; i < rays; i++) {
Vector2 normal(1.0f, 0.0f);
- calculateNormal(rays, i, dir, rayDist, normal);
+ calculateNormal(rays, i, dir.array(), rayDist, normal);
float opacity = strength * (0.5f) / (1 + rayHeight[i] / heightFactor);
# Only build libhwui when USE_OPENGL_RENDERER is
# defined in the current device/board configuration
ifeq ($(USE_OPENGL_RENDERER),true)
- LOCAL_SRC_FILES:= \
+ LOCAL_SRC_FILES := \
utils/Blur.cpp \
utils/SortedListImpl.cpp \
thread/TaskManager.cpp \
handler(op, PROPERTY_SAVECOUNT, mClipToBounds);
int rootRestoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
- for (int i = 0; i < m3dNodes.size(); i++) {
+ for (size_t i = 0; i < m3dNodes.size(); i++) {
const float zValue = m3dNodes.keyAt(i);
if (mode == kPositiveZChildren && zValue < 0.0f) continue;
if (mode == kNegativeZChildren && zValue > 0.0f) break;
const Vector<DrawDisplayListOp*>& nodesAtZ = m3dNodes[i];
- for (int j = 0; j < nodesAtZ.size(); j++) {
+ for (size_t j = 0; j < nodesAtZ.size(); j++) {
DrawDisplayListOp* op = nodesAtZ[j];
if (mode == kPositiveZChildren) {
/* draw shadow on renderer with parent matrix applied, passing in the child's total matrix
/**
* A layer has dimensions and is backed by an OpenGL texture or FBO.
*/
-struct Layer {
+class Layer {
+public:
Layer(const uint32_t layerWidth, const uint32_t layerHeight);
~Layer();
GL_FALSE, &transform.data[0]);
}
-void OpenGLRenderer::setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLuint vbo) {
+void OpenGLRenderer::setupDrawMesh(const GLvoid* vertices,
+ const GLvoid* texCoords, GLuint vbo) {
bool force = false;
if (!vertices || vbo) {
force = mCaches.bindMeshBuffer(vbo == 0 ? mCaches.meshBuffer : vbo);
mCaches.unbindIndicesBuffer();
}
-void OpenGLRenderer::setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLvoid* colors) {
+void OpenGLRenderer::setupDrawMesh(const GLvoid* vertices,
+ const GLvoid* texCoords, const GLvoid* colors) {
bool force = mCaches.unbindMeshBuffer();
GLsizei stride = sizeof(ColorTextureVertex);
mCaches.unbindIndicesBuffer();
}
-void OpenGLRenderer::setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords, GLuint vbo) {
+void OpenGLRenderer::setupDrawMeshIndices(const GLvoid* vertices,
+ const GLvoid* texCoords, GLuint vbo) {
bool force = false;
// If vbo is != 0 we want to treat the vertices parameter as an offset inside
// a VBO. However, if vertices is set to NULL and vbo == 0 then we want to
const uint32_t count = meshWidth * meshHeight * 6;
- ColorTextureVertex mesh[count];
- ColorTextureVertex* vertex = mesh;
+ Vector<ColorTextureVertex> mesh; // TODO: use C++11 unique_ptr
+ mesh.setCapacity(count);
+ ColorTextureVertex* vertex = mesh.editArray();
bool cleanupColors = false;
if (!colors) {
* transformations are stored in the modelView matrix and uploaded to the shader.
*
* @param offset Set to true if the the matrix should be fudged (translated) slightly to disambiguate
- * geometry pixel positioning. See Vertex::gGeometryFudgeFactor.
+ * geometry pixel positioning. See Vertex::GeometryFudgeFactor().
*
* @param ignoreTransform Set to true if l,t,r,b coordinates already in layer space,
* currentTransform() will be ignored. (e.g. when drawing clip in layer coordinates to stencil,
void setupDrawTextureTransform();
void setupDrawTextureTransformUniforms(mat4& transform);
void setupDrawTextGammaUniforms();
- void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords = NULL, GLuint vbo = 0);
- void setupDrawMesh(GLvoid* vertices, GLvoid* texCoords, GLvoid* colors);
- void setupDrawMeshIndices(GLvoid* vertices, GLvoid* texCoords, GLuint vbo = 0);
+ void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords = NULL, GLuint vbo = 0);
+ void setupDrawMesh(const GLvoid* vertices, const GLvoid* texCoords, const GLvoid* colors);
+ void setupDrawMeshIndices(const GLvoid* vertices, const GLvoid* texCoords, GLuint vbo = 0);
void setupDrawIndexedVertices(GLvoid* vertices);
void accountForClear(SkXfermode::Mode mode);
// 9-patch structures
///////////////////////////////////////////////////////////////////////////////
-struct Patch {
+class Patch {
+public:
Patch();
~Patch();
class SkCanvas;
class SkPaint;
class SkPath;
-class SkRect;
+struct SkRect;
namespace android {
namespace uirenderer {
void expandBoundsForStrokeAA(SkRect& bounds) const {
float outset = halfStrokeWidth;
if (outset == 0) outset = 0.5f;
- bounds.outset(outset * inverseScaleX + Vertex::gGeometryFudgeFactor,
- outset * inverseScaleY + Vertex::gGeometryFudgeFactor);
+ bounds.outset(outset * inverseScaleX + Vertex::GeometryFudgeFactor(),
+ outset * inverseScaleY + Vertex::GeometryFudgeFactor());
}
};
// up and to the left.
// This offset value is based on an assumption that some hardware may use as
// little as 12.4 precision, so we offset by slightly more than 1/16.
- p.translate(Vertex::gGeometryFudgeFactor, Vertex::gGeometryFudgeFactor);
+ p.translate(Vertex::GeometryFudgeFactor(), Vertex::GeometryFudgeFactor());
glUniformMatrix4fv(projection, 1, GL_FALSE, &p.data[0]);
}
mProjection = projectionMatrix;
* from this inset will only incur similarly small errors in output, due to transparency
* in extreme outside of the geometry.
*/
- left = floorf(left + Vertex::gGeometryFudgeFactor);
- top = floorf(top + Vertex::gGeometryFudgeFactor);
- right = ceilf(right - Vertex::gGeometryFudgeFactor);
- bottom = ceilf(bottom - Vertex::gGeometryFudgeFactor);
+ left = floorf(left + Vertex::GeometryFudgeFactor());
+ top = floorf(top + Vertex::GeometryFudgeFactor());
+ right = ceilf(right - Vertex::GeometryFudgeFactor());
+ bottom = ceilf(bottom - Vertex::GeometryFudgeFactor());
} else {
/* For other geometry, we do the regular rounding in order to snap, but also outset the
* bounds by a fudge factor. This ensures that ambiguous geometry (e.g. a non-AA Rect
* with top left at (0.5, 0.5)) will err on the side of a larger damage rect.
*/
- left = floorf(left + 0.5f - Vertex::gGeometryFudgeFactor);
- top = floorf(top + 0.5f - Vertex::gGeometryFudgeFactor);
- right = floorf(right + 0.5f + Vertex::gGeometryFudgeFactor);
- bottom = floorf(bottom + 0.5f + Vertex::gGeometryFudgeFactor);
+ left = floorf(left + 0.5f - Vertex::GeometryFudgeFactor());
+ top = floorf(top + 0.5f - Vertex::GeometryFudgeFactor());
+ right = floorf(right + 0.5f + Vertex::GeometryFudgeFactor());
+ bottom = floorf(bottom + 0.5f + Vertex::GeometryFudgeFactor());
}
}
namespace android {
class Functor;
-class Res_png_9patch;
+struct Res_png_9patch;
namespace uirenderer {
* Represents a Skia color filter. A color filter modifies a ProgramDescription
* and sets uniforms on the resulting shaders.
*/
-struct SkiaColorFilter {
+class SkiaColorFilter {
+public:
/**
* Type of Skia color filter in use.
*/
/**
* A color filter that multiplies the source color with a matrix and adds a vector.
*/
-struct SkiaColorMatrixFilter: public SkiaColorFilter {
+class SkiaColorMatrixFilter: public SkiaColorFilter {
+public:
ANDROID_API SkiaColorMatrixFilter(SkColorFilter *skFilter, float* matrix, float* vector);
~SkiaColorMatrixFilter();
* A color filters that multiplies the source color with a fixed value and adds
* another fixed value. Ignores the alpha channel of both arguments.
*/
-struct SkiaLightingFilter: public SkiaColorFilter {
+class SkiaLightingFilter: public SkiaColorFilter {
+public:
ANDROID_API SkiaLightingFilter(SkColorFilter *skFilter, int multiply, int add);
void describe(ProgramDescription& description, const Extensions& extensions);
* A color filters that blends the source color with a specified destination color
* and PorterDuff blending mode.
*/
-struct SkiaBlendFilter: public SkiaColorFilter {
+class SkiaBlendFilter: public SkiaColorFilter {
+public:
ANDROID_API SkiaBlendFilter(SkColorFilter *skFilter, int color, SkXfermode::Mode mode);
void describe(ProgramDescription& description, const Extensions& extensions);
* Represents a Skia shader. A shader will modify the GL context and active
* program to recreate the original effect.
*/
-struct SkiaShader {
+class SkiaShader {
+public:
/**
* Type of Skia shader in use.
*/
* Program::set()), and used to make geometry damage rect calculation conservative (see
* Rect::snapGeometryToPixelBoundaries())
*/
- static const float gGeometryFudgeFactor = 0.0656f;
+ static float GeometryFudgeFactor() { return 0.0656f; }
+
float x, y;
OSDN Git Service
