blob: 439fe1b70fa9779c9d3e5b0325aebe85d8f7156a [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001
reed@google.comac10a2d2010-12-22 21:39:39 +00002/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00003 * Copyright 2010 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
reed@google.comac10a2d2010-12-22 21:39:39 +00007 */
8
epoger@google.comec3ed6a2011-07-28 14:26:00 +00009
reed@google.comac10a2d2010-12-22 21:39:39 +000010#include "GrGpu.h"
bsalomon@google.com558a75b2011-08-08 17:01:14 +000011
bsalomoneb1cb5c2015-05-22 08:01:09 -070012#include "GrCaps.h"
bsalomon@google.com558a75b2011-08-08 17:01:14 +000013#include "GrContext.h"
bsalomon3582d3e2015-02-13 14:20:05 -080014#include "GrGpuResourcePriv.h"
reed@google.comac10a2d2010-12-22 21:39:39 +000015#include "GrIndexBuffer.h"
kkinnunencabe20c2015-06-01 01:37:26 -070016#include "GrPathRendering.h"
bsalomoncb02b382015-08-12 11:14:50 -070017#include "GrPipeline.h"
bsalomon0ea80f42015-02-11 10:49:59 -080018#include "GrResourceCache.h"
egdanielec00d942015-09-14 12:56:10 -070019#include "GrResourceProvider.h"
bsalomon6bc1b5f2015-02-23 09:06:38 -080020#include "GrRenderTargetPriv.h"
egdaniel8dc7c3a2015-04-16 11:22:42 -070021#include "GrStencilAttachment.h"
egdaniel6d901da2015-07-30 12:02:15 -070022#include "GrSurfacePriv.h"
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +000023#include "GrVertexBuffer.h"
bsalomoncb8979d2015-05-05 09:51:38 -070024#include "GrVertices.h"
25
26GrVertices& GrVertices::operator =(const GrVertices& di) {
27 fPrimitiveType = di.fPrimitiveType;
28 fStartVertex = di.fStartVertex;
29 fStartIndex = di.fStartIndex;
30 fVertexCount = di.fVertexCount;
31 fIndexCount = di.fIndexCount;
32
33 fInstanceCount = di.fInstanceCount;
34 fVerticesPerInstance = di.fVerticesPerInstance;
35 fIndicesPerInstance = di.fIndicesPerInstance;
bsalomone64eb572015-05-07 11:35:55 -070036 fMaxInstancesPerDraw = di.fMaxInstancesPerDraw;
bsalomoncb8979d2015-05-05 09:51:38 -070037
38 fVertexBuffer.reset(di.vertexBuffer());
39 fIndexBuffer.reset(di.indexBuffer());
40
41 return *this;
42}
bsalomon@google.com1c13c962011-02-14 16:51:21 +000043
bsalomon@google.comd302f142011-03-03 13:54:13 +000044////////////////////////////////////////////////////////////////////////////////
reed@google.comac10a2d2010-12-22 21:39:39 +000045
bsalomon@google.com6e4e6502013-02-25 20:12:45 +000046GrGpu::GrGpu(GrContext* context)
joshualitt3322fa42014-11-07 08:48:51 -080047 : fResetTimestamp(kExpiredTimestamp+1)
bsalomon@google.com0a208a12013-06-28 18:57:35 +000048 , fResetBits(kAll_GrBackendState)
joshualitt3322fa42014-11-07 08:48:51 -080049 , fContext(context) {
reed@google.comac10a2d2010-12-22 21:39:39 +000050}
51
bsalomoned0bcad2015-05-04 10:36:42 -070052GrGpu::~GrGpu() {}
bsalomon1d89ddc2014-08-19 14:20:58 -070053
robertphillipse3371302014-09-17 06:01:06 -070054void GrGpu::contextAbandoned() {}
reed@google.comac10a2d2010-12-22 21:39:39 +000055
bsalomon@google.comd302f142011-03-03 13:54:13 +000056////////////////////////////////////////////////////////////////////////////////
reed@google.comac10a2d2010-12-22 21:39:39 +000057
bsalomon045802d2015-10-20 07:58:01 -070058bool GrGpu::makeCopyForTextureParams(int width, int height, const GrTextureParams& textureParams,
bsalomon89fe56b2015-10-29 10:49:28 -070059 GrTextureProducer::CopyParams* copyParams) const {
bsalomon045802d2015-10-20 07:58:01 -070060 const GrCaps& caps = *this->caps();
61 if (textureParams.isTiled() && !caps.npotTextureTileSupport() &&
62 (!SkIsPow2(width) || !SkIsPow2(height))) {
bsalomon100b8f82015-10-28 08:37:44 -070063 copyParams->fWidth = GrNextPow2(width);
64 copyParams->fHeight = GrNextPow2(height);
bsalomon045802d2015-10-20 07:58:01 -070065 switch (textureParams.filterMode()) {
66 case GrTextureParams::kNone_FilterMode:
67 copyParams->fFilter = GrTextureParams::kNone_FilterMode;
68 break;
69 case GrTextureParams::kBilerp_FilterMode:
70 case GrTextureParams::kMipMap_FilterMode:
71 // We are only ever scaling up so no reason to ever indicate kMipMap.
72 copyParams->fFilter = GrTextureParams::kBilerp_FilterMode;
73 break;
74 }
bsalomon100b8f82015-10-28 08:37:44 -070075 return true;
bsalomon045802d2015-10-20 07:58:01 -070076 }
bsalomon100b8f82015-10-28 08:37:44 -070077 return false;
bsalomon045802d2015-10-20 07:58:01 -070078}
79
egdanielcf614fd2015-04-22 13:58:58 -070080static GrSurfaceOrigin resolve_origin(GrSurfaceOrigin origin, bool renderTarget) {
egdanielb0e1be22015-04-22 13:27:39 -070081 // By default, GrRenderTargets are GL's normal orientation so that they
82 // can be drawn to by the outside world without the client having
83 // to render upside down.
84 if (kDefault_GrSurfaceOrigin == origin) {
85 return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
86 } else {
87 return origin;
88 }
89}
90
egdanielb0e1be22015-04-22 13:27:39 -070091GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, bool budgeted,
bsalomon@google.coma7f84e12011-03-10 14:13:19 +000092 const void* srcData, size_t rowBytes) {
egdanielb0e1be22015-04-22 13:27:39 -070093 GrSurfaceDesc desc = origDesc;
94
krajcevski9c0e6292014-06-02 07:38:14 -070095 if (!this->caps()->isConfigTexturable(desc.fConfig)) {
halcanary96fcdcc2015-08-27 07:41:13 -070096 return nullptr;
robertphillips@google.comd3eb3362012-10-31 13:56:35 +000097 }
krajcevski9c0e6292014-06-02 07:38:14 -070098
bsalomondb558dd2015-01-23 13:19:00 -080099 bool isRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
100 if (isRT && !this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700101 return nullptr;
commit-bot@chromium.org6b7938f2013-10-15 14:18:16 +0000102 }
robertphillips@google.comd3eb3362012-10-31 13:56:35 +0000103
robertphillips6e83ac72015-08-13 05:19:14 -0700104 // We currently do not support multisampled textures
egdaniel8c9b6f12015-05-12 13:36:30 -0700105 if (!isRT && desc.fSampleCnt > 0) {
halcanary96fcdcc2015-08-27 07:41:13 -0700106 return nullptr;
egdaniel8c9b6f12015-05-12 13:36:30 -0700107 }
108
halcanary96fcdcc2015-08-27 07:41:13 -0700109 GrTexture *tex = nullptr;
egdanielb0e1be22015-04-22 13:27:39 -0700110
111 if (isRT) {
112 int maxRTSize = this->caps()->maxRenderTargetSize();
113 if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {
halcanary96fcdcc2015-08-27 07:41:13 -0700114 return nullptr;
egdanielb0e1be22015-04-22 13:27:39 -0700115 }
116 } else {
117 int maxSize = this->caps()->maxTextureSize();
118 if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
halcanary96fcdcc2015-08-27 07:41:13 -0700119 return nullptr;
egdanielb0e1be22015-04-22 13:27:39 -0700120 }
121 }
122
123 GrGpuResource::LifeCycle lifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
124 GrGpuResource::kUncached_LifeCycle;
125
126 desc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
127 // Attempt to catch un- or wrongly initialized sample counts;
128 SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
129
130 desc.fOrigin = resolve_origin(desc.fOrigin, isRT);
131
krajcevski9c0e6292014-06-02 07:38:14 -0700132 if (GrPixelConfigIsCompressed(desc.fConfig)) {
133 // We shouldn't be rendering into this
egdanielb0e1be22015-04-22 13:27:39 -0700134 SkASSERT(!isRT);
135 SkASSERT(0 == desc.fSampleCnt);
krajcevski9c0e6292014-06-02 07:38:14 -0700136
137 if (!this->caps()->npotTextureTileSupport() &&
tfarinaf9dae782014-06-06 06:35:28 -0700138 (!SkIsPow2(desc.fWidth) || !SkIsPow2(desc.fHeight))) {
halcanary96fcdcc2015-08-27 07:41:13 -0700139 return nullptr;
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000140 }
tfarinaf9dae782014-06-06 06:35:28 -0700141
krajcevski9c0e6292014-06-02 07:38:14 -0700142 this->handleDirtyContext();
egdanielb0e1be22015-04-22 13:27:39 -0700143 tex = this->onCreateCompressedTexture(desc, lifeCycle, srcData);
krajcevski9c0e6292014-06-02 07:38:14 -0700144 } else {
145 this->handleDirtyContext();
egdanielb0e1be22015-04-22 13:27:39 -0700146 tex = this->onCreateTexture(desc, lifeCycle, srcData, rowBytes);
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000147 }
bsalomondb558dd2015-01-23 13:19:00 -0800148 if (!this->caps()->reuseScratchTextures() && !isRT) {
bsalomon3582d3e2015-02-13 14:20:05 -0800149 tex->resourcePriv().removeScratchKey();
bsalomondb558dd2015-01-23 13:19:00 -0800150 }
bsalomonb12ea412015-02-02 21:19:50 -0800151 if (tex) {
152 fStats.incTextureCreates();
153 if (srcData) {
154 fStats.incTextureUploads();
155 }
156 }
bsalomon@google.com81c3f8d2011-08-03 15:18:33 +0000157 return tex;
158}
159
bsalomon6dc6f5f2015-06-18 09:12:16 -0700160GrTexture* GrGpu::wrapBackendTexture(const GrBackendTextureDesc& desc, GrWrapOwnership ownership) {
bsalomon@google.come269f212011-11-07 13:29:52 +0000161 this->handleDirtyContext();
bsalomon6dc6f5f2015-06-18 09:12:16 -0700162 GrTexture* tex = this->onWrapBackendTexture(desc, ownership);
halcanary96fcdcc2015-08-27 07:41:13 -0700163 if (nullptr == tex) {
164 return nullptr;
bsalomon@google.coma14dd6d2012-01-03 21:08:12 +0000165 }
bsalomon@google.come269f212011-11-07 13:29:52 +0000166 // TODO: defer this and attach dynamically
167 GrRenderTarget* tgt = tex->asRenderTarget();
egdanielec00d942015-09-14 12:56:10 -0700168 if (tgt && !fContext->resourceProvider()->attachStencilAttachment(tgt)) {
bsalomon@google.come269f212011-11-07 13:29:52 +0000169 tex->unref();
halcanary96fcdcc2015-08-27 07:41:13 -0700170 return nullptr;
bsalomon@google.come269f212011-11-07 13:29:52 +0000171 } else {
172 return tex;
173 }
174}
175
bsalomon6dc6f5f2015-06-18 09:12:16 -0700176GrRenderTarget* GrGpu::wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc,
177 GrWrapOwnership ownership) {
bsalomon@google.come269f212011-11-07 13:29:52 +0000178 this->handleDirtyContext();
bsalomon6dc6f5f2015-06-18 09:12:16 -0700179 return this->onWrapBackendRenderTarget(desc, ownership);
bsalomon@google.come269f212011-11-07 13:29:52 +0000180}
181
robertphillips@google.comadacc702013-10-14 21:53:24 +0000182GrVertexBuffer* GrGpu::createVertexBuffer(size_t size, bool dynamic) {
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000183 this->handleDirtyContext();
robertphillips1b8e1b52015-06-24 06:54:10 -0700184 GrVertexBuffer* vb = this->onCreateVertexBuffer(size, dynamic);
185 if (!this->caps()->reuseScratchBuffers()) {
186 vb->resourcePriv().removeScratchKey();
187 }
188 return vb;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000189}
190
robertphillips@google.comadacc702013-10-14 21:53:24 +0000191GrIndexBuffer* GrGpu::createIndexBuffer(size_t size, bool dynamic) {
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000192 this->handleDirtyContext();
robertphillips1b8e1b52015-06-24 06:54:10 -0700193 GrIndexBuffer* ib = this->onCreateIndexBuffer(size, dynamic);
194 if (!this->caps()->reuseScratchBuffers()) {
195 ib->resourcePriv().removeScratchKey();
196 }
197 return ib;
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000198}
199
egdaniel51c8d402015-08-06 10:54:13 -0700200void GrGpu::clear(const SkIRect& rect,
joshualitt3322fa42014-11-07 08:48:51 -0800201 GrColor color,
joshualitt3322fa42014-11-07 08:48:51 -0800202 GrRenderTarget* renderTarget) {
bsalomon89c62982014-11-03 12:08:42 -0800203 SkASSERT(renderTarget);
egdaniel51c8d402015-08-06 10:54:13 -0700204 SkASSERT(SkIRect::MakeWH(renderTarget->width(), renderTarget->height()).contains(rect));
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000205 this->handleDirtyContext();
egdaniel51c8d402015-08-06 10:54:13 -0700206 this->onClear(renderTarget, rect, color);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000207}
208
joshualitt6db519c2014-10-29 08:48:18 -0700209void GrGpu::clearStencilClip(const SkIRect& rect,
210 bool insideClip,
211 GrRenderTarget* renderTarget) {
joshualittd53a8272014-11-10 16:03:14 -0800212 SkASSERT(renderTarget);
joshualitt6db519c2014-10-29 08:48:18 -0700213 this->handleDirtyContext();
214 this->onClearStencilClip(renderTarget, rect, insideClip);
215}
216
joshualitt1cbdcde2015-08-21 11:53:29 -0700217bool GrGpu::copySurface(GrSurface* dst,
218 GrSurface* src,
219 const SkIRect& srcRect,
220 const SkIPoint& dstPoint) {
221 SkASSERT(dst && src);
222 this->handleDirtyContext();
223 return this->onCopySurface(dst, src, srcRect, dstPoint);
224}
225
bsalomonf0674512015-07-28 13:26:15 -0700226bool GrGpu::getReadPixelsInfo(GrSurface* srcSurface, int width, int height, size_t rowBytes,
227 GrPixelConfig readConfig, DrawPreference* drawPreference,
228 ReadPixelTempDrawInfo* tempDrawInfo) {
229 SkASSERT(drawPreference);
230 SkASSERT(tempDrawInfo);
231 SkASSERT(kGpuPrefersDraw_DrawPreference != *drawPreference);
232
egdaniel6d901da2015-07-30 12:02:15 -0700233 // We currently do not support reading into a compressed buffer
234 if (GrPixelConfigIsCompressed(readConfig)) {
235 return false;
236 }
237
bsalomonf0674512015-07-28 13:26:15 -0700238 if (!this->onGetReadPixelsInfo(srcSurface, width, height, rowBytes, readConfig, drawPreference,
239 tempDrawInfo)) {
240 return false;
241 }
242
243 // Check to see if we're going to request that the caller draw when drawing is not possible.
244 if (!srcSurface->asTexture() ||
245 !this->caps()->isConfigRenderable(tempDrawInfo->fTempSurfaceDesc.fConfig, false)) {
246 // If we don't have a fallback to a straight read then fail.
247 if (kRequireDraw_DrawPreference == *drawPreference) {
248 return false;
249 }
250 *drawPreference = kNoDraw_DrawPreference;
251 }
252
253 return true;
254}
255bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height, size_t rowBytes,
256 GrPixelConfig srcConfig, DrawPreference* drawPreference,
257 WritePixelTempDrawInfo* tempDrawInfo) {
258 SkASSERT(drawPreference);
259 SkASSERT(tempDrawInfo);
260 SkASSERT(kGpuPrefersDraw_DrawPreference != *drawPreference);
261
jvanverth2dc29942015-09-01 07:16:46 -0700262 if (GrPixelConfigIsCompressed(dstSurface->desc().fConfig) &&
263 dstSurface->desc().fConfig != srcConfig) {
264 return false;
265 }
266
bsalomonf0674512015-07-28 13:26:15 -0700267 if (this->caps()->useDrawInsteadOfPartialRenderTargetWrite() &&
268 SkToBool(dstSurface->asRenderTarget()) &&
269 (width < dstSurface->width() || height < dstSurface->height())) {
270 ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference);
271 }
272
273 if (!this->onGetWritePixelsInfo(dstSurface, width, height, rowBytes, srcConfig, drawPreference,
274 tempDrawInfo)) {
275 return false;
276 }
277
278 // Check to see if we're going to request that the caller draw when drawing is not possible.
279 if (!dstSurface->asRenderTarget() ||
280 !this->caps()->isConfigTexturable(tempDrawInfo->fTempSurfaceDesc.fConfig)) {
281 // If we don't have a fallback to a straight upload then fail.
282 if (kRequireDraw_DrawPreference == *drawPreference ||
283 !this->caps()->isConfigTexturable(srcConfig)) {
284 return false;
285 }
286 *drawPreference = kNoDraw_DrawPreference;
287 }
288 return true;
289}
290
bsalomon6cb3cbe2015-07-30 07:34:27 -0700291bool GrGpu::readPixels(GrSurface* surface,
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000292 int left, int top, int width, int height,
bsalomon@google.comc6980972011-11-02 19:57:21 +0000293 GrPixelConfig config, void* buffer,
senorblanco@chromium.org3cb406b2013-02-05 19:50:46 +0000294 size_t rowBytes) {
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000295 this->handleDirtyContext();
egdaniel6d901da2015-07-30 12:02:15 -0700296
297 // We cannot read pixels into a compressed buffer
298 if (GrPixelConfigIsCompressed(config)) {
299 return false;
300 }
301
302 size_t bpp = GrBytesPerPixel(config);
303 if (!GrSurfacePriv::AdjustReadPixelParams(surface->width(), surface->height(), bpp,
304 &left, &top, &width, &height,
305 &buffer,
306 &rowBytes)) {
307 return false;
308 }
309
310 return this->onReadPixels(surface,
311 left, top, width, height,
312 config, buffer,
313 rowBytes);
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000314}
315
bsalomon6cb3cbe2015-07-30 07:34:27 -0700316bool GrGpu::writePixels(GrSurface* surface,
317 int left, int top, int width, int height,
318 GrPixelConfig config, const void* buffer,
319 size_t rowBytes) {
jvanverth2dc29942015-09-01 07:16:46 -0700320 if (!buffer) {
321 return false;
322 }
323
bsalomon@google.com6f379512011-11-16 20:36:03 +0000324 this->handleDirtyContext();
bsalomon6cb3cbe2015-07-30 07:34:27 -0700325 if (this->onWritePixels(surface, left, top, width, height, config, buffer, rowBytes)) {
bsalomonb12ea412015-02-02 21:19:50 -0800326 fStats.incTextureUploads();
327 return true;
328 }
329 return false;
bsalomon@google.com6f379512011-11-16 20:36:03 +0000330}
331
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000332void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000333 SkASSERT(target);
bsalomon@google.com75f9f252012-01-31 13:35:56 +0000334 this->handleDirtyContext();
335 this->onResolveRenderTarget(target);
336}
337
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000338////////////////////////////////////////////////////////////////////////////////
339
bsalomoncb8979d2015-05-05 09:51:38 -0700340void GrGpu::draw(const DrawArgs& args, const GrVertices& vertices) {
bsalomon@google.coma7f84e12011-03-10 14:13:19 +0000341 this->handleDirtyContext();
bsalomoncb02b382015-08-12 11:14:50 -0700342 if (GrXferBarrierType barrierType = args.fPipeline->xferBarrierType(*this->caps())) {
343 this->xferBarrier(args.fPipeline->getRenderTarget(), barrierType);
344 }
345
bsalomone64eb572015-05-07 11:35:55 -0700346 GrVertices::Iterator iter;
347 const GrNonInstancedVertices* verts = iter.init(vertices);
348 do {
349 this->onDraw(args, *verts);
joshualitt336cda32015-09-09 08:29:47 -0700350 fStats.incNumDraws();
bsalomone64eb572015-05-07 11:35:55 -0700351 } while ((verts = iter.next()));
bsalomon@google.com1c13c962011-02-14 16:51:21 +0000352}