[go: nahoru, domu]
Google Git
Sign in
android / platform / external / chromium_org / third_party / skia / src / a97ef5e8a2b07b735120d041de8e4612dfe59185 / . / gpu / GrDrawTarget.cpp
blob: 5512f174d7c7cd144d17a3b1500bc9f3299e9186 [file] [log] [blame]
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]1
2/*
3 * 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.
7 */
8
9
10
11#include "GrDrawTarget.h"
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]12#include "GrContext.h"
bsalomon@google.com516b4c32013-03-25 18:19:00 +0000[diff] [blame]13#include "GrDrawTargetCaps.h"
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]14#include "GrPath.h"
bsalomon@google.comc08edff2011-12-09 15:55:34 +0000[diff] [blame]15#include "GrRenderTarget.h"
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]16#include "GrTexture.h"
17#include "GrVertexBuffer.h"
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]18
sugoi@google.com5c2ee5c2012-12-17 21:16:45 +0000[diff] [blame]19#include "SkStrokeRec.h"
sugoi@google.com290bf0a2012-12-06 20:13:11 +0000[diff] [blame]20
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]21////////////////////////////////////////////////////////////////////////////////
22
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]23GrDrawTarget::DrawInfo& GrDrawTarget::DrawInfo::operator =(const DrawInfo& di) {
24 fPrimitiveType = di.fPrimitiveType;
25 fStartVertex = di.fStartVertex;
26 fStartIndex = di.fStartIndex;
27 fVertexCount = di.fVertexCount;
28 fIndexCount = di.fIndexCount;
29
30 fInstanceCount = di.fInstanceCount;
31 fVerticesPerInstance = di.fVerticesPerInstance;
32 fIndicesPerInstance = di.fIndicesPerInstance;
33
34 if (NULL != di.fDevBounds) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]35 SkASSERT(di.fDevBounds == &di.fDevBoundsStorage);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]36 fDevBoundsStorage = di.fDevBoundsStorage;
37 fDevBounds = &fDevBoundsStorage;
38 } else {
39 fDevBounds = NULL;
40 }
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]41
42 fDstCopy = di.fDstCopy;
43
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]44 return *this;
45}
46
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]47#ifdef SK_DEBUG
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]48bool GrDrawTarget::DrawInfo::isInstanced() const {
49 if (fInstanceCount > 0) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]50 SkASSERT(0 == fIndexCount % fIndicesPerInstance);
51 SkASSERT(0 == fVertexCount % fVerticesPerInstance);
52 SkASSERT(fIndexCount / fIndicesPerInstance == fInstanceCount);
53 SkASSERT(fVertexCount / fVerticesPerInstance == fInstanceCount);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]54 // there is no way to specify a non-zero start index to drawIndexedInstances().
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]55 SkASSERT(0 == fStartIndex);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]56 return true;
57 } else {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]58 SkASSERT(!fVerticesPerInstance);
59 SkASSERT(!fIndicesPerInstance);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]60 return false;
61 }
62}
63#endif
64
65void GrDrawTarget::DrawInfo::adjustInstanceCount(int instanceOffset) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]66 SkASSERT(this->isInstanced());
67 SkASSERT(instanceOffset + fInstanceCount >= 0);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]68 fInstanceCount += instanceOffset;
69 fVertexCount = fVerticesPerInstance * fInstanceCount;
70 fIndexCount = fIndicesPerInstance * fInstanceCount;
71}
72
73void GrDrawTarget::DrawInfo::adjustStartVertex(int vertexOffset) {
74 fStartVertex += vertexOffset;
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]75 SkASSERT(fStartVertex >= 0);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]76}
77
78void GrDrawTarget::DrawInfo::adjustStartIndex(int indexOffset) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]79 SkASSERT(this->isIndexed());
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]80 fStartIndex += indexOffset;
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]81 SkASSERT(fStartIndex >= 0);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]82}
83
84////////////////////////////////////////////////////////////////////////////////
85
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]86#define DEBUG_INVAL_BUFFER 0xdeadcafe
87#define DEBUG_INVAL_START_IDX -1
88
bsalomon@google.com0ad5bd92013-02-25 20:12:45 +0000[diff] [blame]89GrDrawTarget::GrDrawTarget(GrContext* context)
90 : fClip(NULL)
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]91 , fContext(context)
commit-bot@chromium.orgd604c902014-03-25 15:17:32 +0000[diff] [blame]92 , fGpuTraceMarkerCount(0) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]93 SkASSERT(NULL != context);
bsalomon@google.com0ad5bd92013-02-25 20:12:45 +0000[diff] [blame]94
bsalomon@google.com3a0ffe42012-03-27 15:59:58 +0000[diff] [blame]95 fDrawState = &fDefaultDrawState;
96 // We assume that fDrawState always owns a ref to the object it points at.
97 fDefaultDrawState.ref();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]98 GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]99#ifdef SK_DEBUG
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]100 geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
101 geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
102 geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
103 geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
104#endif
105 geoSrc.fVertexSrc = kNone_GeometrySrcType;
106 geoSrc.fIndexSrc = kNone_GeometrySrcType;
107}
108
109GrDrawTarget::~GrDrawTarget() {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]110 SkASSERT(1 == fGeoSrcStateStack.count());
humper@google.comafcc1612013-01-07 19:54:40 +0000[diff] [blame]111 SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back());
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]112 SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc);
113 SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc);
bsalomon@google.com3a0ffe42012-03-27 15:59:58 +0000[diff] [blame]114 fDrawState->unref();
bsalomon@google.com5bc70a72011-10-28 19:50:21 +0000[diff] [blame]115}
116
117void GrDrawTarget::releaseGeometry() {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]118 int popCnt = fGeoSrcStateStack.count() - 1;
119 while (popCnt) {
120 this->popGeometrySource();
121 --popCnt;
122 }
bsalomon@google.com5bc70a72011-10-28 19:50:21 +0000[diff] [blame]123 this->resetVertexSource();
124 this->resetIndexSource();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]125}
126
robertphillips@google.com8ec5ae62012-07-26 18:52:16 +0000[diff] [blame]127void GrDrawTarget::setClip(const GrClipData* clip) {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]128 clipWillBeSet(clip);
129 fClip = clip;
130}
131
robertphillips@google.com8ec5ae62012-07-26 18:52:16 +0000[diff] [blame]132const GrClipData* GrDrawTarget::getClip() const {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]133 return fClip;
134}
135
bsalomon@google.com3a0ffe42012-03-27 15:59:58 +0000[diff] [blame]136void GrDrawTarget::setDrawState(GrDrawState* drawState) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]137 SkASSERT(NULL != fDrawState);
bsalomon@google.com3a0ffe42012-03-27 15:59:58 +0000[diff] [blame]138 if (NULL == drawState) {
139 drawState = &fDefaultDrawState;
140 }
141 if (fDrawState != drawState) {
142 fDrawState->unref();
143 drawState->ref();
144 fDrawState = drawState;
145 }
146}
147
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]148bool GrDrawTarget::reserveVertexSpace(size_t vertexSize,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]149 int vertexCount,
150 void** vertices) {
151 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
152 bool acquired = false;
153 if (vertexCount > 0) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]154 SkASSERT(NULL != vertices);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]155 this->releasePreviousVertexSource();
156 geoSrc.fVertexSrc = kNone_GeometrySrcType;
157
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]158 acquired = this->onReserveVertexSpace(vertexSize,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]159 vertexCount,
160 vertices);
161 }
162 if (acquired) {
163 geoSrc.fVertexSrc = kReserved_GeometrySrcType;
164 geoSrc.fVertexCount = vertexCount;
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]165 geoSrc.fVertexSize = vertexSize;
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]166 } else if (NULL != vertices) {
167 *vertices = NULL;
168 }
169 return acquired;
170}
171
172bool GrDrawTarget::reserveIndexSpace(int indexCount,
173 void** indices) {
174 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
175 bool acquired = false;
176 if (indexCount > 0) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]177 SkASSERT(NULL != indices);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]178 this->releasePreviousIndexSource();
179 geoSrc.fIndexSrc = kNone_GeometrySrcType;
rmistry@google.comdfb3e3c2012-08-23 18:14:13 +0000[diff] [blame]180
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]181 acquired = this->onReserveIndexSpace(indexCount, indices);
182 }
183 if (acquired) {
184 geoSrc.fIndexSrc = kReserved_GeometrySrcType;
185 geoSrc.fIndexCount = indexCount;
186 } else if (NULL != indices) {
187 *indices = NULL;
188 }
189 return acquired;
rmistry@google.comdfb3e3c2012-08-23 18:14:13 +0000[diff] [blame]190
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]191}
192
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]193bool GrDrawTarget::reserveVertexAndIndexSpace(int vertexCount,
bsalomon@google.comc17542b2012-03-13 12:40:53 +0000[diff] [blame]194 int indexCount,
195 void** vertices,
196 void** indices) {
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]197 size_t vertexSize = this->drawState()->getVertexSize();
198 this->willReserveVertexAndIndexSpace(vertexCount, indexCount);
bsalomon@google.comc17542b2012-03-13 12:40:53 +0000[diff] [blame]199 if (vertexCount) {
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]200 if (!this->reserveVertexSpace(vertexSize, vertexCount, vertices)) {
bsalomon@google.comc17542b2012-03-13 12:40:53 +0000[diff] [blame]201 if (indexCount) {
202 this->resetIndexSource();
203 }
204 return false;
205 }
206 }
207 if (indexCount) {
208 if (!this->reserveIndexSpace(indexCount, indices)) {
209 if (vertexCount) {
210 this->resetVertexSource();
211 }
212 return false;
213 }
214 }
215 return true;
216}
217
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]218bool GrDrawTarget::geometryHints(int32_t* vertexCount,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]219 int32_t* indexCount) const {
220 if (NULL != vertexCount) {
221 *vertexCount = -1;
222 }
223 if (NULL != indexCount) {
224 *indexCount = -1;
225 }
226 return false;
227}
228
229void GrDrawTarget::releasePreviousVertexSource() {
230 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
231 switch (geoSrc.fVertexSrc) {
232 case kNone_GeometrySrcType:
233 break;
234 case kArray_GeometrySrcType:
235 this->releaseVertexArray();
236 break;
237 case kReserved_GeometrySrcType:
238 this->releaseReservedVertexSpace();
239 break;
240 case kBuffer_GeometrySrcType:
241 geoSrc.fVertexBuffer->unref();
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]242#ifdef SK_DEBUG
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]243 geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
244#endif
245 break;
246 default:
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]247 SkFAIL("Unknown Vertex Source Type.");
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]248 break;
249 }
250}
251
252void GrDrawTarget::releasePreviousIndexSource() {
253 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
254 switch (geoSrc.fIndexSrc) {
255 case kNone_GeometrySrcType: // these two don't require
256 break;
257 case kArray_GeometrySrcType:
258 this->releaseIndexArray();
259 break;
260 case kReserved_GeometrySrcType:
261 this->releaseReservedIndexSpace();
262 break;
263 case kBuffer_GeometrySrcType:
264 geoSrc.fIndexBuffer->unref();
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]265#ifdef SK_DEBUG
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]266 geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
267#endif
268 break;
269 default:
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]270 SkFAIL("Unknown Index Source Type.");
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]271 break;
272 }
273}
274
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]275void GrDrawTarget::setVertexSourceToArray(const void* vertexArray,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]276 int vertexCount) {
277 this->releasePreviousVertexSource();
278 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
279 geoSrc.fVertexSrc = kArray_GeometrySrcType;
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]280 geoSrc.fVertexSize = this->drawState()->getVertexSize();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]281 geoSrc.fVertexCount = vertexCount;
282 this->onSetVertexSourceToArray(vertexArray, vertexCount);
283}
284
285void GrDrawTarget::setIndexSourceToArray(const void* indexArray,
286 int indexCount) {
287 this->releasePreviousIndexSource();
288 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
289 geoSrc.fIndexSrc = kArray_GeometrySrcType;
290 geoSrc.fIndexCount = indexCount;
291 this->onSetIndexSourceToArray(indexArray, indexCount);
292}
293
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]294void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer) {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]295 this->releasePreviousVertexSource();
296 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
297 geoSrc.fVertexSrc = kBuffer_GeometrySrcType;
298 geoSrc.fVertexBuffer = buffer;
299 buffer->ref();
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]300 geoSrc.fVertexSize = this->drawState()->getVertexSize();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]301}
302
303void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
304 this->releasePreviousIndexSource();
305 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
306 geoSrc.fIndexSrc = kBuffer_GeometrySrcType;
307 geoSrc.fIndexBuffer = buffer;
308 buffer->ref();
309}
310
311void GrDrawTarget::resetVertexSource() {
312 this->releasePreviousVertexSource();
313 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
314 geoSrc.fVertexSrc = kNone_GeometrySrcType;
315}
316
317void GrDrawTarget::resetIndexSource() {
318 this->releasePreviousIndexSource();
319 GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
320 geoSrc.fIndexSrc = kNone_GeometrySrcType;
321}
322
323void GrDrawTarget::pushGeometrySource() {
324 this->geometrySourceWillPush();
325 GeometrySrcState& newState = fGeoSrcStateStack.push_back();
326 newState.fIndexSrc = kNone_GeometrySrcType;
327 newState.fVertexSrc = kNone_GeometrySrcType;
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]328#ifdef SK_DEBUG
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]329 newState.fVertexCount = ~0;
330 newState.fVertexBuffer = (GrVertexBuffer*)~0;
331 newState.fIndexCount = ~0;
332 newState.fIndexBuffer = (GrIndexBuffer*)~0;
333#endif
334}
335
336void GrDrawTarget::popGeometrySource() {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]337 // if popping last element then pops are unbalanced with pushes
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]338 SkASSERT(fGeoSrcStateStack.count() > 1);
rmistry@google.comdfb3e3c2012-08-23 18:14:13 +0000[diff] [blame]339
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]340 this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
341 this->releasePreviousVertexSource();
342 this->releasePreviousIndexSource();
343 fGeoSrcStateStack.pop_back();
344}
345
346////////////////////////////////////////////////////////////////////////////////
347
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]348bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex,
349 int startIndex, int vertexCount,
350 int indexCount) const {
bsalomon@google.com73d295e2012-07-30 13:09:05 +0000[diff] [blame]351 const GrDrawState& drawState = this->getDrawState();
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]352#ifdef SK_DEBUG
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]353 const GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]354 int maxVertex = startVertex + vertexCount;
355 int maxValidVertex;
356 switch (geoSrc.fVertexSrc) {
357 case kNone_GeometrySrcType:
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]358 SkFAIL("Attempting to draw without vertex src.");
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]359 case kReserved_GeometrySrcType: // fallthrough
360 case kArray_GeometrySrcType:
361 maxValidVertex = geoSrc.fVertexCount;
362 break;
363 case kBuffer_GeometrySrcType:
robertphillips@google.com6138c2d2013-10-14 21:53:24 +0000[diff] [blame]364 maxValidVertex = static_cast<int>(geoSrc.fVertexBuffer->sizeInBytes() / geoSrc.fVertexSize);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]365 break;
366 }
367 if (maxVertex > maxValidVertex) {
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]368 SkFAIL("Drawing outside valid vertex range.");
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]369 }
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]370 if (indexCount > 0) {
371 int maxIndex = startIndex + indexCount;
372 int maxValidIndex;
373 switch (geoSrc.fIndexSrc) {
374 case kNone_GeometrySrcType:
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]375 SkFAIL("Attempting to draw indexed geom without index src.");
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]376 case kReserved_GeometrySrcType: // fallthrough
377 case kArray_GeometrySrcType:
378 maxValidIndex = geoSrc.fIndexCount;
379 break;
380 case kBuffer_GeometrySrcType:
robertphillips@google.com6138c2d2013-10-14 21:53:24 +0000[diff] [blame]381 maxValidIndex = static_cast<int>(geoSrc.fIndexBuffer->sizeInBytes() / sizeof(uint16_t));
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]382 break;
383 }
384 if (maxIndex > maxValidIndex) {
commit-bot@chromium.orge5720c92014-04-30 14:17:00 +0000[diff] [blame]385 SkFAIL("Index reads outside valid index range.");
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]386 }
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]387 }
bsalomon@google.com7c0a72b2012-03-30 17:24:17 +0000[diff] [blame]388
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]389 SkASSERT(NULL != drawState.getRenderTarget());
bsalomon@google.com860912a2013-06-13 19:34:18 +0000[diff] [blame]390
391 for (int s = 0; s < drawState.numColorStages(); ++s) {
392 const GrEffectRef& effect = *drawState.getColorStage(s).getEffect();
393 int numTextures = effect->numTextures();
394 for (int t = 0; t < numTextures; ++t) {
395 GrTexture* texture = effect->texture(t);
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]396 SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
bsalomon@google.com860912a2013-06-13 19:34:18 +0000[diff] [blame]397 }
398 }
399 for (int s = 0; s < drawState.numCoverageStages(); ++s) {
400 const GrEffectRef& effect = *drawState.getCoverageStage(s).getEffect();
401 int numTextures = effect->numTextures();
402 for (int t = 0; t < numTextures; ++t) {
403 GrTexture* texture = effect->texture(t);
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]404 SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
bsalomon@google.com7c0a72b2012-03-30 17:24:17 +0000[diff] [blame]405 }
406 }
commit-bot@chromium.orgf7c3ed02013-03-12 12:26:08 +0000[diff] [blame]407
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]408 SkASSERT(drawState.validateVertexAttribs());
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]409#endif
bsalomon@google.comc08edff2011-12-09 15:55:34 +0000[diff] [blame]410 if (NULL == drawState.getRenderTarget()) {
bsalomon@google.com198bfc02011-11-10 22:16:06 +0000[diff] [blame]411 return false;
412 }
bsalomon@google.come5ed67c2011-11-07 02:30:51 +0000[diff] [blame]413 return true;
414}
415
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]416bool GrDrawTarget::setupDstReadIfNecessary(GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds) {
bsalomon@google.com034620a2013-05-13 18:50:25 +0000[diff] [blame]417 if (this->caps()->dstReadInShaderSupport() || !this->getDrawState().willEffectReadDstColor()) {
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]418 return true;
419 }
420 GrRenderTarget* rt = this->drawState()->getRenderTarget();
commit-bot@chromium.orga8cbc572013-07-17 21:39:42 +0000[diff] [blame]421 SkIRect copyRect;
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]422 const GrClipData* clip = this->getClip();
423 clip->getConservativeBounds(rt, &copyRect);
424
425 if (NULL != drawBounds) {
426 SkIRect drawIBounds;
427 drawBounds->roundOut(&drawIBounds);
commit-bot@chromium.org5b77be12013-04-01 12:49:31 +0000[diff] [blame]428 if (!copyRect.intersect(drawIBounds)) {
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]429#ifdef SK_DEBUG
commit-bot@chromium.org5b77be12013-04-01 12:49:31 +0000[diff] [blame]430 GrPrintf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n");
431#endif
432 return false;
433 }
434 } else {
commit-bot@chromium.org0fde04d2013-08-28 14:17:03 +0000[diff] [blame]435#ifdef SK_DEBUG
commit-bot@chromium.org5b77be12013-04-01 12:49:31 +0000[diff] [blame]436 //GrPrintf("No dev bounds when dst copy is made.\n");
437#endif
438 }
skia.committer@gmail.com2c3b0652013-04-02 07:01:34 +0000[diff] [blame]439
commit-bot@chromium.orgd01e6902013-04-11 22:00:22 +0000[diff] [blame]440 // MSAA consideration: When there is support for reading MSAA samples in the shader we could
441 // have per-sample dst values by making the copy multisampled.
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]442 GrTextureDesc desc;
bsalomon@google.comb1bfcd32013-04-15 13:51:00 +0000[diff] [blame]443 this->initCopySurfaceDstDesc(rt, &desc);
commit-bot@chromium.org5b77be12013-04-01 12:49:31 +0000[diff] [blame]444 desc.fWidth = copyRect.width();
445 desc.fHeight = copyRect.height();
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]446
447 GrAutoScratchTexture ast(fContext, desc, GrContext::kApprox_ScratchTexMatch);
448
449 if (NULL == ast.texture()) {
450 GrPrintf("Failed to create temporary copy of destination texture.\n");
451 return false;
452 }
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]453 SkIPoint dstPoint = {0, 0};
454 if (this->copySurface(ast.texture(), rt, copyRect, dstPoint)) {
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]455 dstCopy->setTexture(ast.texture());
456 dstCopy->setOffset(copyRect.fLeft, copyRect.fTop);
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]457 return true;
458 } else {
459 return false;
460 }
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]461}
462
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]463void GrDrawTarget::drawIndexed(GrPrimitiveType type,
464 int startVertex,
465 int startIndex,
466 int vertexCount,
467 int indexCount,
468 const SkRect* devBounds) {
bsalomon@google.com52ea95b2013-01-30 16:12:41 +0000[diff] [blame]469 if (indexCount > 0 && this->checkDraw(type, startVertex, startIndex, vertexCount, indexCount)) {
470 DrawInfo info;
471 info.fPrimitiveType = type;
472 info.fStartVertex = startVertex;
473 info.fStartIndex = startIndex;
474 info.fVertexCount = vertexCount;
475 info.fIndexCount = indexCount;
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]476
477 info.fInstanceCount = 0;
478 info.fVerticesPerInstance = 0;
479 info.fIndicesPerInstance = 0;
480
481 if (NULL != devBounds) {
482 info.setDevBounds(*devBounds);
483 }
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]484 // TODO: We should continue with incorrect blending.
485 if (!this->setupDstReadIfNecessary(&info)) {
486 return;
487 }
bsalomon@google.com52ea95b2013-01-30 16:12:41 +0000[diff] [blame]488 this->onDraw(info);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]489 }
490}
491
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]492void GrDrawTarget::drawNonIndexed(GrPrimitiveType type,
493 int startVertex,
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]494 int vertexCount,
495 const SkRect* devBounds) {
bsalomon@google.com52ea95b2013-01-30 16:12:41 +0000[diff] [blame]496 if (vertexCount > 0 && this->checkDraw(type, startVertex, -1, vertexCount, -1)) {
497 DrawInfo info;
498 info.fPrimitiveType = type;
499 info.fStartVertex = startVertex;
500 info.fStartIndex = 0;
501 info.fVertexCount = vertexCount;
502 info.fIndexCount = 0;
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]503
504 info.fInstanceCount = 0;
505 info.fVerticesPerInstance = 0;
506 info.fIndicesPerInstance = 0;
507
508 if (NULL != devBounds) {
509 info.setDevBounds(*devBounds);
510 }
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]511 // TODO: We should continue with incorrect blending.
512 if (!this->setupDstReadIfNecessary(&info)) {
513 return;
514 }
bsalomon@google.com52ea95b2013-01-30 16:12:41 +0000[diff] [blame]515 this->onDraw(info);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]516 }
517}
518
commit-bot@chromium.org59c85092013-10-09 15:14:18 +0000[diff] [blame]519void GrDrawTarget::stencilPath(const GrPath* path, SkPath::FillType fill) {
bsalomon@google.com29a68d02012-06-11 15:36:13 +0000[diff] [blame]520 // TODO: extract portions of checkDraw that are relevant to path stenciling.
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]521 SkASSERT(NULL != path);
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]522 SkASSERT(this->caps()->pathRenderingSupport());
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]523 SkASSERT(!SkPath::IsInverseFillType(fill));
commit-bot@chromium.org59c85092013-10-09 15:14:18 +0000[diff] [blame]524 this->onStencilPath(path, fill);
bsalomon@google.com29a68d02012-06-11 15:36:13 +0000[diff] [blame]525}
526
commit-bot@chromium.org59c85092013-10-09 15:14:18 +0000[diff] [blame]527void GrDrawTarget::drawPath(const GrPath* path, SkPath::FillType fill) {
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]528 // TODO: extract portions of checkDraw that are relevant to path rendering.
529 SkASSERT(NULL != path);
530 SkASSERT(this->caps()->pathRenderingSupport());
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]531 const GrDrawState* drawState = &getDrawState();
532
533 SkRect devBounds;
534 if (SkPath::IsInverseFillType(fill)) {
535 devBounds = SkRect::MakeWH(SkIntToScalar(drawState->getRenderTarget()->width()),
536 SkIntToScalar(drawState->getRenderTarget()->height()));
537 } else {
538 devBounds = path->getBounds();
539 }
540 SkMatrix viewM = drawState->getViewMatrix();
541 viewM.mapRect(&devBounds);
542
543 GrDeviceCoordTexture dstCopy;
544 if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
545 return;
546 }
547
commit-bot@chromium.org59c85092013-10-09 15:14:18 +0000[diff] [blame]548 this->onDrawPath(path, fill, dstCopy.texture() ? &dstCopy : NULL);
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]549}
550
commit-bot@chromium.org1e7fd132014-03-28 21:31:34 +0000[diff] [blame]551void GrDrawTarget::drawPaths(int pathCount, const GrPath** paths,
commit-bot@chromium.org43b23c62014-03-25 11:59:40 +0000[diff] [blame]552 const SkMatrix* transforms,
553 SkPath::FillType fill, SkStrokeRec::Style stroke) {
554 SkASSERT(pathCount > 0);
555 SkASSERT(NULL != paths);
556 SkASSERT(NULL != paths[0]);
557 SkASSERT(this->caps()->pathRenderingSupport());
558 SkASSERT(!SkPath::IsInverseFillType(fill));
559
560 const GrDrawState* drawState = &getDrawState();
561
562 SkRect devBounds;
commit-bot@chromium.org1e7fd132014-03-28 21:31:34 +0000[diff] [blame]563 for (int i = 0; i < pathCount; ++i) {
commit-bot@chromium.org43b23c62014-03-25 11:59:40 +0000[diff] [blame]564 SkRect mappedPathBounds;
565 transforms[i].mapRect(&mappedPathBounds, paths[i]->getBounds());
566 devBounds.join(mappedPathBounds);
567 }
568
569 SkMatrix viewM = drawState->getViewMatrix();
570 viewM.mapRect(&devBounds);
571
572 GrDeviceCoordTexture dstCopy;
573 if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
574 return;
575 }
576
577 this->onDrawPaths(pathCount, paths, transforms, fill, stroke,
578 dstCopy.texture() ? &dstCopy : NULL);
579}
580
commit-bot@chromium.orgd604c902014-03-25 15:17:32 +0000[diff] [blame]581void GrDrawTarget::addGpuTraceMarker(GrGpuTraceMarker* marker) {
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]582 if (this->caps()->gpuTracingSupport()) {
commit-bot@chromium.orgd604c902014-03-25 15:17:32 +0000[diff] [blame]583 SkASSERT(fGpuTraceMarkerCount >= 0);
584 this->fActiveTraceMarkers.add(*marker);
585 this->didAddGpuTraceMarker();
586 ++fGpuTraceMarkerCount;
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]587 }
588}
589
commit-bot@chromium.orgd604c902014-03-25 15:17:32 +0000[diff] [blame]590void GrDrawTarget::removeGpuTraceMarker(GrGpuTraceMarker* marker) {
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]591 if (this->caps()->gpuTracingSupport()) {
commit-bot@chromium.orgd604c902014-03-25 15:17:32 +0000[diff] [blame]592 SkASSERT(fGpuTraceMarkerCount >= 1);
593 this->fActiveTraceMarkers.remove(*marker);
594 this->didRemoveGpuTraceMarker();
595 --fGpuTraceMarkerCount;
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]596 }
597}
598
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]599////////////////////////////////////////////////////////////////////////////////
600
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]601bool GrDrawTarget::willUseHWAALines() const {
bsalomon@google.comf1a7c792013-02-12 16:47:41 +0000[diff] [blame]602 // There is a conflict between using smooth lines and our use of premultiplied alpha. Smooth
603 // lines tweak the incoming alpha value but not in a premul-alpha way. So we only use them when
604 // our alpha is 0xff and tweaking the color for partial coverage is OK
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]605 if (!this->caps()->hwAALineSupport() ||
bsalomon@google.comc08edff2011-12-09 15:55:34 +0000[diff] [blame]606 !this->getDrawState().isHWAntialiasState()) {
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]607 return false;
608 }
bsalomon@google.comf1a7c792013-02-12 16:47:41 +0000[diff] [blame]609 GrDrawState::BlendOptFlags opts = this->getDrawState().getBlendOpts();
610 return (GrDrawState::kDisableBlend_BlendOptFlag & opts) &&
611 (GrDrawState::kCoverageAsAlpha_BlendOptFlag & opts);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]612}
613
614bool GrDrawTarget::canApplyCoverage() const {
615 // we can correctly apply coverage if a) we have dual source blending
616 // or b) one of our blend optimizations applies.
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]617 return this->caps()->dualSourceBlendingSupport() ||
bsalomon@google.comf1a7c792013-02-12 16:47:41 +0000[diff] [blame]618 GrDrawState::kNone_BlendOpt != this->getDrawState().getBlendOpts(true);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]619}
620
bsalomon@google.com3c5b8bc2012-03-20 21:17:58 +0000[diff] [blame]621////////////////////////////////////////////////////////////////////////////////
622
623void GrDrawTarget::drawIndexedInstances(GrPrimitiveType type,
624 int instanceCount,
625 int verticesPerInstance,
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]626 int indicesPerInstance,
627 const SkRect* devBounds) {
bsalomon@google.com3c5b8bc2012-03-20 21:17:58 +0000[diff] [blame]628 if (!verticesPerInstance || !indicesPerInstance) {
629 return;
630 }
631
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]632 int maxInstancesPerDraw = this->indexCountInCurrentSource() / indicesPerInstance;
633 if (!maxInstancesPerDraw) {
bsalomon@google.com3c5b8bc2012-03-20 21:17:58 +0000[diff] [blame]634 return;
635 }
636
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]637 DrawInfo info;
638 info.fPrimitiveType = type;
639 info.fStartIndex = 0;
640 info.fStartVertex = 0;
641 info.fIndicesPerInstance = indicesPerInstance;
642 info.fVerticesPerInstance = verticesPerInstance;
643
644 // Set the same bounds for all the draws.
645 if (NULL != devBounds) {
646 info.setDevBounds(*devBounds);
647 }
bsalomon@google.com03d5ebc2013-03-29 19:22:36 +0000[diff] [blame]648 // TODO: We should continue with incorrect blending.
649 if (!this->setupDstReadIfNecessary(&info)) {
650 return;
651 }
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]652
bsalomon@google.com3c5b8bc2012-03-20 21:17:58 +0000[diff] [blame]653 while (instanceCount) {
commit-bot@chromium.orgc4880f62014-03-28 17:58:28 +0000[diff] [blame]654 info.fInstanceCount = SkTMin(instanceCount, maxInstancesPerDraw);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]655 info.fVertexCount = info.fInstanceCount * verticesPerInstance;
656 info.fIndexCount = info.fInstanceCount * indicesPerInstance;
657
658 if (this->checkDraw(type,
659 info.fStartVertex,
660 info.fStartIndex,
661 info.fVertexCount,
662 info.fIndexCount)) {
663 this->onDraw(info);
664 }
665 info.fStartVertex += info.fVertexCount;
666 instanceCount -= info.fInstanceCount;
bsalomon@google.com3c5b8bc2012-03-20 21:17:58 +0000[diff] [blame]667 }
668}
bsalomon@google.comf513f102011-12-08 16:12:03 +0000[diff] [blame]669
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]670////////////////////////////////////////////////////////////////////////////////
671
robertphillips@google.coma9f1f612013-04-20 12:26:07 +0000[diff] [blame]672namespace {
673
674// position + (optional) texture coord
675extern const GrVertexAttrib gBWRectPosUVAttribs[] = {
676 {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding},
commit-bot@chromium.orgc4880f62014-03-28 17:58:28 +0000[diff] [blame]677 {kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttribBinding}
robertphillips@google.coma9f1f612013-04-20 12:26:07 +0000[diff] [blame]678};
679
680void set_vertex_attributes(GrDrawState* drawState, bool hasUVs) {
681 if (hasUVs) {
682 drawState->setVertexAttribs<gBWRectPosUVAttribs>(2);
683 } else {
684 drawState->setVertexAttribs<gBWRectPosUVAttribs>(1);
685 }
686}
687
688};
689
commit-bot@chromium.orga8cbc572013-07-17 21:39:42 +0000[diff] [blame]690void GrDrawTarget::onDrawRect(const SkRect& rect,
bsalomon@google.combfed24f2013-04-02 21:00:15 +0000[diff] [blame]691 const SkMatrix* matrix,
commit-bot@chromium.orga8cbc572013-07-17 21:39:42 +0000[diff] [blame]692 const SkRect* localRect,
bsalomon@google.combfed24f2013-04-02 21:00:15 +0000[diff] [blame]693 const SkMatrix* localMatrix) {
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]694
695 GrDrawState::AutoViewMatrixRestore avmr;
696 if (NULL != matrix) {
bsalomon@google.com8bc92362013-03-20 19:19:53 +0000[diff] [blame]697 avmr.set(this->drawState(), *matrix);
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]698 }
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]699
robertphillips@google.coma9f1f612013-04-20 12:26:07 +0000[diff] [blame]700 set_vertex_attributes(this->drawState(), NULL != localRect);
701
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]702 AutoReleaseGeometry geo(this, 4, 0);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]703 if (!geo.succeeded()) {
704 GrPrintf("Failed to get space for vertices!\n");
705 return;
706 }
707
jvanverth@google.com768ccee2013-03-01 18:21:22 +0000[diff] [blame]708 size_t vsize = this->drawState()->getVertexSize();
bsalomon@google.comc8616f52013-02-01 14:19:27 +0000[diff] [blame]709 geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vsize);
bsalomon@google.com8bc92362013-03-20 19:19:53 +0000[diff] [blame]710 if (NULL != localRect) {
commit-bot@chromium.orgc4880f62014-03-28 17:58:28 +0000[diff] [blame]711 SkPoint* coords = GrTCast<SkPoint*>(GrTCast<intptr_t>(geo.vertices()) +
712 sizeof(SkPoint));
bsalomon@google.com8bc92362013-03-20 19:19:53 +0000[diff] [blame]713 coords->setRectFan(localRect->fLeft, localRect->fTop,
714 localRect->fRight, localRect->fBottom,
715 vsize);
716 if (NULL != localMatrix) {
717 localMatrix->mapPointsWithStride(coords, vsize, 4);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]718 }
719 }
commit-bot@chromium.orgab744d72014-02-11 18:24:25 +0000[diff] [blame]720 SkRect bounds;
721 this->getDrawState().getViewMatrix().mapRect(&bounds, rect);
robertphillips@google.comdcb89882012-10-05 15:37:00 +0000[diff] [blame]722
commit-bot@chromium.orgab744d72014-02-11 18:24:25 +0000[diff] [blame]723 this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4, &bounds);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]724}
725
bsalomon@google.com8b622192013-01-28 15:35:28 +0000[diff] [blame]726void GrDrawTarget::clipWillBeSet(const GrClipData* clipData) {
727}
728
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]729////////////////////////////////////////////////////////////////////////////////
730
731GrDrawTarget::AutoStateRestore::AutoStateRestore() {
732 fDrawTarget = NULL;
733}
734
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]735GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target,
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]736 ASRInit init,
737 const SkMatrix* vm) {
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]738 fDrawTarget = NULL;
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]739 this->set(target, init, vm);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]740}
741
742GrDrawTarget::AutoStateRestore::~AutoStateRestore() {
743 if (NULL != fDrawTarget) {
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]744 fDrawTarget->setDrawState(fSavedState);
745 fSavedState->unref();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]746 }
747}
748
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]749void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]750 SkASSERT(NULL == fDrawTarget);
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]751 fDrawTarget = target;
752 fSavedState = target->drawState();
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]753 SkASSERT(fSavedState);
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]754 fSavedState->ref();
755 if (kReset_ASRInit == init) {
756 if (NULL == vm) {
757 // calls the default cons
758 fTempState.init();
759 } else {
760 SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*vm));
761 }
762 } else {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]763 SkASSERT(kPreserve_ASRInit == init);
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]764 if (NULL == vm) {
765 fTempState.set(*fSavedState);
766 } else {
767 SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*fSavedState, *vm));
768 }
769 }
770 target->setDrawState(fTempState.get());
771}
772
773bool GrDrawTarget::AutoStateRestore::setIdentity(GrDrawTarget* target, ASRInit init) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]774 SkASSERT(NULL == fDrawTarget);
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]775 fDrawTarget = target;
776 fSavedState = target->drawState();
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]777 SkASSERT(fSavedState);
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]778 fSavedState->ref();
779 if (kReset_ASRInit == init) {
780 // calls the default cons
781 fTempState.init();
782 } else {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]783 SkASSERT(kPreserve_ASRInit == init);
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]784 // calls the copy cons
785 fTempState.set(*fSavedState);
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]786 if (!fTempState.get()->setIdentityViewMatrix()) {
787 // let go of any resources held by the temp
788 fTempState.get()->reset();
789 fDrawTarget = NULL;
790 fSavedState->unref();
791 fSavedState = NULL;
792 return false;
793 }
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]794 }
bsalomon@google.combfc805b2012-03-30 15:55:32 +0000[diff] [blame]795 target->setDrawState(fTempState.get());
bsalomon@google.comfbf9f302013-05-29 21:27:53 +0000[diff] [blame]796 return true;
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]797}
798
799////////////////////////////////////////////////////////////////////////////////
800
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]801GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry(
802 GrDrawTarget* target,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]803 int vertexCount,
804 int indexCount) {
805 fTarget = NULL;
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]806 this->set(target, vertexCount, indexCount);
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]807}
rmistry@google.comdfb3e3c2012-08-23 18:14:13 +0000[diff] [blame]808
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]809GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry() {
810 fTarget = NULL;
811}
812
813GrDrawTarget::AutoReleaseGeometry::~AutoReleaseGeometry() {
814 this->reset();
815}
816
817bool GrDrawTarget::AutoReleaseGeometry::set(GrDrawTarget* target,
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]818 int vertexCount,
819 int indexCount) {
820 this->reset();
821 fTarget = target;
822 bool success = true;
823 if (NULL != fTarget) {
824 fTarget = target;
jvanverth@google.com9d8e4b72013-02-05 20:33:30 +0000[diff] [blame]825 success = target->reserveVertexAndIndexSpace(vertexCount,
bsalomon@google.comc17542b2012-03-13 12:40:53 +0000[diff] [blame]826 indexCount,
827 &fVertices,
828 &fIndices);
829 if (!success) {
830 fTarget = NULL;
831 this->reset();
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]832 }
833 }
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]834 SkASSERT(success == (NULL != fTarget));
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]835 return success;
836}
837
838void GrDrawTarget::AutoReleaseGeometry::reset() {
839 if (NULL != fTarget) {
840 if (NULL != fVertices) {
841 fTarget->resetVertexSource();
842 }
843 if (NULL != fIndices) {
844 fTarget->resetIndexSource();
845 }
846 fTarget = NULL;
847 }
848 fVertices = NULL;
849 fIndices = NULL;
850}
851
bsalomon@google.comab3f6ac2012-12-13 20:38:14 +0000[diff] [blame]852GrDrawTarget::AutoClipRestore::AutoClipRestore(GrDrawTarget* target, const SkIRect& newClip) {
853 fTarget = target;
854 fClip = fTarget->getClip();
855 fStack.init();
856 fStack.get()->clipDevRect(newClip, SkRegion::kReplace_Op);
857 fReplacementClip.fClipStack = fStack.get();
858 target->setClip(&fReplacementClip);
859}
860
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]861namespace {
862// returns true if the read/written rect intersects the src/dst and false if not.
863bool clip_srcrect_and_dstpoint(const GrSurface* dst,
864 const GrSurface* src,
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]865 const SkIRect& srcRect,
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]866 const SkIPoint& dstPoint,
867 SkIRect* clippedSrcRect,
868 SkIPoint* clippedDstPoint) {
869 *clippedSrcRect = srcRect;
870 *clippedDstPoint = dstPoint;
skia.committer@gmail.comc98e3892013-04-04 07:01:12 +0000[diff] [blame]871
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]872 // clip the left edge to src and dst bounds, adjusting dstPoint if necessary
873 if (clippedSrcRect->fLeft < 0) {
874 clippedDstPoint->fX -= clippedSrcRect->fLeft;
875 clippedSrcRect->fLeft = 0;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]876 }
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]877 if (clippedDstPoint->fX < 0) {
878 clippedSrcRect->fLeft -= clippedDstPoint->fX;
879 clippedDstPoint->fX = 0;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]880 }
881
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]882 // clip the top edge to src and dst bounds, adjusting dstPoint if necessary
883 if (clippedSrcRect->fTop < 0) {
884 clippedDstPoint->fY -= clippedSrcRect->fTop;
885 clippedSrcRect->fTop = 0;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]886 }
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]887 if (clippedDstPoint->fY < 0) {
888 clippedSrcRect->fTop -= clippedDstPoint->fY;
889 clippedDstPoint->fY = 0;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]890 }
skia.committer@gmail.comc98e3892013-04-04 07:01:12 +0000[diff] [blame]891
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]892 // clip the right edge to the src and dst bounds.
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]893 if (clippedSrcRect->fRight > src->width()) {
894 clippedSrcRect->fRight = src->width();
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]895 }
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]896 if (clippedDstPoint->fX + clippedSrcRect->width() > dst->width()) {
897 clippedSrcRect->fRight = clippedSrcRect->fLeft + dst->width() - clippedDstPoint->fX;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]898 }
899
900 // clip the bottom edge to the src and dst bounds.
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]901 if (clippedSrcRect->fBottom > src->height()) {
902 clippedSrcRect->fBottom = src->height();
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]903 }
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]904 if (clippedDstPoint->fY + clippedSrcRect->height() > dst->height()) {
905 clippedSrcRect->fBottom = clippedSrcRect->fTop + dst->height() - clippedDstPoint->fY;
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]906 }
skia.committer@gmail.comc98e3892013-04-04 07:01:12 +0000[diff] [blame]907
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]908 // The above clipping steps may have inverted the rect if it didn't intersect either the src or
909 // dst bounds.
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]910 return !clippedSrcRect->isEmpty();
911}
912}
913
914bool GrDrawTarget::copySurface(GrSurface* dst,
915 GrSurface* src,
916 const SkIRect& srcRect,
917 const SkIPoint& dstPoint) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]918 SkASSERT(NULL != dst);
919 SkASSERT(NULL != src);
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]920
921 SkIRect clippedSrcRect;
922 SkIPoint clippedDstPoint;
923 // If the rect is outside the src or dst then we've already succeeded.
924 if (!clip_srcrect_and_dstpoint(dst,
925 src,
926 srcRect,
927 dstPoint,
928 &clippedSrcRect,
929 &clippedDstPoint)) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]930 SkASSERT(this->canCopySurface(dst, src, srcRect, dstPoint));
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]931 return true;
932 }
933
934 bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]935 SkASSERT(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]936 return result;
937}
938
939bool GrDrawTarget::canCopySurface(GrSurface* dst,
940 GrSurface* src,
941 const SkIRect& srcRect,
942 const SkIPoint& dstPoint) {
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]943 SkASSERT(NULL != dst);
944 SkASSERT(NULL != src);
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]945
946 SkIRect clippedSrcRect;
947 SkIPoint clippedDstPoint;
948 // If the rect is outside the src or dst then we're guaranteed success
949 if (!clip_srcrect_and_dstpoint(dst,
950 src,
951 srcRect,
952 dstPoint,
953 &clippedSrcRect,
954 &clippedDstPoint)) {
955 return true;
956 }
957 return this->onCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
958}
959
960bool GrDrawTarget::onCanCopySurface(GrSurface* dst,
961 GrSurface* src,
962 const SkIRect& srcRect,
963 const SkIPoint& dstPoint) {
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]964 // Check that the read/write rects are contained within the src/dst bounds.
tfarina@chromium.orga91959e2013-08-17 00:02:59 +0000[diff] [blame]965 SkASSERT(!srcRect.isEmpty());
966 SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
967 SkASSERT(dstPoint.fX >= 0 && dstPoint.fY >= 0);
968 SkASSERT(dstPoint.fX + srcRect.width() <= dst->width() &&
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]969 dstPoint.fY + srcRect.height() <= dst->height());
970
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]971 return !dst->isSameAs(src) && NULL != dst->asRenderTarget() && NULL != src->asTexture();
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]972}
973
974bool GrDrawTarget::onCopySurface(GrSurface* dst,
975 GrSurface* src,
976 const SkIRect& srcRect,
977 const SkIPoint& dstPoint) {
bsalomon@google.com41fa4102013-04-09 15:38:19 +0000[diff] [blame]978 if (!GrDrawTarget::onCanCopySurface(dst, src, srcRect, dstPoint)) {
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]979 return false;
980 }
981
982 GrRenderTarget* rt = dst->asRenderTarget();
983 GrTexture* tex = src->asTexture();
984
985 GrDrawTarget::AutoStateRestore asr(this, kReset_ASRInit);
986 this->drawState()->setRenderTarget(rt);
987 SkMatrix matrix;
988 matrix.setTranslate(SkIntToScalar(srcRect.fLeft - dstPoint.fX),
989 SkIntToScalar(srcRect.fTop - dstPoint.fY));
990 matrix.postIDiv(tex->width(), tex->height());
bsalomon@google.com860912a2013-06-13 19:34:18 +0000[diff] [blame]991 this->drawState()->addColorTextureEffect(tex, matrix);
bsalomon@google.comb9caace2013-04-03 14:56:40 +0000[diff] [blame]992 SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX,
993 dstPoint.fY,
994 srcRect.width(),
995 srcRect.height());
996 this->drawSimpleRect(dstRect);
997 return true;
998}
999
bsalomon@google.comb1bfcd32013-04-15 13:51:00 +0000[diff] [blame]1000void GrDrawTarget::initCopySurfaceDstDesc(const GrSurface* src, GrTextureDesc* desc) {
1001 // Make the dst of the copy be a render target because the default copySurface draws to the dst.
1002 desc->fOrigin = kDefault_GrSurfaceOrigin;
1003 desc->fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
1004 desc->fConfig = src->config();
1005}
1006
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1007///////////////////////////////////////////////////////////////////////////////
1008
bsalomon@google.com516b4c32013-03-25 18:19:00 +0000[diff] [blame]1009void GrDrawTargetCaps::reset() {
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1010 f8BitPaletteSupport = false;
commit-bot@chromium.org21645ef2013-12-19 16:18:01 +0000[diff] [blame]1011 fMipMapSupport = false;
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1012 fNPOTTextureTileSupport = false;
1013 fTwoSidedStencilSupport = false;
1014 fStencilWrapOpsSupport = false;
1015 fHWAALineSupport = false;
1016 fShaderDerivativeSupport = false;
1017 fGeometryShaderSupport = false;
skia.committer@gmail.comb691cc72013-03-26 07:01:04 +0000[diff] [blame]1018 fDualSourceBlendingSupport = false;
djsollen@google.com6162e3e2014-05-02 17:44:34 +0000[diff] [blame]1019 fBufferLockSupport = false;
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]1020 fPathRenderingSupport = false;
commit-bot@chromium.org0ab0c012013-07-18 22:26:39 +0000[diff] [blame]1021 fDstReadInShaderSupport = false;
commit-bot@chromium.org7865a202014-03-28 16:08:05 +0000[diff] [blame]1022 fDiscardRenderTargetSupport = false;
commit-bot@chromium.org0ab0c012013-07-18 22:26:39 +0000[diff] [blame]1023 fReuseScratchTextures = true;
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]1024 fGpuTracingSupport = false;
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1025
1026 fMaxRenderTargetSize = 0;
1027 fMaxTextureSize = 0;
1028 fMaxSampleCount = 0;
commit-bot@chromium.org03e1ce02013-10-14 15:33:45 +0000[diff] [blame]1029
1030 memset(fConfigRenderSupport, 0, sizeof(fConfigRenderSupport));
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1031}
1032
bsalomon@google.com516b4c32013-03-25 18:19:00 +0000[diff] [blame]1033GrDrawTargetCaps& GrDrawTargetCaps::operator=(const GrDrawTargetCaps& other) {
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1034 f8BitPaletteSupport = other.f8BitPaletteSupport;
commit-bot@chromium.org21645ef2013-12-19 16:18:01 +0000[diff] [blame]1035 fMipMapSupport = other.fMipMapSupport;
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1036 fNPOTTextureTileSupport = other.fNPOTTextureTileSupport;
1037 fTwoSidedStencilSupport = other.fTwoSidedStencilSupport;
1038 fStencilWrapOpsSupport = other.fStencilWrapOpsSupport;
1039 fHWAALineSupport = other.fHWAALineSupport;
1040 fShaderDerivativeSupport = other.fShaderDerivativeSupport;
1041 fGeometryShaderSupport = other.fGeometryShaderSupport;
1042 fDualSourceBlendingSupport = other.fDualSourceBlendingSupport;
djsollen@google.com6162e3e2014-05-02 17:44:34 +0000[diff] [blame]1043 fBufferLockSupport = other.fBufferLockSupport;
commit-bot@chromium.orgb4eb9b32013-10-09 14:11:33 +0000[diff] [blame]1044 fPathRenderingSupport = other.fPathRenderingSupport;
commit-bot@chromium.org0ab0c012013-07-18 22:26:39 +0000[diff] [blame]1045 fDstReadInShaderSupport = other.fDstReadInShaderSupport;
commit-bot@chromium.org7865a202014-03-28 16:08:05 +0000[diff] [blame]1046 fDiscardRenderTargetSupport = other.fDiscardRenderTargetSupport;
commit-bot@chromium.org0ab0c012013-07-18 22:26:39 +0000[diff] [blame]1047 fReuseScratchTextures = other.fReuseScratchTextures;
commit-bot@chromium.org1404a232014-02-21 18:45:30 +0000[diff] [blame]1048 fGpuTracingSupport = other.fGpuTracingSupport;
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1049
1050 fMaxRenderTargetSize = other.fMaxRenderTargetSize;
1051 fMaxTextureSize = other.fMaxTextureSize;
1052 fMaxSampleCount = other.fMaxSampleCount;
1053
commit-bot@chromium.org03e1ce02013-10-14 15:33:45 +0000[diff] [blame]1054 memcpy(fConfigRenderSupport, other.fConfigRenderSupport, sizeof(fConfigRenderSupport));
1055
bsalomon@google.com59831d72013-03-25 15:38:39 +0000[diff] [blame]1056 return *this;
1057}
1058
commit-bot@chromium.org89b70802013-11-21 15:23:15 +0000[diff] [blame]1059SkString GrDrawTargetCaps::dump() const {
1060 SkString r;
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]1061 static const char* gNY[] = {"NO", "YES"};
commit-bot@chromium.org7865a202014-03-28 16:08:05 +0000[diff] [blame]1062 r.appendf("8 Bit Palette Support : %s\n", gNY[f8BitPaletteSupport]);
1063 r.appendf("MIP Map Support : %s\n", gNY[fMipMapSupport]);
1064 r.appendf("NPOT Texture Tile Support : %s\n", gNY[fNPOTTextureTileSupport]);
1065 r.appendf("Two Sided Stencil Support : %s\n", gNY[fTwoSidedStencilSupport]);
1066 r.appendf("Stencil Wrap Ops Support : %s\n", gNY[fStencilWrapOpsSupport]);
1067 r.appendf("HW AA Lines Support : %s\n", gNY[fHWAALineSupport]);
1068 r.appendf("Shader Derivative Support : %s\n", gNY[fShaderDerivativeSupport]);
1069 r.appendf("Geometry Shader Support : %s\n", gNY[fGeometryShaderSupport]);
1070 r.appendf("Dual Source Blending Support : %s\n", gNY[fDualSourceBlendingSupport]);
djsollen@google.com6162e3e2014-05-02 17:44:34 +0000[diff] [blame]1071 r.appendf("Buffer Lock Support : %s\n", gNY[fBufferLockSupport]);
commit-bot@chromium.org7865a202014-03-28 16:08:05 +0000[diff] [blame]1072 r.appendf("Path Rendering Support : %s\n", gNY[fPathRenderingSupport]);
1073 r.appendf("Dst Read In Shader Support : %s\n", gNY[fDstReadInShaderSupport]);
1074 r.appendf("Discard Render Target Support: %s\n", gNY[fDiscardRenderTargetSupport]);
1075 r.appendf("Reuse Scratch Textures : %s\n", gNY[fReuseScratchTextures]);
1076 r.appendf("Gpu Tracing Support : %s\n", gNY[fGpuTracingSupport]);
1077 r.appendf("Max Texture Size : %d\n", fMaxTextureSize);
1078 r.appendf("Max Render Target Size : %d\n", fMaxRenderTargetSize);
1079 r.appendf("Max Sample Count : %d\n", fMaxSampleCount);
commit-bot@chromium.org03e1ce02013-10-14 15:33:45 +0000[diff] [blame]1080
1081 static const char* kConfigNames[] = {
1082 "Unknown", // kUnknown_GrPixelConfig
1083 "Alpha8", // kAlpha_8_GrPixelConfig,
1084 "Index8", // kIndex_8_GrPixelConfig,
1085 "RGB565", // kRGB_565_GrPixelConfig,
1086 "RGBA444", // kRGBA_4444_GrPixelConfig,
1087 "RGBA8888", // kRGBA_8888_GrPixelConfig,
1088 "BGRA8888", // kBGRA_8888_GrPixelConfig,
1089 };
1090 GR_STATIC_ASSERT(0 == kUnknown_GrPixelConfig);
1091 GR_STATIC_ASSERT(1 == kAlpha_8_GrPixelConfig);
1092 GR_STATIC_ASSERT(2 == kIndex_8_GrPixelConfig);
1093 GR_STATIC_ASSERT(3 == kRGB_565_GrPixelConfig);
1094 GR_STATIC_ASSERT(4 == kRGBA_4444_GrPixelConfig);
1095 GR_STATIC_ASSERT(5 == kRGBA_8888_GrPixelConfig);
1096 GR_STATIC_ASSERT(6 == kBGRA_8888_GrPixelConfig);
1097 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kConfigNames) == kGrPixelConfigCnt);
1098
commit-bot@chromium.org2b1e5ac2013-11-08 18:45:27 +0000[diff] [blame]1099 SkASSERT(!fConfigRenderSupport[kUnknown_GrPixelConfig][0]);
1100 SkASSERT(!fConfigRenderSupport[kUnknown_GrPixelConfig][1]);
commit-bot@chromium.org03e1ce02013-10-14 15:33:45 +0000[diff] [blame]1101 for (size_t i = 0; i < SK_ARRAY_COUNT(kConfigNames); ++i) {
1102 if (i != kUnknown_GrPixelConfig) {
commit-bot@chromium.org89b70802013-11-21 15:23:15 +0000[diff] [blame]1103 r.appendf("%s is renderable: %s, with MSAA: %s\n",
commit-bot@chromium.org60125332013-10-15 14:18:16 +0000[diff] [blame]1104 kConfigNames[i],
1105 gNY[fConfigRenderSupport[i][0]],
1106 gNY[fConfigRenderSupport[i][1]]);
commit-bot@chromium.org03e1ce02013-10-14 15:33:45 +0000[diff] [blame]1107 }
1108 }
commit-bot@chromium.org89b70802013-11-21 15:23:15 +0000[diff] [blame]1109 return r;
bsalomon@google.com3f30e3a2011-10-12 19:53:16 +0000[diff] [blame]1110}