AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove isIRect "optimization" & defer computation of device Rect in AA rect rendering

Browse Source 
https://chromiumcodereview.appspot.com/14890021/



git-svn-id: http://skia.googlecode.com/svn/trunk@9087 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
robertphillips@google.com 2013-05-10 11:05:58 +00:00
parent 0f20a3fc59
commit 18136d1cf2
4 changed files with 21 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/gpu/GrAARectRenderer.h
View File

@ -42,7 +42,6 @@ public:
GrDrawTarget* target,
const GrRect& rect,
const SkMatrix& combinedMatrix,
const GrRect& devRect,
bool useVertexCoverage) {
#ifdef SHADER_AA_FILL_RECT
if (combinedMatrix.rectStaysRect()) {
@ -55,13 +54,14 @@ public:
#else
this->geometryFillAARect(gpu, target,
rect, combinedMatrix,
devRect, useVertexCoverage);
useVertexCoverage);
#endif
}
void strokeAARect(GrGpu* gpu,
GrDrawTarget* target,
const GrRect& devRect,
const GrRect& rect,
const SkMatrix& combinedMatrix,
const GrVec& devStrokeSize,
bool useVertexCoverage);
@ -80,7 +80,6 @@ private:
GrDrawTarget* target,
const GrRect& rect,
const SkMatrix& combinedMatrix,
const GrRect& devRect,
bool useVertexCoverage);
void shaderFillAARect(GrGpu* gpu,

19
src/gpu/GrAARectRenderer.cpp
View File

@ -364,7 +364,6 @@ void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
GrDrawTarget* target,
const GrRect& rect,
const SkMatrix& combinedMatrix,
const GrRect& devRect,
bool useVertexCoverage) {
GrDrawState* drawState = target->drawState();
@ -389,6 +388,9 @@ void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
GrPoint* fan0Pos = reinterpret_cast<GrPoint*>(verts);
GrPoint* fan1Pos = reinterpret_cast<GrPoint*>(verts + 4 * vsize);
SkRect devRect;
combinedMatrix.mapRect(&devRect, rect);
if (combinedMatrix.rectStaysRect()) {
set_inset_fan(fan0Pos, vsize, devRect, -SK_ScalarHalf, -SK_ScalarHalf);
set_inset_fan(fan1Pos, vsize, devRect, SK_ScalarHalf, SK_ScalarHalf);
@ -616,16 +618,20 @@ void GrAARectRenderer::shaderFillAlignedAARect(GrGpu* gpu,
void GrAARectRenderer::strokeAARect(GrGpu* gpu,
GrDrawTarget* target,
const GrRect& devRect,
const GrRect& rect,
const SkMatrix& combinedMatrix,
const GrVec& devStrokeSize,
bool useVertexCoverage) {
GrDrawState* drawState = target->drawState();
const SkScalar& dx = devStrokeSize.fX;
const SkScalar& dy = devStrokeSize.fY;
const SkScalar dx = devStrokeSize.fX;
const SkScalar dy = devStrokeSize.fY;
const SkScalar rx = SkScalarMul(dx, SK_ScalarHalf);
const SkScalar ry = SkScalarMul(dy, SK_ScalarHalf);
SkRect devRect;
combinedMatrix.mapRect(&devRect, rect);
SkScalar spare;
{
SkScalar w = devRect.width() - dx;
@ -634,9 +640,8 @@ void GrAARectRenderer::strokeAARect(GrGpu* gpu,
}
if (spare <= 0) {
GrRect r(devRect);
r.inset(-rx, -ry);
this->fillAARect(gpu, target, r, SkMatrix::I(), r, useVertexCoverage);
devRect.inset(-rx, -ry);
this->fillAARect(gpu, target, devRect, SkMatrix::I(), useVertexCoverage);
return;
}

1
src/gpu/GrClipMaskManager.cpp
View File

@ -282,7 +282,6 @@ bool GrClipMaskManager::drawElement(GrTexture* target,
fGpu,
element->getRect(),
SkMatrix::I(),
element->getRect(),
false);
} else {
fGpu->drawSimpleRect(element->getRect(), NULL);

32
src/gpu/GrContext.cpp
View File

@ -680,20 +680,10 @@ static void setStrokeRectStrip(GrPoint verts[10], GrRect rect,
verts[9] = verts[1];
}
/**
* Returns true if the rects edges are integer-aligned.
*/
static bool isIRect(const GrRect& r) {
return SkScalarIsInt(r.fLeft) && SkScalarIsInt(r.fTop) &&
SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
}
static bool apply_aa_to_rect(GrDrawTarget* target,
const GrRect& rect,
SkScalar strokeWidth,
const SkMatrix* matrix,
SkMatrix* combinedMatrix,
GrRect* devRect,
bool* useVertexCoverage) {
// we use a simple coverage ramp to do aa on axis-aligned rects
// we check if the rect will be axis-aligned, and the rect won't land on
@ -763,17 +753,7 @@ static bool apply_aa_to_rect(GrDrawTarget* target,
#endif
}
combinedMatrix->mapRect(devRect, rect);
if (strokeWidth < 0
#if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
&& drawState.getViewMatrix().preservesAxisAlignment()
#endif
) {
return !isIRect(*devRect);
} else {
return true;
}
return true;
}
void GrContext::drawRect(const GrPaint& paint,
@ -785,13 +765,12 @@ void GrContext::drawRect(const GrPaint& paint,
GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW);
GrDrawState::AutoStageDisable atr(fDrawState);
GrRect devRect;
SkMatrix combinedMatrix;
bool useVertexCoverage;
bool needAA = paint.isAntiAlias() &&
!this->getRenderTarget()->isMultisampled();
bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
&combinedMatrix, &devRect,
bool doAA = needAA && apply_aa_to_rect(target, width, matrix,
&combinedMatrix,
&useVertexCoverage);
if (doAA) {
GrDrawState::AutoDeviceCoordDraw adcd(target->drawState());
@ -807,12 +786,13 @@ void GrContext::drawRect(const GrPaint& paint,
} else {
strokeSize.set(SK_Scalar1, SK_Scalar1);
}
fAARectRenderer->strokeAARect(this->getGpu(), target, devRect,
fAARectRenderer->strokeAARect(this->getGpu(), target,
rect, combinedMatrix,
strokeSize, useVertexCoverage);
} else {
// filled AA rect
fAARectRenderer->fillAARect(this->getGpu(), target,
rect, combinedMatrix, devRect,
rect, combinedMatrix,
useVertexCoverage);
}
return;