bsalomon | 16b9913 | 2015-08-13 14:55:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/gpu/ops/GrMeshDrawOp.h" |
bsalomon | 16b9913 | 2015-08-13 14:55:50 -0700 | [diff] [blame] | 9 | |
Greg Daniel | 2d41d0d | 2019-08-26 11:08:51 -0400 | [diff] [blame] | 10 | #include "src/gpu/GrOpFlushState.h" |
| 11 | #include "src/gpu/GrOpsRenderPass.h" |
Robert Phillips | 2669a7b | 2020-03-12 12:07:19 -0400 | [diff] [blame^] | 12 | #include "src/gpu/GrRecordingContextPriv.h" |
Greg Daniel | 2d41d0d | 2019-08-26 11:08:51 -0400 | [diff] [blame] | 13 | #include "src/gpu/GrResourceProvider.h" |
| 14 | |
Brian Salomon | 7dc6e75 | 2017-11-02 11:34:51 -0400 | [diff] [blame] | 15 | GrMeshDrawOp::GrMeshDrawOp(uint32_t classID) : INHERITED(classID) {} |
bsalomon | 16b9913 | 2015-08-13 14:55:50 -0700 | [diff] [blame] | 16 | |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 17 | void GrMeshDrawOp::onPrepare(GrOpFlushState* state) { this->onPrepareDraws(state); } |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 18 | |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 19 | void GrMeshDrawOp::createProgramInfo(Target* target) { |
| 20 | this->createProgramInfo(&target->caps(), |
| 21 | target->allocator(), |
| 22 | target->outputView(), |
| 23 | target->detachAppliedClip(), |
| 24 | target->dstProxyView()); |
| 25 | } |
| 26 | |
Robert Phillips | 2669a7b | 2020-03-12 12:07:19 -0400 | [diff] [blame^] | 27 | // This onPrepareDraws implementation assumes the derived Op only has a single programInfo - |
| 28 | // which is the majority of the cases. |
| 29 | void GrMeshDrawOp::onPrePrepareDraws(GrRecordingContext* context, |
| 30 | const GrSurfaceProxyView* outputView, |
| 31 | GrAppliedClip* clip, |
| 32 | const GrXferProcessor::DstProxyView& dstProxyView) { |
| 33 | SkArenaAlloc* arena = context->priv().recordTimeAllocator(); |
| 34 | |
| 35 | // This is equivalent to a GrOpFlushState::detachAppliedClip |
| 36 | GrAppliedClip appliedClip = clip ? std::move(*clip) : GrAppliedClip(); |
| 37 | |
| 38 | this->createProgramInfo(context->priv().caps(), arena, outputView, |
| 39 | std::move(appliedClip), dstProxyView); |
| 40 | |
| 41 | context->priv().recordProgramInfo(this->programInfo()); |
| 42 | } |
| 43 | |
Brian Salomon | b948572 | 2018-08-05 21:30:33 -0400 | [diff] [blame] | 44 | ////////////////////////////////////////////////////////////////////////////// |
| 45 | |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 46 | GrMeshDrawOp::PatternHelper::PatternHelper(Target* target, GrPrimitiveType primitiveType, |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 47 | size_t vertexStride, sk_sp<const GrBuffer> indexBuffer, |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 48 | int verticesPerRepetition, int indicesPerRepetition, |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 49 | int repeatCount, int maxRepetitions) { |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 50 | this->init(target, primitiveType, vertexStride, std::move(indexBuffer), verticesPerRepetition, |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 51 | indicesPerRepetition, repeatCount, maxRepetitions); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | void GrMeshDrawOp::PatternHelper::init(Target* target, GrPrimitiveType primitiveType, |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 55 | size_t vertexStride, sk_sp<const GrBuffer> indexBuffer, |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 56 | int verticesPerRepetition, int indicesPerRepetition, |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 57 | int repeatCount, int maxRepetitions) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 58 | SkASSERT(target); |
| 59 | if (!indexBuffer) { |
| 60 | return; |
| 61 | } |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 62 | sk_sp<const GrBuffer> vertexBuffer; |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 63 | int firstVertex; |
| 64 | int vertexCount = verticesPerRepetition * repeatCount; |
| 65 | fVertices = target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex); |
| 66 | if (!fVertices) { |
| 67 | SkDebugf("Vertices could not be allocated for patterned rendering."); |
| 68 | return; |
| 69 | } |
| 70 | SkASSERT(vertexBuffer); |
Chris Dalton | 79f336d | 2020-02-11 14:42:56 -0700 | [diff] [blame] | 71 | fMesh = target->allocMesh(); |
Robert Phillips | cea290f | 2019-11-06 11:21:03 -0500 | [diff] [blame] | 72 | fPrimitiveType = primitiveType; |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 73 | |
| 74 | SkASSERT(maxRepetitions == |
| 75 | static_cast<int>(indexBuffer->size() / (sizeof(uint16_t) * indicesPerRepetition))); |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 76 | fMesh->setIndexedPatterned(std::move(indexBuffer), indicesPerRepetition, verticesPerRepetition, |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 77 | repeatCount, maxRepetitions); |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 78 | fMesh->setVertexData(std::move(vertexBuffer), firstVertex); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 79 | } |
| 80 | |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 81 | void GrMeshDrawOp::PatternHelper::recordDraw(Target* target, const GrGeometryProcessor* gp) const { |
| 82 | target->recordDraw(gp, fMesh, 1, fPrimitiveType); |
Chris Dalton | 07cdcfc9 | 2019-02-26 11:13:22 -0700 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | void GrMeshDrawOp::PatternHelper::recordDraw( |
Robert Phillips | 6c59fe4 | 2020-02-27 09:30:37 -0500 | [diff] [blame] | 86 | Target* target, |
| 87 | const GrGeometryProcessor* gp, |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 88 | const GrPipeline::FixedDynamicState* fixedDynamicState) const { |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 89 | target->recordDraw(gp, fMesh, 1, fixedDynamicState, nullptr, fPrimitiveType); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | ////////////////////////////////////////////////////////////////////////////// |
| 93 | |
| 94 | GrMeshDrawOp::QuadHelper::QuadHelper(Target* target, size_t vertexStride, int quadsToDraw) { |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 95 | sk_sp<const GrGpuBuffer> indexBuffer = target->resourceProvider()->refNonAAQuadIndexBuffer(); |
| 96 | if (!indexBuffer) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 97 | SkDebugf("Could not get quad index buffer."); |
| 98 | return; |
| 99 | } |
Robert Phillips | ee08d52 | 2019-10-28 16:34:44 -0400 | [diff] [blame] | 100 | this->init(target, GrPrimitiveType::kTriangles, vertexStride, std::move(indexBuffer), |
| 101 | GrResourceProvider::NumVertsPerNonAAQuad(), |
| 102 | GrResourceProvider::NumIndicesPerNonAAQuad(), quadsToDraw, |
| 103 | GrResourceProvider::MaxNumNonAAQuads()); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | ////////////////////////////////////////////////////////////////////////////// |
| 107 | |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 108 | GrPipeline::DynamicStateArrays* GrMeshDrawOp::Target::AllocDynamicStateArrays( |
| 109 | SkArenaAlloc* arena, int numMeshes, int numPrimitiveProcessorTextures, |
| 110 | bool allocScissors) { |
| 111 | |
| 112 | auto result = arena->make<GrPipeline::DynamicStateArrays>(); |
| 113 | |
Chris Dalton | 35a3abe | 2019-02-25 23:11:33 +0000 | [diff] [blame] | 114 | if (allocScissors) { |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 115 | result->fScissorRects = arena->makeArray<SkIRect>(numMeshes); |
Chris Dalton | 35a3abe | 2019-02-25 23:11:33 +0000 | [diff] [blame] | 116 | } |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 117 | |
Chris Dalton | 35a3abe | 2019-02-25 23:11:33 +0000 | [diff] [blame] | 118 | if (numPrimitiveProcessorTextures) { |
Michael Ludwig | fcdd061 | 2019-11-25 08:34:31 -0500 | [diff] [blame] | 119 | result->fPrimitiveProcessorTextures = arena->makeArrayDefault<GrSurfaceProxy*>( |
Chris Dalton | 07cdcfc9 | 2019-02-26 11:13:22 -0700 | [diff] [blame] | 120 | numPrimitiveProcessorTextures * numMeshes); |
Chris Dalton | 35a3abe | 2019-02-25 23:11:33 +0000 | [diff] [blame] | 121 | } |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 122 | |
Chris Dalton | 35a3abe | 2019-02-25 23:11:33 +0000 | [diff] [blame] | 123 | return result; |
| 124 | } |
| 125 | |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 126 | GrPipeline::FixedDynamicState* GrMeshDrawOp::Target::MakeFixedDynamicState( |
| 127 | SkArenaAlloc* arena, const GrAppliedClip* clip, int numPrimProcTextures) { |
| 128 | |
Robert Phillips | ff2f380 | 2019-11-18 16:36:54 -0500 | [diff] [blame] | 129 | bool haveScissor = clip && clip->scissorState().enabled(); |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 130 | |
Robert Phillips | ff2f380 | 2019-11-18 16:36:54 -0500 | [diff] [blame] | 131 | if (haveScissor || numPrimProcTextures) { |
| 132 | auto result = arena->make<GrPipeline::FixedDynamicState>(); |
| 133 | |
| 134 | if (haveScissor) { |
| 135 | result->fScissorRect = clip->scissorState().rect(); |
| 136 | } |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 137 | |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 138 | if (numPrimProcTextures) { |
Michael Ludwig | fcdd061 | 2019-11-25 08:34:31 -0500 | [diff] [blame] | 139 | result->fPrimitiveProcessorTextures = arena->makeArrayDefault<GrSurfaceProxy*>( |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 140 | numPrimProcTextures); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 141 | } |
Robert Phillips | 61fc799 | 2019-10-22 11:58:17 -0400 | [diff] [blame] | 142 | return result; |
Brian Salomon | f513682 | 2018-08-03 09:09:36 -0400 | [diff] [blame] | 143 | } |
Chris Dalton | 07cdcfc9 | 2019-02-26 11:13:22 -0700 | [diff] [blame] | 144 | return nullptr; |
Brian Salomon | f513682 | 2018-08-03 09:09:36 -0400 | [diff] [blame] | 145 | } |