DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) {
GrRenderTarget* target = canvas->internal_private_accessTopLayerRenderTarget();
GrContext* ctx = canvas->getGrContext();
- SkAutoTUnref<GrDrawContext> drawContext(ctx ? ctx->drawContext() : nullptr);
+ SkAutoTUnref<GrDrawContext> drawContext(ctx ? ctx->drawContext(target) : nullptr);
if (drawContext && target) {
SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
static const int stride = 2 * S;
tm.postIDiv(2*S, 2*S);
paint.addColorTextureProcessor(texture, tm);
- drawContext->drawRect(target, clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
+ drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
// now update the lower right of the texture in first pass
// or upper right in second pass
texture->writePixels(S, (i ? 0 : S), S, S,
texture->config(), gTextureData.get(),
4 * stride);
- drawContext->drawRect(target, clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
+ drawContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
}
} else {
skiagm::GM::DrawGpuOnlyMessage(canvas);
*/
virtual bool directFilterMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
*/
virtual bool directFilterRRectMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
* Callers should take a ref if they rely on the GrDrawContext sticking around.
* NULL will be returned if the context has been abandoned.
*
+ * @param rt the render target receiving the draws
* @param surfaceProps the surface properties (mainly defines text drawing)
*
* @return a draw context
*/
- GrDrawContext* drawContext(const SkSurfaceProps* surfaceProps = NULL) {
- return fDrawingMgr.drawContext(surfaceProps);
+ GrDrawContext* drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps = NULL) {
+ return fDrawingMgr.drawContext(rt, surfaceProps);
}
GrTextContext* textContext(const SkSurfaceProps& surfaceProps, GrRenderTarget* rt) {
// Callers assume the creation ref of the drawContext!
// NULL will be returned if the context has been abandoned.
- GrDrawContext* drawContext(const SkSurfaceProps* surfaceProps);
+ GrDrawContext* drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps);
GrTextContext* textContext(const SkSurfaceProps& props, GrRenderTarget* rt);
public:
~GrDrawContext() override;
- void copySurface(GrRenderTarget* dst, GrSurface* src,
- const SkIRect& srcRect, const SkIPoint& dstPoint);
+ void copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint);
// TODO: it is odd that we need both the SkPaint in the following 3 methods.
// We should extract the text parameters from SkPaint and pass them separately
// akin to GrStrokeInfo (GrTextInfo?)
- void drawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
+ void drawText(const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix, const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& clipBounds);
- void drawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
+ void drawPosText(const GrClip&, const GrPaint&, const SkPaint&,
const SkMatrix& viewMatrix, const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkIRect& clipBounds);
- void drawTextBlob(GrRenderTarget*, const GrClip&, const SkPaint&,
+ void drawTextBlob(const GrClip&, const SkPaint&,
const SkMatrix& viewMatrix, const SkTextBlob*,
SkScalar x, SkScalar y,
SkDrawFilter*, const SkIRect& clipBounds);
* Provides a perfomance hint that the render target's contents are allowed
* to become undefined.
*/
- void discard(GrRenderTarget*);
+ void discard();
/**
* Clear the entire or rect of the render target, ignoring any clips.
- * @param target The render target to clear.
* @param rect the rect to clear or the whole thing if rect is NULL.
* @param color the color to clear to.
* @param canIgnoreRect allows partial clears to be converted to whole
* clears on platforms for which that is cheap
*/
- void clear(GrRenderTarget*, const SkIRect* rect, GrColor color, bool canIgnoreRect);
+ void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect);
/**
* Draw everywhere (respecting the clip) with the paint.
*/
- void drawPaint(GrRenderTarget*, const GrClip&, const GrPaint&, const SkMatrix& viewMatrix);
+ void drawPaint(const GrClip&, const GrPaint&, const SkMatrix& viewMatrix);
/**
* Draw the rect using a paint.
* mitered/beveled stroked based on stroke width.
* The rects coords are used to access the paint (through texture matrix)
*/
- void drawRect(GrRenderTarget*,
- const GrClip&,
+ void drawRect(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect&,
* @param rectToDraw the rectangle to draw
* @param localRect the rectangle of shader coordinates applied to rectToDraw
*/
- void drawNonAARectToRect(GrRenderTarget*,
- const GrClip&,
+ void drawNonAARectToRect(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rectToDraw,
/**
* Draws a non-AA rect with paint and a localMatrix
*/
- void drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
- const GrClip& clip,
+ void drawNonAARectWithLocalMatrix(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
* @param strokeInfo the stroke information (width, join, cap) and
* the dash information (intervals, count, phase).
*/
- void drawRRect(GrRenderTarget*,
- const GrClip&,
+ void drawRRect(const GrClip&,
const GrPaint&,
const SkMatrix& viewMatrix,
const SkRRect& rrect,
* @param outer the outer roundrect
* @param inner the inner roundrect
*/
- void drawDRRect(GrRenderTarget*,
- const GrClip&,
+ void drawDRRect(const GrClip&,
const GrPaint&,
const SkMatrix& viewMatrix,
const SkRRect& outer,
* @param strokeInfo the stroke information (width, join, cap) and
* the dash information (intervals, count, phase).
*/
- void drawPath(GrRenderTarget*,
- const GrClip&,
+ void drawPath(const GrClip&,
const GrPaint&,
const SkMatrix& viewMatrix,
const SkPath&,
* @param indexCount if indices is non-null then this is the
* number of indices.
*/
- void drawVertices(GrRenderTarget*,
- const GrClip&,
+ void drawVertices(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
GrPrimitiveType primitiveType,
* @param colors optional array of per-sprite colors, supercedes
* the paint's color field.
*/
- void drawAtlas(GrRenderTarget*,
- const GrClip&,
+ void drawAtlas(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
int spriteCount,
* @param strokeInfo the stroke information (width, join, cap) and
* the dash information (intervals, count, phase).
*/
- void drawOval(GrRenderTarget*,
- const GrClip&,
+ void drawOval(const GrClip&,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& oval,
* @param paint describes how to color pixels.
* @param batch the batch to draw
*/
- void drawBatch(GrRenderTarget*, const GrClip&, const GrPaint&, GrDrawBatch*);
+ void drawBatch(const GrClip&, const GrPaint&, GrDrawBatch*);
private:
friend class GrAtlasTextContext; // for access to drawBatch
friend class GrContext; // for ctor
- GrDrawContext(GrContext*, GrDrawTarget*, const SkSurfaceProps* surfaceProps);
+ SkDEBUGCODE(void validate() const;)
- // Checks if the context has been abandoned and if the rendertarget is owned by this context
- bool prepareToDraw(GrRenderTarget* rt);
+ GrDrawContext(GrContext*, GrRenderTarget*, GrDrawTarget*, const SkSurfaceProps* surfaceProps);
void internalDrawPath(GrDrawTarget*,
GrPipelineBuilder*,
void drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch);
GrContext* fContext; // owning context -> no ref
+ GrRenderTarget* fRenderTarget;
GrDrawTarget* fDrawTarget;
GrTextContext* fTextContext; // lazily gotten from GrContext::DrawingMgr
SkASSERT(fp);
paint.addColorFragmentProcessor(fp)->unref();
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
if (drawContext) {
- drawContext->drawNonAARectToRect(dst->asRenderTarget(), clip, paint, SkMatrix::I(),
- dstRect, srcRect);
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
WrapTexture(dst, bounds.width(), bounds.height(), result);
return true;
bool SkMaskFilter::directFilterMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
bool SkMaskFilter::directFilterRRectMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
#if SK_SUPPORT_GPU
bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
GrTexture* texture,
- const SkMatrix& in_matrix,
+ const SkMatrix& inMatrix,
const SkIRect&) const {
if (fp) {
GrContext* context = texture->getContext();
return false;
}
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(
+ context->drawContext(maskTexture->asRenderTarget()));
if (drawContext) {
GrPaint grPaint;
grPaint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
SkRegion::Iterator iter(fRegion);
- drawContext->clear(maskTexture->asRenderTarget(), nullptr, 0x0, true);
+ drawContext->clear(nullptr, 0x0, true);
while (!iter.done()) {
SkRect rect = SkRect::Make(iter.rect());
- drawContext->drawRect(maskTexture->asRenderTarget(), GrClip::WideOpen(), grPaint,
- in_matrix, rect);
+ drawContext->drawRect(GrClip::WideOpen(), grPaint, inMatrix, rect);
iter.next();
}
}
SkRect* maskRect) const override;
bool directFilterMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
const SkPath& path) const override;
bool directFilterRRectMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip&,
const SkMatrix& viewMatrix,
bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip& clip,
const SkMatrix& viewMatrix,
return false;
}
- drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), rect, inverse);
+ drawContext->drawNonAARectWithLocalMatrix(clip, *grp, SkMatrix::I(), rect, inverse);
return true;
}
bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrTextureProvider* texProvider,
GrDrawContext* drawContext,
- GrRenderTarget* rt,
GrPaint* grp,
const GrClip& clip,
const SkMatrix& viewMatrix,
return false;
}
- drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), proxyRect, inverse);
+ drawContext->drawNonAARectWithLocalMatrix(clip, *grp, SkMatrix::I(), proxyRect, inverse);
return true;
}
paint.setCoverageSetOpXPFactory(SkRegion::kDifference_Op);
}
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext((*result)->asRenderTarget()));
if (!drawContext) {
return false;
}
- drawContext->drawRect((*result)->asRenderTarget(), GrClip::WideOpen(),
- paint, SkMatrix::I(), clipRect);
+ drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), clipRect);
}
return true;
matrix.setTranslate(-SkIntToScalar(colorBounds.x()),
-SkIntToScalar(colorBounds.y()));
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
if (!drawContext) {
return false;
}
- drawContext->drawRect(dst->asRenderTarget(), GrClip::WideOpen(), paint, matrix,
- SkRect::Make(colorBounds));
+ drawContext->drawRect(GrClip::WideOpen(), paint, matrix, SkRect::Make(colorBounds));
offset->fX = bounds.left();
offset->fY = bounds.top();
WrapTexture(dst, bounds.width(), bounds.height(), result);
}
static void convolve_gaussian_1d(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
const SkRect& srcRect,
const SkRect& dstRect,
SkAutoTUnref<GrFragmentProcessor> conv(GrConvolutionEffect::CreateGaussian(
texture, direction, radius, sigma, useBounds, bounds));
paint.addColorFragmentProcessor(conv);
- drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), dstRect, srcRect);
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
}
static void convolve_gaussian_2d(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
const SkRect& srcRect,
const SkRect& dstRect,
useBounds ? GrTextureDomain::kClamp_Mode : GrTextureDomain::kIgnore_Mode,
true, sigmaX, sigmaY));
paint.addColorFragmentProcessor(conv);
- drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), dstRect, srcRect);
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
}
static void convolve_gaussian(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
const SkRect& srcRect,
const SkRect& dstRect,
bool cropToSrcRect) {
float bounds[2] = { 0.0f, 1.0f };
if (!cropToSrcRect) {
- convolve_gaussian_1d(drawContext, rt, clip, srcRect, dstRect, texture,
+ convolve_gaussian_1d(drawContext, clip, srcRect, dstRect, texture,
direction, radius, sigma, false, bounds);
return;
}
}
if (radius >= size * SK_ScalarHalf) {
// Blur radius covers srcRect; use bounds over entire draw
- convolve_gaussian_1d(drawContext, rt, clip, srcRect, dstRect, texture,
+ convolve_gaussian_1d(drawContext, clip, srcRect, dstRect, texture,
direction, radius, sigma, true, bounds);
} else {
// Draw upper and lower margins with bounds; middle without.
- convolve_gaussian_1d(drawContext, rt, clip, lowerSrcRect, lowerDstRect, texture,
+ convolve_gaussian_1d(drawContext, clip, lowerSrcRect, lowerDstRect, texture,
direction, radius, sigma, true, bounds);
- convolve_gaussian_1d(drawContext, rt, clip, upperSrcRect, upperDstRect, texture,
+ convolve_gaussian_1d(drawContext, clip, upperSrcRect, upperDstRect, texture,
direction, radius, sigma, true, bounds);
- convolve_gaussian_1d(drawContext, rt, clip, middleSrcRect, middleDstRect, texture,
+ convolve_gaussian_1d(drawContext, clip, middleSrcRect, middleDstRect, texture,
direction, radius, sigma, false, bounds);
}
}
scale_rect(&dstRect, i < scaleFactorX ? 0.5f : 1.0f,
i < scaleFactorY ? 0.5f : 1.0f);
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(
+ context->drawContext(dstTexture->asRenderTarget()));
if (!dstDrawContext) {
return nullptr;
}
- dstDrawContext->drawNonAARectToRect(dstTexture->asRenderTarget(), clip, paint,
- SkMatrix::I(), dstRect, srcRect);
+ dstDrawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
srcDrawContext.swap(dstDrawContext);
srcRect = dstRect;
SkASSERT((1 == scaleFactorX) && (1 == scaleFactorY));
SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(
+ context->drawContext(dstTexture->asRenderTarget()));
if (!dstDrawContext) {
return nullptr;
}
- convolve_gaussian_2d(dstDrawContext, dstTexture->asRenderTarget(), clip, srcRect, dstRect,
+ convolve_gaussian_2d(dstDrawContext, clip, srcRect, dstRect,
srcTexture, radiusX, radiusY, sigmaX, sigmaY, cropToRect, srcIRect);
srcDrawContext.swap(dstDrawContext);
if (scaleFactorX > 1) {
// TODO: if we pass in the source draw context we don't need this here
if (!srcDrawContext) {
- srcDrawContext.reset(context->drawContext());
+ srcDrawContext.reset(context->drawContext(srcTexture->asRenderTarget()));
if (!srcDrawContext) {
return nullptr;
}
// X convolution from reading garbage.
clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
radiusX, srcIRect.height());
- srcDrawContext->clear(srcTexture->asRenderTarget(), &clearRect, 0x0, false);
+ srcDrawContext->clear(&clearRect, 0x0, false);
}
SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(
+ context->drawContext(dstTexture->asRenderTarget()));
if (!dstDrawContext) {
return nullptr;
}
- convolve_gaussian(dstDrawContext, dstTexture->asRenderTarget(), clip, srcRect, dstRect,
+ convolve_gaussian(dstDrawContext, clip, srcRect, dstRect,
srcTexture, Gr1DKernelEffect::kX_Direction, radiusX, sigmaX,
cropToRect);
if (scaleFactorY > 1 || sigmaX > 0.0f) {
// TODO: if we pass in the source draw context we don't need this here
if (!srcDrawContext) {
- srcDrawContext.reset(context->drawContext());
+ srcDrawContext.reset(context->drawContext(srcTexture->asRenderTarget()));
if (!srcDrawContext) {
return nullptr;
}
// convolution from reading garbage.
clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
srcIRect.width(), radiusY);
- srcDrawContext->clear(srcTexture->asRenderTarget(), &clearRect, 0x0, false);
+ srcDrawContext->clear(&clearRect, 0x0, false);
}
SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(
+ context->drawContext(dstTexture->asRenderTarget()));
if (!dstDrawContext) {
return nullptr;
}
- convolve_gaussian(dstDrawContext, dstTexture->asRenderTarget(), clip, srcRect,
+ convolve_gaussian(dstDrawContext, clip, srcRect,
dstRect, srcTexture, Gr1DKernelEffect::kY_Direction, radiusY, sigmaY,
cropToRect);
// upsampling.
clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
srcIRect.width() + 1, 1);
- srcDrawContext->clear(srcTexture->asRenderTarget(), &clearRect, 0x0, false);
+ srcDrawContext->clear(&clearRect, 0x0, false);
clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
1, srcIRect.height());
- srcDrawContext->clear(srcTexture->asRenderTarget(), &clearRect, 0x0, false);
+ srcDrawContext->clear(&clearRect, 0x0, false);
SkMatrix matrix;
matrix.setIDiv(srcTexture->width(), srcTexture->height());
SkRect dstRect(srcRect);
scale_rect(&dstRect, (float) scaleFactorX, (float) scaleFactorY);
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(
+ context->drawContext(dstTexture->asRenderTarget()));
if (!dstDrawContext) {
return nullptr;
}
- dstDrawContext->drawNonAARectToRect(dstTexture->asRenderTarget(), clip, paint,
- SkMatrix::I(), dstRect, srcRect);
+ dstDrawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
srcDrawContext.swap(dstDrawContext);
srcRect = dstRect;
#if SK_SUPPORT_GPU
void drawRect(GrDrawContext* drawContext,
GrTexture* src,
- GrTexture* dst,
const SkMatrix& matrix,
const GrClip& clip,
const SkRect& dstRect,
#if SK_SUPPORT_GPU
void SkLightingImageFilterInternal::drawRect(GrDrawContext* drawContext,
GrTexture* src,
- GrTexture* dst,
const SkMatrix& matrix,
const GrClip& clip,
const SkRect& dstRect,
GrPaint paint;
GrFragmentProcessor* fp = this->getFragmentProcessor(src, matrix, bounds, boundaryMode);
paint.addColorFragmentProcessor(fp)->unref();
- drawContext->drawNonAARectToRect(dst->asRenderTarget(), clip, paint, SkMatrix::I(),
- dstRect, srcRect);
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
}
bool SkLightingImageFilterInternal::filterImageGPU(Proxy* proxy,
SkRect bottom = SkRect::MakeXYWH(1, dstRect.height() - 1, dstRect.width() - 2, 1);
SkRect bottomRight = SkRect::MakeXYWH(dstRect.width() - 1, dstRect.height() - 1, 1, 1);
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
if (!drawContext) {
return false;
}
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, topLeft, kTopLeft_BoundaryMode,
+ this->drawRect(drawContext, srcTexture, matrix, clip, topLeft, kTopLeft_BoundaryMode, bounds);
+ this->drawRect(drawContext, srcTexture, matrix, clip, top, kTop_BoundaryMode, bounds);
+ this->drawRect(drawContext, srcTexture, matrix, clip, topRight, kTopRight_BoundaryMode,
bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, top, kTop_BoundaryMode, bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, topRight, kTopRight_BoundaryMode,
+ this->drawRect(drawContext, srcTexture, matrix, clip, left, kLeft_BoundaryMode, bounds);
+ this->drawRect(drawContext, srcTexture, matrix, clip, interior, kInterior_BoundaryMode,
bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, left, kLeft_BoundaryMode, bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, interior, kInterior_BoundaryMode,
+ this->drawRect(drawContext, srcTexture, matrix, clip, right, kRight_BoundaryMode, bounds);
+ this->drawRect(drawContext, srcTexture, matrix, clip, bottomLeft, kBottomLeft_BoundaryMode,
bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, right, kRight_BoundaryMode, bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, bottomLeft, kBottomLeft_BoundaryMode,
- bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, bottom, kBottom_BoundaryMode, bounds);
- this->drawRect(drawContext, srcTexture, dst, matrix, clip, bottomRight,
+ this->drawRect(drawContext, srcTexture, matrix, clip, bottom, kBottom_BoundaryMode, bounds);
+ this->drawRect(drawContext, srcTexture, matrix, clip, bottomRight,
kBottomRight_BoundaryMode, bounds);
WrapTexture(dst, bounds.width(), bounds.height(), result);
return true;
void apply_morphology_rect(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
GrTexture* texture,
const SkIRect& srcRect,
radius,
morphType,
bounds))->unref();
- drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
SkRect::Make(srcRect));
}
void apply_morphology_rect_no_bounds(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
GrTexture* texture,
const SkIRect& srcRect,
direction,
radius,
morphType))->unref();
- drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
+ drawContext->drawNonAARectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
SkRect::Make(srcRect));
}
void apply_morphology_pass(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
GrTexture* texture,
const SkIRect& srcRect,
}
if (middleSrcRect.fLeft - middleSrcRect.fRight >= 0) {
// radius covers srcRect; use bounds over entire draw
- apply_morphology_rect(drawContext, rt, clip, texture, srcRect, dstRect, radius,
+ apply_morphology_rect(drawContext, clip, texture, srcRect, dstRect, radius,
morphType, bounds, direction);
} else {
// Draw upper and lower margins with bounds; middle without.
- apply_morphology_rect(drawContext, rt, clip, texture, lowerSrcRect, lowerDstRect, radius,
+ apply_morphology_rect(drawContext, clip, texture, lowerSrcRect, lowerDstRect, radius,
morphType, bounds, direction);
- apply_morphology_rect(drawContext, rt, clip, texture, upperSrcRect, upperDstRect, radius,
+ apply_morphology_rect(drawContext, clip, texture, upperSrcRect, upperDstRect, radius,
morphType, bounds, direction);
- apply_morphology_rect_no_bounds(drawContext, rt, clip, texture, middleSrcRect, middleDstRect,
+ apply_morphology_rect_no_bounds(drawContext, clip, texture, middleSrcRect, middleDstRect,
radius, morphType, direction);
}
}
if (nullptr == scratch) {
return false;
}
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext(scratch->asRenderTarget()));
if (!dstDrawContext) {
return false;
}
- apply_morphology_pass(dstDrawContext, scratch->asRenderTarget(), clip, srcTexture,
+ apply_morphology_pass(dstDrawContext, clip, srcTexture,
srcRect, dstRect, radius.fWidth, morphType,
Gr1DKernelEffect::kX_Direction);
SkIRect clearRect = SkIRect::MakeXYWH(dstRect.fLeft, dstRect.fBottom,
GrColor clearColor = GrMorphologyEffect::kErode_MorphologyType == morphType ?
SK_ColorWHITE :
SK_ColorTRANSPARENT;
- dstDrawContext->clear(scratch->asRenderTarget(), &clearRect, clearColor, false);
+ dstDrawContext->clear(&clearRect, clearColor, false);
srcTexture.reset(scratch);
srcRect = dstRect;
if (nullptr == scratch) {
return false;
}
- SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> dstDrawContext(context->drawContext(scratch->asRenderTarget()));
if (!dstDrawContext) {
return false;
}
- apply_morphology_pass(dstDrawContext, scratch->asRenderTarget(), clip, srcTexture,
+ apply_morphology_pass(dstDrawContext, clip, srcTexture,
srcRect, dstRect, radius.fHeight, morphType,
Gr1DKernelEffect::kY_Direction);
paint.addColorFragmentProcessor(xferFP)->unref();
}
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
if (!drawContext) {
return false;
}
- drawContext->drawRect(dst->asRenderTarget(), GrClip::WideOpen(), paint,
- SkMatrix::I(), srcRect);
+ drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), srcRect);
offset->fX = backgroundOffset.fX;
offset->fY = backgroundOffset.fY;
// is already burnt into the mask this boils down to a rect draw.
// Return true if the mask was successfully drawn.
static bool draw_mask(GrDrawContext* drawContext,
- GrRenderTarget* rt,
const GrClip& clip,
const SkMatrix& viewMatrix,
const SkRect& maskRect,
if (!viewMatrix.invert(&inverse)) {
return false;
}
- drawContext->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), maskRect, inverse);
+ drawContext->drawNonAARectWithLocalMatrix(clip, *grp, SkMatrix::I(), maskRect, inverse);
return true;
}
static bool draw_with_mask_filter(GrDrawContext* drawContext,
GrTextureProvider* textureProvider,
- GrRenderTarget* rt,
const GrClip& clipData,
const SkMatrix& viewMatrix,
const SkPath& devPath,
SkRect maskRect = SkRect::Make(dstM.fBounds);
- return draw_mask(drawContext, rt, clipData, viewMatrix, maskRect, grp, texture);
+ return draw_mask(drawContext, clipData, viewMatrix, maskRect, grp, texture);
}
// Create a mask of 'devPath' and place the result in 'mask'.
SkRect clipRect = SkRect::MakeWH(maskRect->width(), maskRect->height());
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(mask->asRenderTarget()));
if (!drawContext) {
return nullptr;
}
- drawContext->clear(mask->asRenderTarget(), nullptr, 0x0, true);
+ drawContext->clear(nullptr, 0x0, true);
GrPaint tempPaint;
tempPaint.setAntiAlias(doAA);
// the origin using tempPaint.
SkMatrix translate;
translate.setTranslate(-maskRect->fLeft, -maskRect->fTop);
- drawContext->drawPath(mask->asRenderTarget(), clip, tempPaint, translate, devPath, strokeInfo);
+ drawContext->drawPath(clip, tempPaint, translate, devPath, strokeInfo);
return mask;
}
if (paint.getMaskFilter()->directFilterMaskGPU(context->textureProvider(),
drawContext,
- renderTarget,
&grPaint,
clip,
viewMatrix,
// filterMaskGPU gives us ownership of a ref to the result
SkAutoTUnref<GrTexture> atu(filtered);
if (draw_mask(drawContext,
- renderTarget,
clip,
viewMatrix,
maskRect,
// GPU path fails
SkPaint::Style style = strokeInfo.isHairlineStyle() ? SkPaint::kStroke_Style :
SkPaint::kFill_Style;
- draw_with_mask_filter(drawContext, context->textureProvider(), renderTarget,
+ draw_with_mask_filter(drawContext, context->textureProvider(),
clip, viewMatrix, *devPathPtr,
paint.getMaskFilter(), clipBounds, &grPaint, style);
return;
}
- drawContext->drawPath(renderTarget, clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
+ drawContext->drawPath(clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
}
return fTextContexts[props.pixelGeometry()][useDIF];
}
-GrDrawContext* GrContext::DrawingMgr::drawContext(const SkSurfaceProps* surfaceProps) {
+GrDrawContext* GrContext::DrawingMgr::drawContext(GrRenderTarget* rt,
+ const SkSurfaceProps* surfaceProps) {
if (this->abandoned()) {
return nullptr;
}
- return new GrDrawContext(fContext, fDrawTarget, surfaceProps);
+ return new GrDrawContext(fContext, rt, fDrawTarget, surfaceProps);
}
////////////////////////////////////////////////////////////////////////////////
}
SkMatrix matrix;
matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top));
- SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(renderTarget));
if (!drawContext) {
return false;
}
paint.addColorFragmentProcessor(fp);
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
- drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, matrix, rect, nullptr);
+ drawContext->drawRect(GrClip::WideOpen(), paint, matrix, rect, nullptr);
if (kFlushWrites_PixelOp & pixelOpsFlags) {
this->flushSurfaceWrites(surface);
if (fp) {
paint.addColorFragmentProcessor(fp);
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
- SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
- drawContext->drawRect(temp->asRenderTarget(), GrClip::WideOpen(), paint,
- SkMatrix::I(), rect, nullptr);
+ SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(temp->asRenderTarget()));
+ drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect, nullptr);
surfaceToRead.reset(SkRef(temp.get()));
left = 0;
top = 0;
return;
}
- SkAutoTUnref<GrDrawContext> drawContext(this->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(this->drawContext(dst->asRenderTarget()));
if (!drawContext) {
return;
}
- drawContext->copySurface(dst->asRenderTarget(), src, srcRect, dstPoint);
+ drawContext->copySurface(src, srcRect, dstPoint);
if (kFlushWrites_PixelOp & pixelOpsFlags) {
this->flush();
};
GrDrawContext::GrDrawContext(GrContext* context,
+ GrRenderTarget* rt,
GrDrawTarget* drawTarget,
const SkSurfaceProps* surfaceProps)
: fContext(context)
+ , fRenderTarget(rt)
, fDrawTarget(SkRef(drawTarget))
, fTextContext(nullptr)
, fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps)) {
+ SkDEBUGCODE(this->validate();)
}
GrDrawContext::~GrDrawContext() {
SkSafeUnref(fDrawTarget);
}
-void GrDrawContext::copySurface(GrRenderTarget* dst, GrSurface* src,
- const SkIRect& srcRect, const SkIPoint& dstPoint) {
- RETURN_IF_ABANDONED
+#ifdef SK_DEBUG
+void GrDrawContext::validate() const {
+ SkASSERT(fRenderTarget);
+ ASSERT_OWNED_RESOURCE(fRenderTarget);
+}
+#endif
- if (!this->prepareToDraw(dst)) {
- return;
- }
+void GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) {
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
- fDrawTarget->copySurface(dst, src, srcRect, dstPoint);
+ fDrawTarget->copySurface(fRenderTarget, src, srcRect, dstPoint);
}
-void GrDrawContext::drawText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+void GrDrawContext::drawText(const GrClip& clip, const GrPaint& grPaint,
const SkPaint& skPaint,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& clipBounds) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
if (!fTextContext) {
- fTextContext = fContext->textContext(fSurfaceProps, rt);
+ fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
}
- fTextContext->drawText(this, rt, clip, grPaint, skPaint, viewMatrix,
+ fTextContext->drawText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix,
text, byteLength, x, y, clipBounds);
}
-void GrDrawContext::drawPosText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+void GrDrawContext::drawPosText(const GrClip& clip, const GrPaint& grPaint,
const SkPaint& skPaint,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkIRect& clipBounds) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
if (!fTextContext) {
- fTextContext = fContext->textContext(fSurfaceProps, rt);
+ fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
}
- fTextContext->drawPosText(this, rt, clip, grPaint, skPaint, viewMatrix, text, byteLength,
+ fTextContext->drawPosText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix, text, byteLength,
pos, scalarsPerPosition, offset, clipBounds);
}
-void GrDrawContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip, const SkPaint& skPaint,
+void GrDrawContext::drawTextBlob(const GrClip& clip, const SkPaint& skPaint,
const SkMatrix& viewMatrix, const SkTextBlob* blob,
SkScalar x, SkScalar y,
SkDrawFilter* filter, const SkIRect& clipBounds) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
if (!fTextContext) {
- fTextContext = fContext->textContext(fSurfaceProps, rt);
+ fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
}
- fTextContext->drawTextBlob(this, rt,
+ fTextContext->drawTextBlob(this, fRenderTarget,
clip, skPaint, viewMatrix, blob, x, y, filter, clipBounds);
}
GrPathRangeDraw* draw,
int /*GrPathRendering::FillType*/ fill) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
fDrawTarget->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color, range, draw,
(GrPathRendering::FillType) fill);
}
-void GrDrawContext::discard(GrRenderTarget* renderTarget) {
+void GrDrawContext::discard() {
RETURN_IF_ABANDONED
- SkASSERT(renderTarget);
+ SkDEBUGCODE(this->validate();)
+
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(renderTarget)) {
- return;
- }
- fDrawTarget->discard(renderTarget);
+ fDrawTarget->discard(fRenderTarget);
}
-void GrDrawContext::clear(GrRenderTarget* renderTarget,
- const SkIRect* rect,
+void GrDrawContext::clear(const SkIRect* rect,
const GrColor color,
bool canIgnoreRect) {
RETURN_IF_ABANDONED
- SkASSERT(renderTarget);
+ SkDEBUGCODE(this->validate();)
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(renderTarget)) {
- return;
- }
- fDrawTarget->clear(rect, color, canIgnoreRect, renderTarget);
+ fDrawTarget->clear(rect, color, canIgnoreRect, fRenderTarget);
}
-void GrDrawContext::drawPaint(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawPaint(const GrClip& clip,
const GrPaint& origPaint,
const SkMatrix& viewMatrix) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
// set rect to be big enough to fill the space, but not super-huge, so we
// don't overflow fixed-point implementations
SkRect r;
r.setLTRB(0, 0,
- SkIntToScalar(rt->width()),
- SkIntToScalar(rt->height()));
+ SkIntToScalar(fRenderTarget->width()),
+ SkIntToScalar(fRenderTarget->height()));
SkTCopyOnFirstWrite<GrPaint> paint(origPaint);
// by definition this fills the entire clip, no need for AA
return;
}
inverse.mapRect(&r);
- this->drawRect(rt, clip, *paint, viewMatrix, r);
+ this->drawRect(clip, *paint, viewMatrix, r);
} else {
SkMatrix localMatrix;
if (!viewMatrix.invert(&localMatrix)) {
}
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
fDrawTarget->drawNonAARect(pipelineBuilder,
paint->getColor(),
SkMatrix::I(),
point.fY >= rect.fTop && point.fY <= rect.fBottom;
}
-void GrDrawContext::drawRect(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawRect(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rect,
const GrStrokeInfo* strokeInfo) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
if (strokeInfo && strokeInfo->isDashed()) {
SkPath path;
path.setIsVolatile(true);
path.addRect(rect);
- this->drawPath(rt, clip, paint, viewMatrix, path, *strokeInfo);
+ this->drawPath(clip, paint, viewMatrix, path, *strokeInfo);
return;
}
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
SkScalar width = nullptr == strokeInfo ? -1 : strokeInfo->getWidth();
// Will it blend?
GrColor clearColor;
if (paint.isConstantBlendedColor(&clearColor)) {
- fDrawTarget->clear(nullptr, clearColor, true, rt);
+ fDrawTarget->clear(nullptr, clearColor, true, fRenderTarget);
return;
}
}
if (width >= 0) {
// Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
- bool snapToPixelCenters = (0 == width && !rt->isUnifiedMultisampled());
+ bool snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAStroke(
color, viewMatrix, rect, width, snapToPixelCenters));
}
}
-void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawNonAARectToRect(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rectToDraw,
const SkRect& localRect) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
fDrawTarget->drawNonAARect(pipelineBuilder,
paint.getColor(),
viewMatrix,
localRect);
}
-void GrDrawContext::drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawNonAARectWithLocalMatrix(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& rectToDraw,
const SkMatrix& localMatrix) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
fDrawTarget->drawNonAARect(pipelineBuilder,
paint.getColor(),
viewMatrix,
localMatrix);
}
-void GrDrawContext::drawVertices(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawVertices(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
GrPrimitiveType primitiveType,
const uint16_t indices[],
int indexCount) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
// TODO clients should give us bounds
SkRect bounds;
///////////////////////////////////////////////////////////////////////////////
-void GrDrawContext::drawAtlas(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawAtlas(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
int spriteCount,
const SkRect texRect[],
const SkColor colors[]) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrDrawAtlasBatch::Geometry geometry;
geometry.fColor = paint.getColor();
///////////////////////////////////////////////////////////////////////////////
-void GrDrawContext::drawRRect(GrRenderTarget*rt,
- const GrClip& clip,
+void GrDrawContext::drawRRect(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRRect& rrect,
const GrStrokeInfo& strokeInfo) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
if (rrect.isEmpty()) {
return;
}
SkPath path;
path.setIsVolatile(true);
path.addRRect(rrect);
- this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
+ this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
return;
}
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
+
if (!GrOvalRenderer::DrawRRect(fDrawTarget,
pipelineBuilder,
color,
///////////////////////////////////////////////////////////////////////////////
-void GrDrawContext::drawDRRect(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawDRRect(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRRect& outer,
const SkRRect& inner) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
if (outer.isEmpty()) {
return;
}
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
if (!GrOvalRenderer::DrawDRRect(fDrawTarget,
pipelineBuilder,
///////////////////////////////////////////////////////////////////////////////
-void GrDrawContext::drawOval(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawOval(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkRect& oval,
const GrStrokeInfo& strokeInfo) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
if (oval.isEmpty()) {
return;
}
SkPath path;
path.setIsVolatile(true);
path.addOval(oval);
- this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
+ this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
return;
}
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
GrColor color = paint.getColor();
+
if (!GrOvalRenderer::DrawOval(fDrawTarget,
pipelineBuilder,
color,
return allEq || allGoE1;
}
-void GrDrawContext::drawBatch(GrRenderTarget* rt, const GrClip& clip,
+void GrDrawContext::drawBatch(const GrClip& clip,
const GrPaint& paint, GrDrawBatch* batch) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
fDrawTarget->drawBatch(pipelineBuilder, batch);
}
-void GrDrawContext::drawPath(GrRenderTarget* rt,
- const GrClip& clip,
+void GrDrawContext::drawPath(const GrClip& clip,
const GrPaint& paint,
const SkMatrix& viewMatrix,
const SkPath& path,
const GrStrokeInfo& strokeInfo) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+
if (path.isEmpty()) {
if (path.isInverseFillType()) {
- this->drawPaint(rt, clip, paint, viewMatrix);
+ this->drawPaint(clip, paint, viewMatrix);
}
return;
}
// the writePixels that uploads to the scratch will perform a flush so we're
// OK.
AutoCheckFlush acf(fContext);
- if (!this->prepareToDraw(rt)) {
- return;
- }
- GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+ GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
if (!strokeInfo.isDashed()) {
bool useCoverageAA = paint.isAntiAlias() &&
!pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
RETURN_IF_ABANDONED
SkASSERT(!path.isEmpty());
-
// An Assumption here is that path renderer would use some form of tweaking
// the src color (either the input alpha or in the frag shader) to implement
// aa. If we have some future driver-mojo path AA that can do the right
pr->drawPath(args);
}
-bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
- RETURN_FALSE_IF_ABANDONED
-
- ASSERT_OWNED_RESOURCE(rt);
- SkASSERT(rt);
- return true;
-}
-
void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
fDrawTarget->drawBatch(*pipelineBuilder, batch);
}
SkASSERT(0 == fPictureHash.count());
- SkAutoTUnref<GrDrawContext> drawContext(fContext->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(
+ fContext->drawContext(fAtlas->getTexture()->asRenderTarget()));
if (drawContext) {
- drawContext->discard(fAtlas->getTexture()->asRenderTarget());
+ drawContext->discard();
}
}
#endif
return;
}
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(this));
if (!drawContext) {
return;
}
- drawContext->discard(this);
+ drawContext->discard();
}
void GrRenderTarget::flagAsNeedingResolve(const SkIRect* rect) {
paint.addColorFragmentProcessor(yuvToRgbProcessor);
const SkRect r = SkRect::MakeIWH(yuvInfo.fSize[0].fWidth, yuvInfo.fSize[0].fHeight);
- SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext(renderTarget));
if (!drawContext) {
return nullptr;
}
- drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, SkMatrix::I(), r);
+ drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), r);
return result.detach();
}
fLegacyBitmap.setInfo(info);
fLegacyBitmap.setPixelRef(pr)->unref();
- fDrawContext.reset(fContext->drawContext(&this->surfaceProps()));
+ fDrawContext.reset(fContext->drawContext(rt, &this->surfaceProps()));
}
GrRenderTarget* SkGpuDevice::CreateRenderTarget(GrContext* context, SkSurface::Budgeted budgeted,
GrColor color = 0;
GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::clearAll", fContext);
SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
- fDrawContext->clear(fRenderTarget, &rect, color, true);
+ fDrawContext->clear(&rect, color, true);
fNeedClear = false;
}
SkPixelRef* pr = new SkGrPixelRef(fLegacyBitmap.info(), fRenderTarget);
fLegacyBitmap.setPixelRef(pr)->unref();
- fDrawContext.reset(fRenderTarget->getContext()->drawContext(&this->surfaceProps()));
+ fDrawContext.reset(fRenderTarget->getContext()->drawContext(fRenderTarget,
+ &this->surfaceProps()));
}
///////////////////////////////////////////////////////////////////////////////
return;
}
- fDrawContext->drawPaint(fRenderTarget, fClip, grPaint, *draw.fMatrix);
+ fDrawContext->drawPaint(fClip, grPaint, *draw.fMatrix);
}
// must be in SkCanvas::PointMode order
path.setIsVolatile(true);
path.moveTo(pts[0]);
path.lineTo(pts[1]);
- fDrawContext->drawPath(fRenderTarget, fClip, grPaint, *draw.fMatrix, path, strokeInfo);
+ fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, strokeInfo);
return;
}
return;
}
- fDrawContext->drawVertices(fRenderTarget,
- fClip,
+ fDrawContext->drawVertices(fClip,
grPaint,
*draw.fMatrix,
gPointMode2PrimtiveType[mode],
return;
}
- fDrawContext->drawRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
+ fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
}
///////////////////////////////////////////////////////////////////////////////
}
if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext->textureProvider(),
fDrawContext,
- fRenderTarget,
&grPaint,
fClip,
*draw.fMatrix,
return;
}
- fDrawContext->drawRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
+ fDrawContext->drawRRect(fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
}
void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
}
if (nullptr == paint.getMaskFilter() && nullptr == paint.getPathEffect()) {
- fDrawContext->drawDRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, outer, inner);
+ fDrawContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner);
return;
}
}
return;
}
- fDrawContext->drawOval(fRenderTarget, fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
+ fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
}
#include "SkMaskFilter.h"
dstRect,
devRect));
- drawContext->drawBatch(renderTarget, clip, grPaint, batch);
+ drawContext->drawBatch(clip, grPaint, batch);
}
static bool can_ignore_strict_subset_constraint(const SkBitmap& bitmap, const SkRect& subset) {
if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
// We don't have local coords in this case and have previously set the transform
// matrices directly on the texture processor.
- fDrawContext->drawRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect);
+ fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
} else {
- fDrawContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect,
- paintRect);
+ fDrawContext->drawNonAARectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
}
}
return;
}
- fDrawContext->drawNonAARectToRect(fRenderTarget,
- fClip,
+ fDrawContext->drawNonAARectToRect(fClip,
grPaint,
SkMatrix::I(),
SkRect::MakeXYWH(SkIntToScalar(left),
SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
SK_Scalar1 * h / devTex->height());
- fDrawContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, SkMatrix::I(), dstRect,
- srcRect);
+ fDrawContext->drawNonAARectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
}
bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
lineIndices[i + 5] = state.f0;
i += 6;
}
- fDrawContext->drawVertices(fRenderTarget,
- fClip,
+ fDrawContext->drawVertices(fClip,
grPaint,
*draw.fMatrix,
kLines_GrPrimitiveType,
}
}
- fDrawContext->drawVertices(fRenderTarget,
- fClip,
+ fDrawContext->drawVertices(fClip,
grPaint,
*draw.fMatrix,
primType,
}
SkDEBUGCODE(this->validate();)
- fDrawContext->drawAtlas(fRenderTarget, fClip, grPaint, *draw.fMatrix,
- count, xform, texRect, colors);
+ fDrawContext->drawAtlas(fClip, grPaint, *draw.fMatrix, count, xform, texRect, colors);
}
///////////////////////////////////////////////////////////////////////////////
SkDEBUGCODE(this->validate();)
- fDrawContext->drawText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
+ fDrawContext->drawText(fClip, grPaint, paint, *draw.fMatrix,
(const char *)text, byteLength, x, y, draw.fClip->getBounds());
}
SkDEBUGCODE(this->validate();)
- fDrawContext->drawPosText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
+ fDrawContext->drawPosText(fClip, grPaint, paint, *draw.fMatrix,
(const char *)text, byteLength, pos, scalarsPerPos, offset,
draw.fClip->getBounds());
}
SkDEBUGCODE(this->validate();)
- fDrawContext->drawTextBlob(fRenderTarget, fClip, paint, *draw.fMatrix,
+ fDrawContext->drawTextBlob(fClip, paint, *draw.fMatrix,
blob, x, y, drawFilter, draw.fClip->getBounds());
}
SkRect rect = SkRect::MakeWH(SkIntToScalar(rtDesc.fWidth), SkIntToScalar(rtDesc.fHeight));
SkRect localRect = SkRect::MakeWH(1.f, 1.f);
- SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(stretched->asRenderTarget()));
if (!drawContext) {
return nullptr;
}
- drawContext->drawNonAARectToRect(stretched->asRenderTarget(), GrClip::WideOpen(), paint,
- SkMatrix::I(), rect, localRect);
+ drawContext->drawNonAARectToRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect, localRect);
return stretched.detach();
}
paint1.addColorFragmentProcessor(pmToUPM1);
- SkAutoTUnref<GrDrawContext> readDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> readDrawContext(context->drawContext(readTex->asRenderTarget()));
if (!readDrawContext) {
failed = true;
break;
}
- readDrawContext->drawNonAARectToRect(readTex->asRenderTarget(),
- GrClip::WideOpen(),
+ readDrawContext->drawNonAARectToRect(GrClip::WideOpen(),
paint1,
SkMatrix::I(),
kDstRect,
paint2.addColorFragmentProcessor(upmToPM);
- SkAutoTUnref<GrDrawContext> tempDrawContext(context->drawContext());
+ SkAutoTUnref<GrDrawContext> tempDrawContext(context->drawContext(tempTex->asRenderTarget()));
if (!tempDrawContext) {
failed = true;
break;
}
- tempDrawContext->drawNonAARectToRect(tempTex->asRenderTarget(),
- GrClip::WideOpen(),
+ tempDrawContext->drawNonAARectToRect(GrClip::WideOpen(),
paint2,
SkMatrix::I(),
kDstRect,
paint3.addColorFragmentProcessor(pmToUPM2);
- readDrawContext.reset(context->drawContext());
+ readDrawContext.reset(context->drawContext(readTex->asRenderTarget()));
if (!readDrawContext) {
failed = true;
break;
}
- readDrawContext->drawNonAARectToRect(readTex->asRenderTarget(),
- GrClip::WideOpen(),
+ readDrawContext->drawNonAARectToRect(GrClip::WideOpen(),
paint3,
SkMatrix::I(),
kDstRect,
const SkRect rect = SkRect::MakeWH(SkIntToScalar(dstDesc.fWidth),
SkIntToScalar(dstDesc.fHeight));
- SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext());
+ SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext(dst->asRenderTarget()));
if (!drawContext) {
return nullptr;
}
- drawContext->drawRect(dst->asRenderTarget(), GrClip::WideOpen(), paint, SkMatrix::I(), rect);
+ drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), rect);
ctx->flushSurfaceWrites(dst);
return new SkImage_Gpu(dstDesc.fWidth, dstDesc.fHeight, kNeedNewImageUniqueID,
kOpaque_SkAlphaType, dst, budgeted);
projects / platform / upstream / libSkiaSharp.git / commitdiff