123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213 |
- /*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "src/gpu/GrOpFlushState.h"
- #include "include/gpu/GrTexture.h"
- #include "src/core/SkConvertPixels.h"
- #include "src/gpu/GrContextPriv.h"
- #include "src/gpu/GrDrawOpAtlas.h"
- #include "src/gpu/GrGpu.h"
- #include "src/gpu/GrResourceProvider.h"
- //////////////////////////////////////////////////////////////////////////////
- GrOpFlushState::GrOpFlushState(GrGpu* gpu, GrResourceProvider* resourceProvider,
- GrTokenTracker* tokenTracker,
- sk_sp<GrBufferAllocPool::CpuBufferCache> cpuBufferCache)
- : fVertexPool(gpu, cpuBufferCache)
- , fIndexPool(gpu, std::move(cpuBufferCache))
- , fGpu(gpu)
- , fResourceProvider(resourceProvider)
- , fTokenTracker(tokenTracker)
- , fDeinstantiateProxyTracker() {}
- const GrCaps& GrOpFlushState::caps() const {
- return *fGpu->caps();
- }
- GrGpuRTCommandBuffer* GrOpFlushState::rtCommandBuffer() {
- return fCommandBuffer->asRTCommandBuffer();
- }
- void GrOpFlushState::executeDrawsAndUploadsForMeshDrawOp(
- const GrOp* op, const SkRect& chainBounds, GrProcessorSet&& processorSet,
- GrPipeline::InputFlags pipelineFlags, const GrUserStencilSettings* stencilSettings) {
- SkASSERT(this->rtCommandBuffer());
- GrPipeline::InitArgs pipelineArgs;
- pipelineArgs.fInputFlags = pipelineFlags;
- pipelineArgs.fDstProxy = this->dstProxy();
- pipelineArgs.fCaps = &this->caps();
- pipelineArgs.fUserStencil = stencilSettings;
- pipelineArgs.fOutputSwizzle = this->drawOpArgs().fOutputSwizzle;
- GrPipeline pipeline(pipelineArgs, std::move(processorSet), this->detachAppliedClip());
- while (fCurrDraw != fDraws.end() && fCurrDraw->fOp == op) {
- GrDeferredUploadToken drawToken = fTokenTracker->nextTokenToFlush();
- while (fCurrUpload != fInlineUploads.end() &&
- fCurrUpload->fUploadBeforeToken == drawToken) {
- this->rtCommandBuffer()->inlineUpload(this, fCurrUpload->fUpload);
- ++fCurrUpload;
- }
- this->rtCommandBuffer()->draw(
- *fCurrDraw->fGeometryProcessor, pipeline, fCurrDraw->fFixedDynamicState,
- fCurrDraw->fDynamicStateArrays, fCurrDraw->fMeshes, fCurrDraw->fMeshCnt,
- chainBounds);
- fTokenTracker->flushToken();
- ++fCurrDraw;
- }
- }
- void GrOpFlushState::preExecuteDraws() {
- fVertexPool.unmap();
- fIndexPool.unmap();
- for (auto& upload : fASAPUploads) {
- this->doUpload(upload);
- }
- // Setup execution iterators.
- fCurrDraw = fDraws.begin();
- fCurrUpload = fInlineUploads.begin();
- }
- void GrOpFlushState::reset() {
- SkASSERT(fCurrDraw == fDraws.end());
- SkASSERT(fCurrUpload == fInlineUploads.end());
- fVertexPool.reset();
- fIndexPool.reset();
- fArena.reset();
- fASAPUploads.reset();
- fInlineUploads.reset();
- fDraws.reset();
- fBaseDrawToken = GrDeferredUploadToken::AlreadyFlushedToken();
- }
- void GrOpFlushState::doUpload(GrDeferredTextureUploadFn& upload) {
- GrDeferredTextureUploadWritePixelsFn wp = [this](GrTextureProxy* dstProxy, int left, int top,
- int width, int height,
- GrColorType srcColorType, const void* buffer,
- size_t rowBytes) {
- GrSurface* dstSurface = dstProxy->peekSurface();
- if (!fGpu->caps()->surfaceSupportsWritePixels(dstSurface) &&
- fGpu->caps()->supportedWritePixelsColorType(dstSurface->config(), srcColorType) != srcColorType) {
- return false;
- }
- size_t tightRB = width * GrColorTypeToSkColorType(srcColorType);
- std::unique_ptr<char[]> tmpPixels;
- if (!fGpu->caps()->writePixelsRowBytesSupport() && rowBytes > tightRB) {
- tmpPixels.reset(new char[tightRB * height]);
- SkRectMemcpy(tmpPixels.get(), tightRB, buffer, rowBytes, tightRB, height);
- buffer = tmpPixels.get();
- rowBytes = tightRB;
- }
- return this->fGpu->writePixels(dstSurface, left, top, width, height, srcColorType, buffer,
- rowBytes);
- };
- upload(wp);
- }
- GrDeferredUploadToken GrOpFlushState::addInlineUpload(GrDeferredTextureUploadFn&& upload) {
- return fInlineUploads.append(&fArena, std::move(upload), fTokenTracker->nextDrawToken())
- .fUploadBeforeToken;
- }
- GrDeferredUploadToken GrOpFlushState::addASAPUpload(GrDeferredTextureUploadFn&& upload) {
- fASAPUploads.append(&fArena, std::move(upload));
- return fTokenTracker->nextTokenToFlush();
- }
- void GrOpFlushState::recordDraw(
- sk_sp<const GrGeometryProcessor> gp, const GrMesh meshes[], int meshCnt,
- const GrPipeline::FixedDynamicState* fixedDynamicState,
- const GrPipeline::DynamicStateArrays* dynamicStateArrays) {
- SkASSERT(fOpArgs);
- SkASSERT(fOpArgs->fOp);
- bool firstDraw = fDraws.begin() == fDraws.end();
- auto& draw = fDraws.append(&fArena);
- GrDeferredUploadToken token = fTokenTracker->issueDrawToken();
- if (fixedDynamicState && fixedDynamicState->fPrimitiveProcessorTextures) {
- for (int i = 0; i < gp->numTextureSamplers(); ++i) {
- fixedDynamicState->fPrimitiveProcessorTextures[i]->ref();
- }
- }
- if (dynamicStateArrays && dynamicStateArrays->fPrimitiveProcessorTextures) {
- int n = gp->numTextureSamplers() * meshCnt;
- for (int i = 0; i < n; ++i) {
- dynamicStateArrays->fPrimitiveProcessorTextures[i]->ref();
- }
- }
- draw.fGeometryProcessor = std::move(gp);
- draw.fFixedDynamicState = fixedDynamicState;
- draw.fDynamicStateArrays = dynamicStateArrays;
- draw.fMeshes = meshes;
- draw.fMeshCnt = meshCnt;
- draw.fOp = fOpArgs->fOp;
- if (firstDraw) {
- fBaseDrawToken = token;
- }
- }
- void* GrOpFlushState::makeVertexSpace(size_t vertexSize, int vertexCount,
- sk_sp<const GrBuffer>* buffer, int* startVertex) {
- return fVertexPool.makeSpace(vertexSize, vertexCount, buffer, startVertex);
- }
- uint16_t* GrOpFlushState::makeIndexSpace(int indexCount, sk_sp<const GrBuffer>* buffer,
- int* startIndex) {
- return reinterpret_cast<uint16_t*>(fIndexPool.makeSpace(indexCount, buffer, startIndex));
- }
- void* GrOpFlushState::makeVertexSpaceAtLeast(size_t vertexSize, int minVertexCount,
- int fallbackVertexCount, sk_sp<const GrBuffer>* buffer,
- int* startVertex, int* actualVertexCount) {
- return fVertexPool.makeSpaceAtLeast(vertexSize, minVertexCount, fallbackVertexCount, buffer,
- startVertex, actualVertexCount);
- }
- uint16_t* GrOpFlushState::makeIndexSpaceAtLeast(int minIndexCount, int fallbackIndexCount,
- sk_sp<const GrBuffer>* buffer, int* startIndex,
- int* actualIndexCount) {
- return reinterpret_cast<uint16_t*>(fIndexPool.makeSpaceAtLeast(
- minIndexCount, fallbackIndexCount, buffer, startIndex, actualIndexCount));
- }
- void GrOpFlushState::putBackIndices(int indexCount) {
- fIndexPool.putBack(indexCount * sizeof(uint16_t));
- }
- void GrOpFlushState::putBackVertices(int vertices, size_t vertexStride) {
- fVertexPool.putBack(vertices * vertexStride);
- }
- GrAppliedClip GrOpFlushState::detachAppliedClip() {
- return fOpArgs->fAppliedClip ? std::move(*fOpArgs->fAppliedClip) : GrAppliedClip();
- }
- GrStrikeCache* GrOpFlushState::glyphCache() const {
- return fGpu->getContext()->priv().getGrStrikeCache();
- }
- GrAtlasManager* GrOpFlushState::atlasManager() const {
- return fGpu->getContext()->priv().getAtlasManager();
- }
- //////////////////////////////////////////////////////////////////////////////
- GrOpFlushState::Draw::~Draw() {
- if (fFixedDynamicState && fFixedDynamicState->fPrimitiveProcessorTextures) {
- for (int i = 0; i < fGeometryProcessor->numTextureSamplers(); ++i) {
- fFixedDynamicState->fPrimitiveProcessorTextures[i]->unref();
- }
- }
- if (fDynamicStateArrays && fDynamicStateArrays->fPrimitiveProcessorTextures) {
- int n = fGeometryProcessor->numTextureSamplers() * fMeshCnt;
- const auto* textures = fDynamicStateArrays->fPrimitiveProcessorTextures;
- for (int i = 0; i < n; ++i) {
- textures[i]->unref();
- }
- }
- }
|