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

Convert DstTexture to DstProxy

Browse Source 
The last GrTexture-based TextureSampler::reset call must be removed before the TextureSamplers can become purely GrTextureProxy-backed

Split out of: https://skia-review.googlesource.com/c/10484/ (Omnibus: Push instantiation of GrTextures later (post TextureSampler))

Change-Id: Ic1435177d8b5d9bd3fc38b4903c9baae8205cfb0
Reviewed-on: https://skia-review.googlesource.com/16908
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Robert Phillips 2017-05-15 14:56:51 -04:00 committed by Skia Commit-Bot
parent 1314918f90
commit 87f7f1c3ce
19 changed files with 117 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/gpu/GrOpFlushState.h
View File

@ -102,7 +102,7 @@ public:
struct DrawOpArgs {
GrRenderTarget* fRenderTarget;
const GrAppliedClip* fAppliedClip;
GrXferProcessor::DstTexture fDstTexture;
GrXferProcessor::DstProxy fDstProxy;
};
void setDrawOpArgs(DrawOpArgs* opArgs) { fOpArgs = opArgs; }
@ -224,8 +224,8 @@ public:
const GrAppliedClip* clip() const { return this->state()->drawOpArgs().fAppliedClip; }
const GrXferProcessor::DstTexture& dstTexture() const {
return this->state()->drawOpArgs().fDstTexture;
const GrXferProcessor::DstProxy& dstProxy() const {
return this->state()->drawOpArgs().fDstProxy;
}
template <typename... Args>

16
src/gpu/GrPipeline.cpp
View File

@ -44,9 +44,13 @@ void GrPipeline::init(const InitArgs& args) {
fXferProcessor = args.fProcessors->refXferProcessor();
if (args.fDstTexture.texture()) {
fDstTexture.reset(args.fDstTexture.texture());
fDstTextureOffset = args.fDstTexture.offset();
if (args.fDstProxy.proxy()) {
if (!args.fDstProxy.proxy()->instantiate(args.fResourceProvider)) {
this->markAsBad();
}
fDstTextureProxy.reset(args.fDstProxy.proxy());
fDstTextureOffset = args.fDstProxy.offset();
}
// Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline, possibly removing some of the
@ -91,7 +95,7 @@ static void add_dependencies_for_processor(const GrFragmentProcessor* proc,
GrFragmentProcessor::TextureAccessIter iter(proc);
while (const GrResourceIOProcessor::TextureSampler* sampler = iter.next()) {
SkASSERT(rtp->getLastOpList());
rtp->getLastOpList()->addDependency(sampler->texture());
rtp->getLastOpList()->addDependency(sampler->proxy());
}
}
#endif
@ -104,8 +108,8 @@ void GrPipeline::addDependenciesTo(GrRenderTargetProxy* rtp) const {
}
#endif
if (fDstTexture) {
//SkASSERT(rtp->getLastOpList());
if (fDstTextureProxy) {
SkASSERT(rtp->getLastOpList());
// MDB TODO: re-enable when TextureSamplers store texture proxies
//rtp->getLastOpList()->addDependency(fDstTexture.get());
}

14
src/gpu/GrPipeline.h
View File

@ -75,7 +75,8 @@ public:
const GrAppliedClip* fAppliedClip = nullptr;
GrRenderTarget* fRenderTarget = nullptr;
const GrCaps* fCaps = nullptr;
GrXferProcessor::DstTexture fDstTexture;
GrResourceProvider* fResourceProvider = nullptr;
GrXferProcessor::DstProxy fDstProxy;
};
/**
@ -157,11 +158,11 @@ public:
* If the GrXferProcessor uses a texture to access the dst color, then this returns that
* texture and the offset to the dst contents within that texture.
*/
GrTexture* dstTexture(SkIPoint* offset = nullptr) const {
GrTextureProxy* dstTextureProxy(SkIPoint* offset = nullptr) const {
if (offset) {
*offset = fDstTextureOffset;
}
return fDstTexture.get();
return fDstTextureProxy.get();
}
const GrFragmentProcessor& getColorFragmentProcessor(int idx) const {
@ -215,7 +216,8 @@ public:
bool isBad() const { return SkToBool(fFlags & kIsBad_Flag); }
GrXferBarrierType xferBarrierType(const GrCaps& caps) const {
if (fDstTexture.get() && fDstTexture.get() == fRenderTarget.get()->asTexture()) {
if (fDstTextureProxy.get() &&
fDstTextureProxy.get()->priv().peekTexture() == fRenderTarget.get()->asTexture()) {
return kTexture_GrXferBarrierType;
}
return this->getXferProcessor().xferBarrierType(caps);
@ -233,11 +235,11 @@ private:
};
using RenderTarget = GrPendingIOResource<GrRenderTarget, kWrite_GrIOType>;
using DstTexture = GrPendingIOResource<GrTexture, kRead_GrIOType>;
using DstTextureProxy = GrPendingIOResource<GrTextureProxy, kRead_GrIOType>;
using PendingFragmentProcessor = GrPendingProgramElement<const GrFragmentProcessor>;
using FragmentProcessorArray = SkAutoSTArray<8, PendingFragmentProcessor>;
DstTexture fDstTexture;
DstTextureProxy fDstTextureProxy;
SkIPoint fDstTextureOffset;
RenderTarget fRenderTarget;
GrScissorState fScissorState;

12
src/gpu/GrProcessor.cpp
View File

@ -230,18 +230,6 @@ GrResourceIOProcessor::TextureSampler::TextureSampler(GrResourceProvider* resour
this->reset(resourceProvider, std::move(proxy), filterMode, tileXAndY, visibility);
}
// MDB TODO: remove this!
void GrResourceIOProcessor::TextureSampler::reset(GrTexture* texture,
GrSamplerParams::FilterMode filterMode,
SkShader::TileMode tileXAndY,
GrShaderFlags visibility) {
SkASSERT(texture);
fTexture.set(SkRef(texture), kRead_GrIOType);
filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
fParams.reset(tileXAndY, filterMode);
fVisibility = visibility;
}
void GrResourceIOProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
sk_sp<GrTextureProxy> proxy,
const GrSamplerParams& params,

6
src/gpu/GrProcessor.h
View File

@ -222,12 +222,6 @@ public:
*/
TextureSampler();
// MDB TODO: this is the last GrTexture-based reset call!
void reset(GrTexture*,
GrSamplerParams::FilterMode = GrSamplerParams::kNone_FilterMode,
SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode,
GrShaderFlags visibility = kFragment_GrShaderFlag);
// MDB TODO: ultimately we shouldn't need the resource provider parameter
TextureSampler(GrResourceProvider*, sk_sp<GrTextureProxy>, const GrSamplerParams&);
explicit TextureSampler(GrResourceProvider*, sk_sp<GrTextureProxy>,

4
src/gpu/GrProgramDesc.cpp
View File

@ -198,8 +198,8 @@ bool GrProgramDesc::Build(GrProgramDesc* desc,
const GrXferProcessor& xp = pipeline.getXferProcessor();
const GrSurfaceOrigin* originIfDstTexture = nullptr;
GrSurfaceOrigin origin;
if (pipeline.dstTexture()) {
origin = pipeline.dstTexture()->origin();
if (pipeline.dstTextureProxy()) {
origin = pipeline.dstTextureProxy()->origin();
originIfDstTexture = &origin;
}
xp.getGLSLProcessorKey(shaderCaps, &b, originIfDstTexture);

36
src/gpu/GrRenderTargetContext.cpp
View File

@ -1598,15 +1598,15 @@ uint32_t GrRenderTargetContext::addDrawOp(const GrClip& clip, std::unique_ptr<Gr
}
}
GrXferProcessor::DstTexture dstTexture;
GrXferProcessor::DstProxy dstProxy;
if (op->xpRequiresDstTexture(*this->caps(), &appliedClip)) {
if (!this->setupDstTexture(fRenderTargetProxy.get(), clip, op->bounds(), &dstTexture)) {
if (!this->setupDstProxy(this->asRenderTargetProxy(), clip, op->bounds(), &dstProxy)) {
return SK_InvalidUniqueID;
}
}
op->setClippedBounds(bounds);
return this->getOpList()->addOp(std::move(op), this, std::move(appliedClip), dstTexture);
return this->getOpList()->addOp(std::move(op), this, std::move(appliedClip), dstProxy);
}
uint32_t GrRenderTargetContext::addLegacyMeshDrawOp(GrPipelineBuilder&& pipelineBuilder,
@ -1656,9 +1656,10 @@ uint32_t GrRenderTargetContext::addLegacyMeshDrawOp(GrPipelineBuilder&& pipeline
args.fAppliedClip = &appliedClip;
args.fRenderTarget = rt;
args.fCaps = this->caps();
args.fResourceProvider = fContext->resourceProvider();
if (analysis.requiresDstTexture()) {
if (!this->setupDstTexture(fRenderTargetProxy.get(), clip, bounds, &args.fDstTexture)) {
if (!this->setupDstProxy(this->asRenderTargetProxy(), clip, bounds, &args.fDstProxy)) {
return SK_InvalidUniqueID;
}
}
@ -1671,22 +1672,15 @@ uint32_t GrRenderTargetContext::addLegacyMeshDrawOp(GrPipelineBuilder&& pipeline
return this->getOpList()->addOp(std::move(op), this);
}
bool GrRenderTargetContext::setupDstTexture(GrRenderTargetProxy* rtProxy, const GrClip& clip,
bool GrRenderTargetContext::setupDstProxy(GrRenderTargetProxy* rtProxy, const GrClip& clip,
const SkRect& opBounds,
GrXferProcessor::DstTexture* dstTexture) {
GrXferProcessor::DstProxy* dstProxy) {
if (this->caps()->textureBarrierSupport()) {
if (GrTextureProxy* texProxy = rtProxy->asTextureProxy()) {
// MDB TODO: remove this instantiation. Blocked on making DstTexture be proxy-based
sk_sp<GrTexture> tex(sk_ref_sp(texProxy->instantiate(fContext->resourceProvider())));
if (!tex) {
SkDebugf("setupDstTexture: instantiation of src texture failed.\n");
return false; // We have bigger problems now
}
// The render target is a texture, so we can read from it directly in the shader. The XP
// will be responsible to detect this situation and request a texture barrier.
dstTexture->setTexture(std::move(tex));
dstTexture->setOffset(0, 0);
dstProxy->setProxy(sk_ref_sp(texProxy));
dstProxy->setOffset(0, 0);
return true;
}
}
@ -1752,15 +1746,7 @@ bool GrRenderTargetContext::setupDstTexture(GrRenderTargetProxy* rtProxy, const
return false;
}
GrTextureProxy* copyProxy = sContext->asTextureProxy();
// MDB TODO: remove this instantiation once DstTexture is proxy-backed
sk_sp<GrTexture> copy(sk_ref_sp(copyProxy->instantiate(fContext->resourceProvider())));
if (!copy) {
SkDebugf("setupDstTexture: instantiation of copied texture failed.\n");
return false;
}
dstTexture->setTexture(std::move(copy));
dstTexture->setOffset(dstOffset);
dstProxy->setProxy(sContext->asTextureProxyRef());
dstProxy->setOffset(dstOffset);
return true;
}

8
src/gpu/GrRenderTargetContext.h
View File

@ -458,10 +458,10 @@ private:
// Makes a copy of the proxy if it is necessary for the draw and places the texture that should
// be used by GrXferProcessor to access the destination color in 'result'. If the return
// value is false then a texture copy could not be made.
bool SK_WARN_UNUSED_RESULT setupDstTexture(GrRenderTargetProxy*,
const GrClip&,
const SkRect& opBounds,
GrXferProcessor::DstTexture* result);
bool SK_WARN_UNUSED_RESULT setupDstProxy(GrRenderTargetProxy*,
const GrClip&,
const SkRect& opBounds,
GrXferProcessor::DstProxy* result);
GrRenderTargetOpList* getOpList();

20
src/gpu/GrRenderTargetOpList.cpp
View File

@ -88,7 +88,7 @@ void GrRenderTargetOpList::prepareOps(GrOpFlushState* flushState) {
opArgs = {
fRecordedOps[i].fRenderTarget.get(),
fRecordedOps[i].fAppliedClip,
fRecordedOps[i].fDstTexture
fRecordedOps[i].fDstProxy
};
}
flushState->setDrawOpArgs(&opArgs);
@ -167,7 +167,7 @@ bool GrRenderTargetOpList::executeOps(GrOpFlushState* flushState) {
GrOpFlushState::DrawOpArgs opArgs {
fRecordedOps[i].fRenderTarget.get(),
fRecordedOps[i].fAppliedClip,
fRecordedOps[i].fDstTexture
fRecordedOps[i].fDstProxy
};
flushState->setDrawOpArgs(&opArgs);
@ -273,7 +273,7 @@ static inline bool can_reorder(const SkRect& a, const SkRect& b) { return !GrRec
bool GrRenderTargetOpList::combineIfPossible(const RecordedOp& a, GrOp* b,
const GrAppliedClip* bClip,
const DstTexture* bDstTexture,
const DstProxy* bDstProxy,
const GrCaps& caps) {
if (a.fAppliedClip) {
if (!bClip) {
@ -285,11 +285,11 @@ bool GrRenderTargetOpList::combineIfPossible(const RecordedOp& a, GrOp* b,
} else if (bClip) {
return false;
}
if (bDstTexture) {
if (a.fDstTexture != *bDstTexture) {
if (bDstProxy) {
if (a.fDstProxy != *bDstProxy) {
return false;
}
} else if (a.fDstTexture.texture()) {
} else if (a.fDstProxy.proxy()) {
return false;
}
return a.fOp->combineIfPossible(b, caps);
@ -298,7 +298,7 @@ bool GrRenderTargetOpList::combineIfPossible(const RecordedOp& a, GrOp* b,
GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
GrRenderTargetContext* renderTargetContext,
GrAppliedClip* clip,
const DstTexture* dstTexture) {
const DstProxy* dstProxy) {
GrRenderTarget* renderTarget = renderTargetContext->accessRenderTarget();
if (!renderTarget) {
SkASSERT(false);
@ -345,7 +345,7 @@ GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
candidate.fOp->uniqueID());
break;
}
if (this->combineIfPossible(candidate, op.get(), clip, dstTexture, *caps)) {
if (this->combineIfPossible(candidate, op.get(), clip, dstProxy, *caps)) {
GrOP_INFO("\t\tBackward: Combining with (%s, opID: %u)\n", candidate.fOp->name(),
candidate.fOp->uniqueID());
GrOP_INFO("\t\t\tBackward: Combined op info:\n");
@ -373,7 +373,7 @@ GrOp* GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op,
clip = fClipAllocator.make<GrAppliedClip>(std::move(*clip));
SkDEBUGCODE(fNumClips++;)
}
fRecordedOps.emplace_back(std::move(op), renderTarget, clip, dstTexture);
fRecordedOps.emplace_back(std::move(op), renderTarget, clip, dstProxy);
fRecordedOps.back().fOp->wasRecorded(this);
fLastFullClearOp = nullptr;
fLastFullClearResourceID.makeInvalid();
@ -404,7 +404,7 @@ void GrRenderTargetOpList::forwardCombine(const GrCaps& caps) {
break;
}
if (this->combineIfPossible(fRecordedOps[i], candidate.fOp.get(),
candidate.fAppliedClip, &candidate.fDstTexture, caps)) {
candidate.fAppliedClip, &candidate.fDstProxy, caps)) {
GrOP_INFO("\t\tForward: Combining with (%s, opID: %u)\n", candidate.fOp->name(),
candidate.fOp->uniqueID());
GR_AUDIT_TRAIL_OPS_RESULT_COMBINED(fAuditTrail, op, candidate.fOp.get());

18
src/gpu/GrRenderTargetOpList.h
View File

@ -30,7 +30,7 @@ class GrRenderTargetProxy;
class GrRenderTargetOpList final : public GrOpList {
private:
using DstTexture = GrXferProcessor::DstTexture;
using DstProxy = GrXferProcessor::DstProxy;
public:
GrRenderTargetOpList(GrRenderTargetProxy*, GrGpu*, GrAuditTrail*);
@ -70,9 +70,9 @@ public:
return this->uniqueID();
}
uint32_t addOp(std::unique_ptr<GrOp> op, GrRenderTargetContext* renderTargetContext,
GrAppliedClip&& clip, const DstTexture& dstTexture) {
GrAppliedClip&& clip, const DstProxy& dstProxy) {
this->recordOp(std::move(op), renderTargetContext, clip.doesClip() ? &clip : nullptr,
&dstTexture);
&dstProxy);
return this->uniqueID();
}
@ -116,31 +116,31 @@ private:
RecordedOp(std::unique_ptr<GrOp> op,
GrRenderTarget* rt,
const GrAppliedClip* appliedClip,
const DstTexture* dstTexture)
const DstProxy* dstProxy)
: fOp(std::move(op))
, fRenderTarget(rt)
, fAppliedClip(appliedClip) {
if (dstTexture) {
fDstTexture = *dstTexture;
if (dstProxy) {
fDstProxy = *dstProxy;
}
}
std::unique_ptr<GrOp> fOp;
// TODO: These ops will all to target the same render target and this won't be needed.
GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
DstTexture fDstTexture;
DstProxy fDstProxy;
const GrAppliedClip* fAppliedClip;
};
// If the input op is combined with an earlier op, this returns the combined op. Otherwise, it
// returns the input op.
GrOp* recordOp(std::unique_ptr<GrOp>, GrRenderTargetContext*, GrAppliedClip* = nullptr,
const DstTexture* = nullptr);
const DstProxy* = nullptr);
void forwardCombine(const GrCaps&);
// If this returns true then b has been merged into a's op.
bool combineIfPossible(const RecordedOp& a, GrOp* b, const GrAppliedClip* bClip,
const DstTexture* bDstTexture, const GrCaps&);
const DstProxy* bDstTexture, const GrCaps&);
GrClearOp* fLastFullClearOp = nullptr;
GrGpuResource::UniqueID fLastFullClearResourceID = GrGpuResource::UniqueID::InvalidID();

44
src/gpu/GrXferProcessor.h
View File

@ -55,45 +55,55 @@ public:
* to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
* GrXferProcessor for blending in the fragment shader.
*/
class DstTexture {
class DstProxy {
public:
DstTexture() { fOffset.set(0, 0); }
DstProxy() { fOffset.set(0, 0); }
DstTexture(const DstTexture& other) {
DstProxy(const DstProxy& other) {
*this = other;
}
DstTexture(GrTexture* texture, const SkIPoint& offset)
: fTexture(SkSafeRef(texture)), fOffset(texture ? offset : SkIPoint{0, 0}) {}
DstProxy(sk_sp<GrTextureProxy> proxy, const SkIPoint& offset)
: fProxy(std::move(proxy)) {
if (fProxy) {
fOffset = offset;
} else {
fOffset.set(0, 0);
}
}
DstTexture& operator=(const DstTexture& other) {
fTexture = other.fTexture;
DstProxy& operator=(const DstProxy& other) {
fProxy = other.fProxy;
fOffset = other.fOffset;
return *this;
}
bool operator==(const DstTexture& that) const {
return fTexture == that.fTexture && fOffset == that.fOffset;
bool operator==(const DstProxy& that) const {
return fProxy == that.fProxy && fOffset == that.fOffset;
}
bool operator!=(const DstTexture& that) const { return !(*this == that); }
bool operator!=(const DstProxy& that) const { return !(*this == that); }
const SkIPoint& offset() const { return fOffset; }
void setOffset(const SkIPoint& offset) { fOffset = offset; }
void setOffset(int ox, int oy) { fOffset.set(ox, oy); }
GrTexture* texture() const { return fTexture.get(); }
GrTextureProxy* proxy() const { return fProxy.get(); }
void setTexture(sk_sp<GrTexture> texture) {
fTexture = std::move(texture);
if (!fTexture) {
void setProxy(sk_sp<GrTextureProxy> proxy) {
fProxy = std::move(proxy);
if (!fProxy) {
fOffset = {0, 0};
}
}
bool instantiate(GrResourceProvider* resourceProvider) {
return SkToBool(fProxy->instantiate(resourceProvider));
}
private:
sk_sp<GrTexture> fTexture;
SkIPoint fOffset;
sk_sp<GrTextureProxy> fProxy;
SkIPoint fOffset;
};
/**
@ -234,7 +244,7 @@ private:
#endif
class GrXPFactory {
public:
typedef GrXferProcessor::DstTexture DstTexture;
typedef GrXferProcessor::DstProxy DstProxy;
enum class AnalysisProperties : unsigned {
kNone = 0x0,

7
src/gpu/gl/GrGLProgram.cpp
View File

@ -92,7 +92,12 @@ void GrGLProgram::setData(const GrPrimitiveProcessor& primProc, const GrPipeline
const GrXferProcessor& xp = pipeline.getXferProcessor();
SkIPoint offset;
GrTexture* dstTexture = pipeline.dstTexture(&offset);
GrTextureProxy* dstProxy = pipeline.dstTextureProxy(&offset);
GrTexture* dstTexture = nullptr;
if (dstProxy) {
dstTexture = dstProxy->priv().peekTexture();
}
fXferProcessor->setData(fProgramDataManager, xp, dstTexture, offset);
if (dstTexture) {
fGpu->bindTexture(nextTexSamplerIdx++, GrSamplerParams::ClampNoFilter(), true,

5
src/gpu/glsl/GrGLSLProgramBuilder.cpp
View File

@ -237,7 +237,10 @@ void GrGLSLProgramBuilder::emitAndInstallXferProc(const SkString& colorIn,
SamplerHandle dstTextureSamplerHandle;
GrSurfaceOrigin dstTextureOrigin = kTopLeft_GrSurfaceOrigin;
if (GrTexture* dstTexture = fPipeline.dstTexture()) {
if (GrTextureProxy* dstTextureProxy = fPipeline.dstTextureProxy()) {
GrTexture* dstTexture = dstTextureProxy->priv().peekTexture();
// GrProcessor::TextureSampler sampler(dstTexture);
SkString name("DstTextureSampler");
dstTextureSamplerHandle =

3
src/gpu/instanced/InstancedOp.cpp
View File

@ -229,6 +229,7 @@ void InstancedOp::onExecute(GrOpFlushState* state) {
GrPipeline::InitArgs args;
args.fAppliedClip = state->drawOpArgs().fAppliedClip;
args.fCaps = &state->caps();
args.fResourceProvider = state->resourceProvider();
args.fProcessors = &fProcessors;
args.fFlags = GrAATypeIsHW(fInfo.aaType()) ? GrPipeline::kHWAntialias_Flag : 0;
if (fAllowsSRGBInputs) {
@ -238,7 +239,7 @@ void InstancedOp::onExecute(GrOpFlushState* state) {
args.fFlags |= GrPipeline::kDisableOutputConversionToSRGB_Flag;
}
args.fRenderTarget = state->drawOpArgs().fRenderTarget;
args.fDstTexture = state->drawOpArgs().fDstTexture;
args.fDstProxy = state->drawOpArgs().fDstProxy;
pipeline.init(args);
if (GrXferBarrierType barrierType = pipeline.xferBarrierType(*state->gpu()->caps())) {

3
src/gpu/ops/GrDrawPathOp.cpp
View File

@ -48,7 +48,8 @@ void GrDrawPathOpBase::initPipeline(const GrOpFlushState& state, GrPipeline* pip
args.fAppliedClip = state.drawOpArgs().fAppliedClip;
args.fRenderTarget = state.drawOpArgs().fRenderTarget;
args.fCaps = &state.caps();
args.fDstTexture = state.drawOpArgs().fDstTexture;
args.fResourceProvider = state.resourceProvider();
args.fDstProxy = state.drawOpArgs().fDstProxy;
return pipeline->init(args);
}

3
src/gpu/ops/GrSimpleMeshDrawOpHelper.h
View File

@ -137,8 +137,9 @@ protected:
args.fProcessors = &this->processors();
args.fRenderTarget = target->renderTarget();
args.fAppliedClip = target->clip();
args.fDstTexture = target->dstTexture();
args.fDstProxy = target->dstProxy();
args.fCaps = &target->caps();
args.fResourceProvider = target->resourceProvider();
return args;
}

3
src/gpu/vk/GrVkGpuCommandBuffer.cpp
View File

@ -533,7 +533,8 @@ void GrVkGpuCommandBuffer::onDraw(const GrPipeline& pipeline,
while (const GrFragmentProcessor* fp = iter.next()) {
prepare_sampled_images(*fp, fGpu);
}
if (GrVkTexture* dstTexture = static_cast<GrVkTexture*>(pipeline.dstTexture())) {
if (GrTextureProxy* dstTextureProxy = pipeline.dstTextureProxy()) {
GrVkTexture* dstTexture = static_cast<GrVkTexture*>(dstTextureProxy->priv().peekTexture());
set_texture_layout(dstTexture, fGpu);
}

12
src/gpu/vk/GrVkPipelineState.cpp
View File

@ -7,6 +7,7 @@
#include "GrVkPipelineState.h"
#include "GrContext.h"
#include "GrPipeline.h"
#include "GrTexturePriv.h"
#include "GrVkBufferView.h"
@ -258,12 +259,17 @@ void GrVkPipelineState::setData(GrVkGpu* gpu,
SkASSERT(!fp && !glslFP);
SkIPoint offset;
GrTexture* dstTexture = pipeline.dstTexture(&offset);
GrTextureProxy* dstTextureProxy = nullptr;
GrTexture* dstTexture = nullptr;
if (dstTextureProxy = pipeline.dstTextureProxy(&offset)) {
dstTexture = dstTextureProxy->priv().peekTexture();
}
fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset);
GrResourceIOProcessor::TextureSampler dstTextureSampler;
if (dstTexture) {
if (dstTextureProxy) {
// MDB TODO: this is the last usage of a GrTexture-based TextureSampler reset method
dstTextureSampler.reset(dstTexture);
dstTextureSampler.reset(gpu->getContext()->resourceProvider(), sk_ref_sp(dstTextureProxy));
textureBindings.push_back(&dstTextureSampler);
}

11
tests/GrPorterDuffTest.cpp
View File

@ -1044,11 +1044,12 @@ DEF_GPUTEST(PorterDuffNoDualSourceBlending, reporter, /*factory*/) {
kRGBA_8888_GrPixelConfig,
backendTexHandle);
GrXferProcessor::DstTexture fakeDstTexture;
fakeDstTexture.setTexture(
ctx->resourceProvider()->wrapBackendTexture(backendTex, kTopLeft_GrSurfaceOrigin,
kNone_GrBackendTextureFlag, 0,
kBorrow_GrWrapOwnership));
GrXferProcessor::DstProxy fakeDstProxy;
{
sk_sp<GrTextureProxy> proxy = GrSurfaceProxy::MakeWrappedBackend(ctx, backendTex,
kTopLeft_GrSurfaceOrigin);
fakeDstProxy.setProxy(std::move(proxy));
}
static const GrProcessorAnalysisColor colorInputs[] = {
GrProcessorAnalysisColor::Opaque::kNo, GrProcessorAnalysisColor::Opaque::kYes,