void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
GrDrawTarget* target,
const SkIRect& rect) {
GrDrawState* drawState = target->drawState();
GrDrawState::AutoViewMatrixRestore avmr;
if (!avmr.setIdentity(drawState)) {
return;
}
GrDrawState::AutoRestoreEffects are(drawState);
SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft,
SK_Scalar1 * rect.fTop,
SK_Scalar1 * rect.fRight,
SK_Scalar1 * rect.fBottom);
// We want to use device coords to compute the texture coordinates. We set our matrix to be
// equal to the view matrix followed by a translation so that the top-left of the device bounds
// maps to 0,0, and then a scaling matrix to normalized coords. We apply this matrix to the
// vertex positions rather than local coords.
SkMatrix maskMatrix;
maskMatrix.setIDiv(texture->width(), texture->height());
maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop));
maskMatrix.preConcat(drawState->getViewMatrix());
drawState->addCoverageEffect(
GrSimpleTextureEffect::Create(texture,
maskMatrix,
GrTextureParams::kNone_FilterMode,
kPosition_GrCoordSet))->unref();
target->drawSimpleRect(dstRect);
}
void GrBitmapTextContext::flushGlyphs() {
if (NULL == fDrawTarget) {
return;
}
GrDrawState* drawState = fDrawTarget->drawState();
GrDrawState::AutoRestoreEffects are(drawState);
drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
if (fCurrVertex > 0) {
// setup our sampler state for our text texture/atlas
SkASSERT(SkIsAlign4(fCurrVertex));
SkASSERT(fCurrTexture);
GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
// This effect could be stored with one of the cache objects (atlas?)
drawState->addCoverageEffect(
GrCustomCoordsTextureEffect::Create(fCurrTexture, params),
kGlyphCoordsAttributeIndex)->unref();
if (NULL != fStrike && kARGB_GrMaskFormat == fStrike->getMaskFormat()) {
drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
drawState->setColor(0xffffffff);
} else if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
if (kOne_GrBlendCoeff != fPaint.getSrcBlendCoeff() ||
kISA_GrBlendCoeff != fPaint.getDstBlendCoeff() ||
fPaint.numColorStages()) {
GrPrintf("LCD Text will not draw correctly.\n");
}
// We don't use the GrPaint's color in this case because it's been premultiplied by
// alpha. Instead we feed in a non-premultiplied color, and multiply its alpha by
// the mask texture color. The end result is that we get
// mask*paintAlpha*paintColor + (1-mask*paintAlpha)*dstColor
int a = SkColorGetA(fSkPaint.getColor());
// paintAlpha
drawState->setColor(SkColorSetARGB(a, a, a, a));
// paintColor
drawState->setBlendConstant(skcolor_to_grcolor_nopremultiply(fSkPaint.getColor()));
drawState->setBlendFunc(kConstC_GrBlendCoeff, kISC_GrBlendCoeff);
} else {
// set back to normal in case we took LCD path previously.
drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
drawState->setColor(fPaint.getColor());
}
int nGlyphs = fCurrVertex / 4;
fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
nGlyphs,
4, 6, &fVertexBounds);
fDrawTarget->resetVertexSource();
fVertices = NULL;
fMaxVertices = 0;
fCurrVertex = 0;
fVertexBounds.setLargestInverted();
SkSafeSetNull(fCurrTexture);
}
}
bool GrDashingEffect::DrawDashLine(const SkPoint pts[2], const GrPaint& paint,
const GrStrokeInfo& strokeInfo, GrGpu* gpu,
GrDrawTarget* target, const SkMatrix& vm) {
if (!can_fast_path_dash(pts, strokeInfo, *target, vm)) {
return false;
}
const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
SkScalar srcStrokeWidth = strokeInfo.getStrokeRec().getWidth();
// the phase should be normalized to be [0, sum of all intervals)
SkASSERT(info.fPhase >= 0 && info.fPhase < info.fIntervals[0] + info.fIntervals[1]);
SkScalar srcPhase = info.fPhase;
// Rotate the src pts so they are aligned horizontally with pts[0].fX < pts[1].fX
SkMatrix srcRotInv;
SkPoint ptsRot[2];
if (pts[0].fY != pts[1].fY || pts[0].fX > pts[1].fX) {
SkMatrix rotMatrix;
align_to_x_axis(pts, &rotMatrix, ptsRot);
if(!rotMatrix.invert(&srcRotInv)) {
GrPrintf("Failed to create invertible rotation matrix!\n");
return false;
}
} else {
srcRotInv.reset();
memcpy(ptsRot, pts, 2 * sizeof(SkPoint));
}
bool useAA = paint.isAntiAlias();
// Scale corrections of intervals and stroke from view matrix
SkScalar parallelScale;
SkScalar perpScale;
calc_dash_scaling(¶llelScale, &perpScale, vm, ptsRot);
bool hasCap = SkPaint::kButt_Cap != cap && 0 != srcStrokeWidth;
// We always want to at least stroke out half a pixel on each side in device space
// so 0.5f / perpScale gives us this min in src space
SkScalar halfSrcStroke = SkMaxScalar(srcStrokeWidth * 0.5f, 0.5f / perpScale);
SkScalar strokeAdj;
if (!hasCap) {
strokeAdj = 0.f;
} else {
strokeAdj = halfSrcStroke;
}
SkScalar startAdj = 0;
SkMatrix combinedMatrix = srcRotInv;
combinedMatrix.postConcat(vm);
bool lineDone = false;
SkRect startRect;
bool hasStartRect = false;
// If we are using AA, check to see if we are drawing a partial dash at the start. If so
// draw it separately here and adjust our start point accordingly
if (useAA) {
if (srcPhase > 0 && srcPhase < info.fIntervals[0]) {
SkPoint startPts[2];
startPts[0] = ptsRot[0];
startPts[1].fY = startPts[0].fY;
startPts[1].fX = SkMinScalar(startPts[0].fX + info.fIntervals[0] - srcPhase,
ptsRot[1].fX);
startRect.set(startPts, 2);
startRect.outset(strokeAdj, halfSrcStroke);
hasStartRect = true;
startAdj = info.fIntervals[0] + info.fIntervals[1] - srcPhase;
}
}
// adjustments for start and end of bounding rect so we only draw dash intervals
// contained in the original line segment.
startAdj += calc_start_adjustment(info);
if (startAdj != 0) {
ptsRot[0].fX += startAdj;
srcPhase = 0;
}
SkScalar endingInterval = 0;
SkScalar endAdj = calc_end_adjustment(info, ptsRot, srcPhase, &endingInterval);
ptsRot[1].fX -= endAdj;
if (ptsRot[0].fX >= ptsRot[1].fX) {
lineDone = true;
}
SkRect endRect;
bool hasEndRect = false;
// If we are using AA, check to see if we are drawing a partial dash at then end. If so
// draw it separately here and adjust our end point accordingly
if (useAA && !lineDone) {
// If we adjusted the end then we will not be drawing a partial dash at the end.
// If we didn't adjust the end point then we just need to make sure the ending
// dash isn't a full dash
if (0 == endAdj && endingInterval != info.fIntervals[0]) {
SkPoint endPts[2];
endPts[1] = ptsRot[1];
endPts[0].fY = endPts[1].fY;
endPts[0].fX = endPts[1].fX - endingInterval;
endRect.set(endPts, 2);
endRect.outset(strokeAdj, halfSrcStroke);
hasEndRect = true;
endAdj = endingInterval + info.fIntervals[1];
ptsRot[1].fX -= endAdj;
if (ptsRot[0].fX >= ptsRot[1].fX) {
lineDone = true;
}
}
}
if (startAdj != 0) {
srcPhase = 0;
}
// Change the dashing info from src space into device space
SkScalar devIntervals[2];
devIntervals[0] = info.fIntervals[0] * parallelScale;
devIntervals[1] = info.fIntervals[1] * parallelScale;
SkScalar devPhase = srcPhase * parallelScale;
SkScalar strokeWidth = srcStrokeWidth * perpScale;
if ((strokeWidth < 1.f && !useAA) || 0.f == strokeWidth) {
strokeWidth = 1.f;
}
SkScalar halfDevStroke = strokeWidth * 0.5f;
if (SkPaint::kSquare_Cap == cap && 0 != srcStrokeWidth) {
// add cap to on interveal and remove from off interval
devIntervals[0] += strokeWidth;
devIntervals[1] -= strokeWidth;
}
SkScalar startOffset = devIntervals[1] * 0.5f + devPhase;
SkScalar bloatX = useAA ? 0.5f / parallelScale : 0.f;
SkScalar bloatY = useAA ? 0.5f / perpScale : 0.f;
SkScalar devBloat = useAA ? 0.5f : 0.f;
GrDrawState* drawState = target->drawState();
if (devIntervals[1] <= 0.f && useAA) {
// Case when we end up drawing a solid AA rect
// Reset the start rect to draw this single solid rect
// but it requires to upload a new intervals uniform so we can mimic
// one giant dash
ptsRot[0].fX -= hasStartRect ? startAdj : 0;
ptsRot[1].fX += hasEndRect ? endAdj : 0;
startRect.set(ptsRot, 2);
startRect.outset(strokeAdj, halfSrcStroke);
hasStartRect = true;
hasEndRect = false;
lineDone = true;
SkPoint devicePts[2];
vm.mapPoints(devicePts, ptsRot, 2);
SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
if (hasCap) {
lineLength += 2.f * halfDevStroke;
}
devIntervals[0] = lineLength;
}
if (devIntervals[1] > 0.f || useAA) {
SkPathEffect::DashInfo devInfo;
devInfo.fPhase = devPhase;
devInfo.fCount = 2;
devInfo.fIntervals = devIntervals;
GrEffectEdgeType edgeType= useAA ? kFillAA_GrEffectEdgeType :
kFillBW_GrEffectEdgeType;
bool isRoundCap = SkPaint::kRound_Cap == cap;
GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
GrDashingEffect::kNonRound_DashCap;
drawState->addCoverageEffect(
GrDashingEffect::Create(edgeType, devInfo, strokeWidth, capType), 1)->unref();
}
// Set up the vertex data for the line and start/end dashes
drawState->setVertexAttribs<gDashLineVertexAttribs>(SK_ARRAY_COUNT(gDashLineVertexAttribs));
int totalRectCnt = 0;
totalRectCnt += !lineDone ? 1 : 0;
totalRectCnt += hasStartRect ? 1 : 0;
totalRectCnt += hasEndRect ? 1 : 0;
GrDrawTarget::AutoReleaseGeometry geo(target, totalRectCnt * 4, 0);
if (!geo.succeeded()) {
GrPrintf("Failed to get space for vertices!\n");
return false;
}
DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
int curVIdx = 0;
if (SkPaint::kRound_Cap == cap && 0 != srcStrokeWidth) {
// need to adjust this for round caps to correctly set the dashPos attrib on vertices
startOffset -= halfDevStroke;
}
// Draw interior part of dashed line
if (!lineDone) {
SkPoint devicePts[2];
vm.mapPoints(devicePts, ptsRot, 2);
SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
if (hasCap) {
lineLength += 2.f * halfDevStroke;
}
SkRect bounds;
bounds.set(ptsRot[0].fX, ptsRot[0].fY, ptsRot[1].fX, ptsRot[1].fY);
bounds.outset(bloatX + strokeAdj, bloatY + halfSrcStroke);
setup_dashed_rect(bounds, verts, curVIdx, combinedMatrix, startOffset, devBloat,
lineLength, halfDevStroke);
curVIdx += 4;
}
if (hasStartRect) {
SkASSERT(useAA); // so that we know bloatX and bloatY have been set
startRect.outset(bloatX, bloatY);
setup_dashed_rect(startRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
devIntervals[0], halfDevStroke);
curVIdx += 4;
}
if (hasEndRect) {
SkASSERT(useAA); // so that we know bloatX and bloatY have been set
endRect.outset(bloatX, bloatY);
setup_dashed_rect(endRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
devIntervals[0], halfDevStroke);
}
target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
target->drawIndexedInstances(kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
target->resetIndexSource();
return true;
}
void GrBitmapTextContext::flushGlyphs() {
if (NULL == fDrawTarget) {
return;
}
GrDrawState* drawState = fDrawTarget->drawState();
GrDrawState::AutoRestoreEffects are(drawState);
drawState->setFromPaint(fPaint, SkMatrix::I(), fContext->getRenderTarget());
if (fCurrVertex > 0) {
// setup our sampler state for our text texture/atlas
SkASSERT(SkIsAlign4(fCurrVertex));
SkASSERT(fCurrTexture);
GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
uint32_t textureUniqueID = fCurrTexture->getUniqueID();
if (textureUniqueID != fEffectTextureUniqueID) {
fCachedEffect.reset(GrCustomCoordsTextureEffect::Create(fCurrTexture, params));
fEffectTextureUniqueID = textureUniqueID;
}
// This effect could be stored with one of the cache objects (atlas?)
int coordsIdx = drawState->hasColorVertexAttribute() ? kGlyphCoordsWithColorAttributeIndex :
kGlyphCoordsNoColorAttributeIndex;
drawState->addCoverageEffect(fCachedEffect.get(), coordsIdx);
SkASSERT(NULL != fStrike);
switch (fStrike->getMaskFormat()) {
// Color bitmap text
case kARGB_GrMaskFormat:
SkASSERT(!drawState->hasColorVertexAttribute());
drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
drawState->setColor(0xffffffff);
break;
// LCD text
case kA888_GrMaskFormat:
case kA565_GrMaskFormat: {
if (kOne_GrBlendCoeff != fPaint.getSrcBlendCoeff() ||
kISA_GrBlendCoeff != fPaint.getDstBlendCoeff() ||
fPaint.numColorStages()) {
GrPrintf("LCD Text will not draw correctly.\n");
}
SkASSERT(!drawState->hasColorVertexAttribute());
// We don't use the GrPaint's color in this case because it's been premultiplied by
// alpha. Instead we feed in a non-premultiplied color, and multiply its alpha by
// the mask texture color. The end result is that we get
// mask*paintAlpha*paintColor + (1-mask*paintAlpha)*dstColor
int a = SkColorGetA(fSkPaint.getColor());
// paintAlpha
drawState->setColor(SkColorSetARGB(a, a, a, a));
// paintColor
drawState->setBlendConstant(skcolor_to_grcolor_nopremultiply(fSkPaint.getColor()));
drawState->setBlendFunc(kConstC_GrBlendCoeff, kISC_GrBlendCoeff);
break;
}
// Grayscale/BW text
case kA8_GrMaskFormat:
// set back to normal in case we took LCD path previously.
drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
// We're using per-vertex color.
SkASSERT(drawState->hasColorVertexAttribute());
break;
default:
SkFAIL("Unexepected mask format.");
}
int nGlyphs = fCurrVertex / 4;
fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
nGlyphs,
4, 6, &fVertexBounds);
fDrawTarget->resetVertexSource();
fVertices = NULL;
fMaxVertices = 0;
fCurrVertex = 0;
fVertexBounds.setLargestInverted();
SkSafeSetNull(fCurrTexture);
}
}
