Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(6)

Side by Side Diff: tests/GLProgramsTest.cpp

Issue 582963002: Solo gp (Closed) Base URL: https://skia.googlesource.com/skia.git@no_peb
Patch Set: rebase Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp ('k') | tests/GpuColorFilterTest.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 1
2 /* 2 /*
3 * Copyright 2011 Google Inc. 3 * Copyright 2011 Google Inc.
4 * 4 *
5 * Use of this source code is governed by a BSD-style license that can be 5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file. 6 * found in the LICENSE file.
7 */ 7 */
8 8
9 // This is a GPU-backend specific test. It relies on static intializers to work 9 // This is a GPU-backend specific test. It relies on static intializers to work
10 10
11 #include "SkTypes.h" 11 #include "SkTypes.h"
12 12
13 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS 13 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
14 14
15 #include "GrBackendEffectFactory.h" 15 #include "GrBackendProcessorFactory.h"
16 #include "GrContextFactory.h" 16 #include "GrContextFactory.h"
17 #include "GrOptDrawState.h" 17 #include "GrOptDrawState.h"
18 #include "effects/GrConfigConversionEffect.h" 18 #include "effects/GrConfigConversionEffect.h"
19 #include "gl/GrGLPathRendering.h" 19 #include "gl/GrGLPathRendering.h"
20 #include "gl/GrGpuGL.h" 20 #include "gl/GrGpuGL.h"
21 #include "SkChecksum.h" 21 #include "SkChecksum.h"
22 #include "SkRandom.h" 22 #include "SkRandom.h"
23 #include "Test.h" 23 #include "Test.h"
24 24
25 static void get_stage_stats(const GrEffectStage stage, bool* readsDst, 25 static void get_stage_stats(const GrFragmentStage stage, bool* readsDst,
26 bool* readsFragPosition, bool* requiresVertexShader) { 26 bool* readsFragPosition, bool* requiresVertexShader) {
27 if (stage.getEffect()->willReadDstColor()) { 27 if (stage.getFragmentProcessor()->willReadDstColor()) {
28 *readsDst = true; 28 *readsDst = true;
29 } 29 }
30 if (stage.getEffect()->willReadFragmentPosition()) { 30 if (stage.getProcessor()->willReadFragmentPosition()) {
31 *readsFragPosition = true; 31 *readsFragPosition = true;
32 } 32 }
33 if (stage.getEffect()->requiresVertexShader()) {
34 *requiresVertexShader = true;
35 }
36 } 33 }
37 34
38 bool GrGLProgramDesc::setRandom(SkRandom* random, 35 bool GrGLProgramDesc::setRandom(SkRandom* random,
39 GrGpuGL* gpu, 36 GrGpuGL* gpu,
40 const GrRenderTarget* dstRenderTarget, 37 const GrRenderTarget* dstRenderTarget,
41 const GrTexture* dstCopyTexture, 38 const GrTexture* dstCopyTexture,
42 const GrEffectStage* geometryProcessor, 39 const GrGeometryStage* geometryProcessor,
43 const GrEffectStage* stages[], 40 const GrFragmentStage* stages[],
44 int numColorStages, 41 int numColorStages,
45 int numCoverageStages, 42 int numCoverageStages,
46 int currAttribIndex, 43 int currAttribIndex,
47 GrGpu::DrawType drawType) { 44 GrGpu::DrawType drawType) {
48 bool isPathRendering = GrGpu::IsPathRenderingDrawType(drawType); 45 bool isPathRendering = GrGpu::IsPathRenderingDrawType(drawType);
49 bool useLocalCoords = !isPathRendering && 46 bool useLocalCoords = !isPathRendering &&
50 random->nextBool() && 47 random->nextBool() &&
51 currAttribIndex < GrDrawState::kMaxVertexAttribCnt; 48 currAttribIndex < GrDrawState::kMaxVertexAttribCnt;
52 49
53 int numStages = numColorStages + numCoverageStages; 50 int numStages = numColorStages + numCoverageStages;
54 fKey.reset(); 51 fKey.reset();
55 52
56 GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t)); 53 GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t));
57 54
58 // Make room for everything up to and including the array of offsets to effe ct keys. 55 // Make room for everything up to and including the array of offsets to effe ct keys.
59 fKey.push_back_n(kEffectKeyOffsetsAndLengthOffset + 2 * sizeof(uint16_t) * ( numStages + 56 fKey.push_back_n(kEffectKeyOffsetsAndLengthOffset + 2 * sizeof(uint16_t) * ( numStages +
60 (geometryProcessor ? 1 : 0))); 57 (geometryProcessor ? 1 : 0)));
61 58
62 bool dstRead = false; 59 bool dstRead = false;
63 bool fragPos = false; 60 bool fragPos = false;
64 bool vertexShader = SkToBool(geometryProcessor); 61 bool vertexShader = SkToBool(geometryProcessor);
65 int offset = 0; 62 int offset = 0;
66 if (geometryProcessor) { 63 if (geometryProcessor) {
67 const GrEffectStage* stage = geometryProcessor; 64 const GrGeometryStage* stage = geometryProcessor;
68 uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() + 65 uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() +
69 kEffectKeyOffsetsA ndLengthOffset + 66 kEffectKeyOffsetsA ndLengthOffset +
70 offset * 2 * sizeo f(uint16_t)); 67 offset * 2 * sizeo f(uint16_t));
71 uint32_t effectKeyOffset = fKey.count(); 68 uint32_t effectKeyOffset = fKey.count();
72 if (effectKeyOffset > SK_MaxU16) { 69 if (effectKeyOffset > SK_MaxU16) {
73 fKey.reset(); 70 fKey.reset();
74 return false; 71 return false;
75 } 72 }
76 GrEffectKeyBuilder b(&fKey); 73 GrProcessorKeyBuilder b(&fKey);
77 uint16_t effectKeySize; 74 uint16_t effectKeySize;
78 if (!GetEffectKey(*stage, gpu->glCaps(), useLocalCoords, &b, &effectKeyS ize)) { 75 if (!GetProcessorKey(*stage, gpu->glCaps(), useLocalCoords, &b, &effectK eySize)) {
79 fKey.reset(); 76 fKey.reset();
80 return false; 77 return false;
81 } 78 }
82 get_stage_stats(*stage, &dstRead, &fragPos, &vertexShader); 79 vertexShader = true;
80 fragPos = stage->getProcessor()->willReadFragmentPosition();
83 offsetAndSize[0] = effectKeyOffset; 81 offsetAndSize[0] = effectKeyOffset;
84 offsetAndSize[1] = effectKeySize; 82 offsetAndSize[1] = effectKeySize;
85 offset++; 83 offset++;
86 } 84 }
87 85
88 for (int s = 0; s < numStages; ++s, ++offset) { 86 for (int s = 0; s < numStages; ++s, ++offset) {
89 const GrEffectStage* stage = stages[s]; 87 const GrFragmentStage* stage = stages[s];
90 uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() + 88 uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() +
91 kEffectKeyOffsetsA ndLengthOffset + 89 kEffectKeyOffsetsA ndLengthOffset +
92 offset * 2 * sizeo f(uint16_t)); 90 offset * 2 * sizeo f(uint16_t));
93 uint32_t effectKeyOffset = fKey.count(); 91 uint32_t effectKeyOffset = fKey.count();
94 if (effectKeyOffset > SK_MaxU16) { 92 if (effectKeyOffset > SK_MaxU16) {
95 fKey.reset(); 93 fKey.reset();
96 return false; 94 return false;
97 } 95 }
98 GrEffectKeyBuilder b(&fKey); 96 GrProcessorKeyBuilder b(&fKey);
99 uint16_t effectKeySize; 97 uint16_t effectKeySize;
100 if (!GetEffectKey(*stages[s], gpu->glCaps(), useLocalCoords, &b, &effect KeySize)) { 98 if (!GetProcessorKey(*stages[s], gpu->glCaps(), useLocalCoords, &b, &eff ectKeySize)) {
101 fKey.reset(); 99 fKey.reset();
102 return false; 100 return false;
103 } 101 }
104 get_stage_stats(*stage, &dstRead, &fragPos, &vertexShader); 102 get_stage_stats(*stage, &dstRead, &fragPos, &vertexShader);
105 offsetAndSize[0] = effectKeyOffset; 103 offsetAndSize[0] = effectKeyOffset;
106 offsetAndSize[1] = effectKeySize; 104 offsetAndSize[1] = effectKeySize;
107 } 105 }
108 106
109 KeyHeader* header = this->header(); 107 KeyHeader* header = this->header();
110 memset(header, 0, kHeaderSize); 108 memset(header, 0, kHeaderSize);
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after
183 this->finalize(); 181 this->finalize();
184 return true; 182 return true;
185 } 183 }
186 184
187 // TODO clean this up, we have to do this to test geometry processors but there has got to be 185 // TODO clean this up, we have to do this to test geometry processors but there has got to be
188 // a better way. In the mean time, we actually fill out these generic vertex at tribs below with 186 // a better way. In the mean time, we actually fill out these generic vertex at tribs below with
189 // the correct vertex attribs from the GP. We have to ensure, however, we don't try to add more 187 // the correct vertex attribs from the GP. We have to ensure, however, we don't try to add more
190 // than two attributes. 188 // than two attributes.
191 GrVertexAttrib genericVertexAttribs[] = { 189 GrVertexAttrib genericVertexAttribs[] = {
192 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding }, 190 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding },
193 { kVec2f_GrVertexAttribType, 0, kEffect_GrVertexAttribBinding }, 191 { kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding } ,
194 { kVec2f_GrVertexAttribType, 0, kEffect_GrVertexAttribBinding } 192 { kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding }
195 }; 193 };
196 194
197 /* 195 /*
198 * convert sl type to vertexattrib type, not a complete implementation, only use for debugging 196 * convert sl type to vertexattrib type, not a complete implementation, only use for debugging
199 */ 197 */
200 GrVertexAttribType convert_sltype_to_attribtype(GrSLType type) { 198 GrVertexAttribType convert_sltype_to_attribtype(GrSLType type) {
201 switch (type) { 199 switch (type) {
202 case kFloat_GrSLType: 200 case kFloat_GrSLType:
203 return kFloat_GrVertexAttribType; 201 return kFloat_GrVertexAttribType;
204 case kVec2f_GrSLType: 202 case kVec2f_GrSLType:
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
249 GrGLProgramDesc pdesc; 247 GrGLProgramDesc pdesc;
250 248
251 int currAttribIndex = 1; // we need to always leave room for position 249 int currAttribIndex = 1; // we need to always leave room for position
252 int currTextureCoordSet = 0; 250 int currTextureCoordSet = 0;
253 GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()}; 251 GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
254 252
255 int numStages = random.nextULessThan(maxStages + 1); 253 int numStages = random.nextULessThan(maxStages + 1);
256 int numColorStages = random.nextULessThan(numStages + 1); 254 int numColorStages = random.nextULessThan(numStages + 1);
257 int numCoverageStages = numStages - numColorStages; 255 int numCoverageStages = numStages - numColorStages;
258 256
259 SkAutoSTMalloc<8, const GrEffectStage*> stages(numStages); 257 SkAutoSTMalloc<8, const GrFragmentStage*> stages(numStages);
260 258
261 bool usePathRendering = this->glCaps().pathRenderingSupport() && random. nextBool(); 259 bool usePathRendering = this->glCaps().pathRenderingSupport() && random. nextBool();
262 260
263 GrGpu::DrawType drawType = usePathRendering ? GrGpu::kDrawPath_DrawType : 261 GrGpu::DrawType drawType = usePathRendering ? GrGpu::kDrawPath_DrawType :
264 GrGpu::kDrawPoints_DrawTyp e; 262 GrGpu::kDrawPoints_DrawTyp e;
265 263
266 SkAutoTDelete<GrEffectStage> geometryProcessor; 264 SkAutoTDelete<GrGeometryStage> geometryProcessor;
267 bool hasGeometryProcessor = usePathRendering ? false : random.nextBool() ; 265 bool hasGeometryProcessor = usePathRendering ? false : random.nextBool() ;
268 if (hasGeometryProcessor) { 266 if (hasGeometryProcessor) {
269 while (true) { 267 while (true) {
270 SkAutoTUnref<const GrEffect> effect(GrEffectTestFactory::CreateS tage( 268 SkAutoTUnref<const GrGeometryProcessor> effect(
271 &random, 269 GrProcessorTestFactory<GrGeometryProcessor>::CreateStage (&random, this->getContext(), *this->caps(),
272 this->getContext(), 270 dummyTextures));
273 *this->caps(),
274 dummyTextures));
275 SkASSERT(effect); 271 SkASSERT(effect);
276 // Only geometryProcessor can use vertex shader 272 // Only geometryProcessor can use vertex shader
277 if (!effect->requiresVertexShader()) { 273 GrGeometryStage* stage = SkNEW_ARGS(GrGeometryStage, (effect.get ()));
278 continue;
279 }
280
281 GrEffectStage* stage = SkNEW_ARGS(GrEffectStage, (effect.get())) ;
282 geometryProcessor.reset(stage); 274 geometryProcessor.reset(stage);
283 275
284 // we have to set dummy vertex attribs 276 // we have to set dummy vertex attribs
285 const GrEffect::VertexAttribArray& v = effect->getVertexAttribs( ); 277 const GrGeometryProcessor::VertexAttribArray& v = effect->getVer texAttribs();
286 int numVertexAttribs = v.count(); 278 int numVertexAttribs = v.count();
287 279
288 SkASSERT(GrEffect::kMaxVertexAttribs == 2 && 280 SkASSERT(GrGeometryProcessor::kMaxVertexAttribs == 2 &&
289 GrEffect::kMaxVertexAttribs >= numVertexAttribs); 281 GrGeometryProcessor::kMaxVertexAttribs >= numVertexAttr ibs);
290 size_t runningStride = GrVertexAttribTypeSize(genericVertexAttri bs[0].fType); 282 size_t runningStride = GrVertexAttribTypeSize(genericVertexAttri bs[0].fType);
291 for (int i = 0; i < numVertexAttribs; i++) { 283 for (int i = 0; i < numVertexAttribs; i++) {
292 genericVertexAttribs[i + 1].fOffset = runningStride; 284 genericVertexAttribs[i + 1].fOffset = runningStride;
293 genericVertexAttribs[i + 1].fType = 285 genericVertexAttribs[i + 1].fType =
294 convert_sltype_to_attribtype(v[i].getType()); 286 convert_sltype_to_attribtype(v[i].getType());
295 runningStride += GrVertexAttribTypeSize(genericVertexAttribs [i + 1].fType); 287 runningStride += GrVertexAttribTypeSize(genericVertexAttribs [i + 1].fType);
296 } 288 }
297 289
298 // update the vertex attributes with the ds 290 // update the vertex attributes with the ds
299 GrDrawState* ds = this->drawState(); 291 GrDrawState* ds = this->drawState();
300 ds->setVertexAttribs<genericVertexAttribs>(numVertexAttribs + 1, runningStride); 292 ds->setVertexAttribs<genericVertexAttribs>(numVertexAttribs + 1, runningStride);
301 currAttribIndex = numVertexAttribs + 1; 293 currAttribIndex = numVertexAttribs + 1;
302 break; 294 break;
303 } 295 }
304 } 296 }
305 for (int s = 0; s < numStages;) { 297 for (int s = 0; s < numStages;) {
306 SkAutoTUnref<const GrEffect> effect(GrEffectTestFactory::CreateStage ( 298 SkAutoTUnref<const GrFragmentProcessor> effect(
299 GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(
307 &ran dom, 300 &ran dom,
308 this ->getContext(), 301 this ->getContext(),
309 *thi s->caps(), 302 *thi s->caps(),
310 dumm yTextures)); 303 dumm yTextures));
311 SkASSERT(effect); 304 SkASSERT(effect);
312 305
313 // Only geometryProcessor can use vertex shader
314 if (effect->requiresVertexShader()) {
315 continue;
316 }
317
318 // If adding this effect would exceed the max texture coord set coun t then generate a 306 // If adding this effect would exceed the max texture coord set coun t then generate a
319 // new random effect. 307 // new random effect.
320 if (usePathRendering && this->glPathRendering()->texturingMode() == 308 if (usePathRendering && this->glPathRendering()->texturingMode() ==
321 GrGLPathRendering::FixedFunction_TexturingMo de) {; 309 GrGLPathRendering::FixedFunction_TexturingMo de) {;
322 int numTransforms = effect->numTransforms(); 310 int numTransforms = effect->numTransforms();
323 if (currTextureCoordSet + numTransforms > this->glCaps().maxFixe dFunctionTextureCoords()) { 311 if (currTextureCoordSet + numTransforms > this->glCaps().maxFixe dFunctionTextureCoords()) {
324 continue; 312 continue;
325 } 313 }
326 currTextureCoordSet += numTransforms; 314 currTextureCoordSet += numTransforms;
327 } 315 }
328 GrEffectStage* stage = SkNEW_ARGS(GrEffectStage, (effect.get())); 316 GrFragmentStage* stage = SkNEW_ARGS(GrFragmentStage, (effect.get())) ;
329 317
330 stages[s] = stage; 318 stages[s] = stage;
331 ++s; 319 ++s;
332 } 320 }
333 const GrTexture* dstTexture = random.nextBool() ? dummyTextures[0] : dum myTextures[1]; 321 const GrTexture* dstTexture = random.nextBool() ? dummyTextures[0] : dum myTextures[1];
334 if (!pdesc.setRandom(&random, 322 if (!pdesc.setRandom(&random,
335 this, 323 this,
336 dummyTextures[0]->asRenderTarget(), 324 dummyTextures[0]->asRenderTarget(),
337 dstTexture, 325 dstTexture,
338 geometryProcessor.get(), 326 geometryProcessor.get(),
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after
398 SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1)); 386 SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1));
399 GrConfigConversionEffect::Create(NULL, 387 GrConfigConversionEffect::Create(NULL,
400 false, 388 false,
401 GrConfigConversionEffect::kNone_PMConversio n, 389 GrConfigConversionEffect::kNone_PMConversio n,
402 SkMatrix::I()); 390 SkMatrix::I());
403 SkScalar matrix[20]; 391 SkScalar matrix[20];
404 SkAutoTUnref<SkColorMatrixFilter> cmf(SkColorMatrixFilter::Create(matrix)); 392 SkAutoTUnref<SkColorMatrixFilter> cmf(SkColorMatrixFilter::Create(matrix));
405 } 393 }
406 394
407 #endif 395 #endif
OLDNEW
« no previous file with comments | « src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp ('k') | tests/GpuColorFilterTest.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698