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

Side by Side Diff: src/gpu/gl/GrGLShaderBuilder.cpp

Issue 12668019: Make GrGLShaderBuilder responsible for enabling GLSL extensions (Closed) Base URL: http://skia.googlecode.com/svn/trunk/
Patch Set: Created 7 years, 8 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 | Annotate | Revision Log
« no previous file with comments | « src/gpu/gl/GrGLShaderBuilder.h ('k') | no next file » | 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 * Copyright 2012 Google Inc. 2 * Copyright 2012 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 5 * found in the LICENSE file.
6 */ 6 */
7 7
8 #include "gl/GrGLShaderBuilder.h" 8 #include "gl/GrGLShaderBuilder.h"
9 #include "gl/GrGLProgram.h" 9 #include "gl/GrGLProgram.h"
10 #include "gl/GrGLUniformHandle.h" 10 #include "gl/GrGLUniformHandle.h"
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
89 , fVSAttrs(kVarsPerBlock) 89 , fVSAttrs(kVarsPerBlock)
90 , fVSOutputs(kVarsPerBlock) 90 , fVSOutputs(kVarsPerBlock)
91 , fGSInputs(kVarsPerBlock) 91 , fGSInputs(kVarsPerBlock)
92 , fGSOutputs(kVarsPerBlock) 92 , fGSOutputs(kVarsPerBlock)
93 , fFSInputs(kVarsPerBlock) 93 , fFSInputs(kVarsPerBlock)
94 , fFSOutputs(kMaxFSOutputs) 94 , fFSOutputs(kMaxFSOutputs)
95 , fUsesGS(false) 95 , fUsesGS(false)
96 , fCtxInfo(ctxInfo) 96 , fCtxInfo(ctxInfo)
97 , fUniformManager(uniformManager) 97 , fUniformManager(uniformManager)
98 , fCurrentStageIdx(kNonStageIdx) 98 , fCurrentStageIdx(kNonStageIdx)
99 , fFSFeaturesAddedMask(0)
99 , fSetupFragPosition(false) 100 , fSetupFragPosition(false)
100 , fRTHeightUniform(GrGLUniformManager::kInvalidUniformHandle) { 101 , fRTHeightUniform(GrGLUniformManager::kInvalidUniformHandle) {
101 102
102 fPositionVar = &fVSAttrs.push_back(); 103 fPositionVar = &fVSAttrs.push_back();
103 fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, " aPosition"); 104 fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, " aPosition");
104 if (explicitLocalCoords) { 105 if (explicitLocalCoords) {
105 fLocalCoordsVar = &fVSAttrs.push_back(); 106 fLocalCoordsVar = &fVSAttrs.push_back();
106 fLocalCoordsVar->set(kVec2f_GrSLType, 107 fLocalCoordsVar->set(kVec2f_GrSLType,
107 GrGLShaderVar::kAttribute_TypeModifier, 108 GrGLShaderVar::kAttribute_TypeModifier,
108 "aLocalCoords"); 109 "aLocalCoords");
109 } else { 110 } else {
110 fLocalCoordsVar = fPositionVar; 111 fLocalCoordsVar = fPositionVar;
111 } 112 }
112 } 113 }
113 114
115 bool GrGLShaderBuilder::enableFeature(GLSLFeature feature) {
116 switch (feature) {
117 case kStandardDerivatives_GLSLFeature:
118 if (!fCtxInfo.caps()->shaderDerivativeSupport()) {
119 return false;
120 }
121 if (kES2_GrGLBinding == fCtxInfo.binding()) {
122 this->addFSFeature(1 << kStandardDerivatives_GLSLFeature,
123 "GL_OES_standard_derivatives");
124 }
125 return true;
126 default:
127 GrCrash("Unexpected GLSLFeature requested.");
128 return false;
129 }
130 }
131
132 bool GrGLShaderBuilder::enablePrivateFeature(GLSLPrivateFeature feature) {
133 switch (feature) {
134 case kFragCoordConventions_GLSLPrivateFeature:
135 if (!fCtxInfo.caps()->fragCoordConventionsSupport()) {
136 return false;
137 }
138 if (fCtxInfo.glslGeneration() < k150_GrGLSLGeneration) {
139 this->addFSFeature(1 << kFragCoordConventions_GLSLPrivateFeature ,
140 "GL_ARB_fragment_coord_conventions");
141 }
142 return true;
143 default:
144 GrCrash("Unexpected GLSLPrivateFeature requested.");
145 return false;
146 }
147 }
148
robertphillips 2013/03/26 17:26:05 "require" vs. "enable"
bsalomon 2013/04/01 17:49:31 require is more correct. We need the extension to
149 void GrGLShaderBuilder::addFSFeature(uint32_t featureBit, const char* extensionN ame) {
150 if (!(featureBit & fFSFeaturesAddedMask)) {
151 fFSHeader.appendf("#extension %s: require\n", extensionName);
152 fFSFeaturesAddedMask |= featureBit;
153 }
154 }
155
156
114 void GrGLShaderBuilder::codeAppendf(ShaderType type, const char format[], va_lis t args) { 157 void GrGLShaderBuilder::codeAppendf(ShaderType type, const char format[], va_lis t args) {
115 SkString* string = NULL; 158 SkString* string = NULL;
116 switch (type) { 159 switch (type) {
117 case kVertex_ShaderType: 160 case kVertex_ShaderType:
118 string = &fVSCode; 161 string = &fVSCode;
119 break; 162 break;
120 case kGeometry_ShaderType: 163 case kGeometry_ShaderType:
121 string = &fGSCode; 164 string = &fGSCode;
122 break; 165 break;
123 case kFragment_ShaderType: 166 case kFragment_ShaderType:
(...skipping 203 matching lines...) Expand 10 before | Expand all | Expand 10 after
327 fFSInputs.back().setName(*fsName); 370 fFSInputs.back().setName(*fsName);
328 if (fsInName) { 371 if (fsInName) {
329 *fsInName = fsName->c_str(); 372 *fsInName = fsName->c_str();
330 } 373 }
331 } 374 }
332 375
333 const char* GrGLShaderBuilder::fragmentPosition() { 376 const char* GrGLShaderBuilder::fragmentPosition() {
334 #if 1 377 #if 1
335 if (fCtxInfo.caps()->fragCoordConventionsSupport()) { 378 if (fCtxInfo.caps()->fragCoordConventionsSupport()) {
336 if (!fSetupFragPosition) { 379 if (!fSetupFragPosition) {
337 if (fCtxInfo.glslGeneration() < k150_GrGLSLGeneration) { 380 SkAssertResult(this->enablePrivateFeature(kFragCoordConventions_GLSL PrivateFeature));
338 fFSHeader.append("#extension GL_ARB_fragment_coord_conventions: require\n");
339 }
340 fFSInputs.push_back().set(kVec4f_GrSLType, 381 fFSInputs.push_back().set(kVec4f_GrSLType,
341 GrGLShaderVar::kIn_TypeModifier, 382 GrGLShaderVar::kIn_TypeModifier,
342 "gl_FragCoord", 383 "gl_FragCoord",
343 GrGLShaderVar::kDefault_Precision, 384 GrGLShaderVar::kDefault_Precision,
344 GrGLShaderVar::kUpperLeft_Origin); 385 GrGLShaderVar::kUpperLeft_Origin);
345 fSetupFragPosition = true; 386 fSetupFragPosition = true;
346 } 387 }
347 return "gl_FragCoord"; 388 return "gl_FragCoord";
348 } else { 389 } else {
349 static const char* kCoordName = "fragCoordYDown"; 390 static const char* kCoordName = "fragCoordYDown";
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after
446 void GrGLShaderBuilder::appendUniformDecls(ShaderType stype, SkString* out) cons t { 487 void GrGLShaderBuilder::appendUniformDecls(ShaderType stype, SkString* out) cons t {
447 for (int i = 0; i < fUniforms.count(); ++i) { 488 for (int i = 0; i < fUniforms.count(); ++i) {
448 if (fUniforms[i].fVisibility & stype) { 489 if (fUniforms[i].fVisibility & stype) {
449 fUniforms[i].fVariable.appendDecl(fCtxInfo, out); 490 fUniforms[i].fVariable.appendDecl(fCtxInfo, out);
450 out->append(";\n"); 491 out->append(";\n");
451 } 492 }
452 } 493 }
453 } 494 }
454 495
455 void GrGLShaderBuilder::getShader(ShaderType type, SkString* shaderStr) const { 496 void GrGLShaderBuilder::getShader(ShaderType type, SkString* shaderStr) const {
497 const char* version = GrGetGLSLVersionDecl(fCtxInfo.binding(), fCtxInfo.glsl Generation());
498
456 switch (type) { 499 switch (type) {
457 case kVertex_ShaderType: 500 case kVertex_ShaderType:
458 *shaderStr = fHeader; 501 *shaderStr = version;
459 this->appendUniformDecls(kVertex_ShaderType, shaderStr); 502 this->appendUniformDecls(kVertex_ShaderType, shaderStr);
460 this->appendDecls(fVSAttrs, shaderStr); 503 this->appendDecls(fVSAttrs, shaderStr);
461 this->appendDecls(fVSOutputs, shaderStr); 504 this->appendDecls(fVSOutputs, shaderStr);
462 shaderStr->append("void main() {\n"); 505 shaderStr->append("void main() {\n");
463 shaderStr->append(fVSCode); 506 shaderStr->append(fVSCode);
464 shaderStr->append("}\n"); 507 shaderStr->append("}\n");
465 break; 508 break;
466 case kGeometry_ShaderType: 509 case kGeometry_ShaderType:
467 if (fUsesGS) { 510 if (fUsesGS) {
468 *shaderStr = fHeader; 511 *shaderStr = version;
469 shaderStr->append(fGSHeader); 512 shaderStr->append(fGSHeader);
470 this->appendDecls(fGSInputs, shaderStr); 513 this->appendDecls(fGSInputs, shaderStr);
471 this->appendDecls(fGSOutputs, shaderStr); 514 this->appendDecls(fGSOutputs, shaderStr);
472 shaderStr->append("void main() {\n"); 515 shaderStr->append("void main() {\n");
473 shaderStr->append(fGSCode); 516 shaderStr->append(fGSCode);
474 shaderStr->append("}\n"); 517 shaderStr->append("}\n");
475 } else { 518 } else {
476 shaderStr->reset(); 519 shaderStr->reset();
477 } 520 }
478 break; 521 break;
479 case kFragment_ShaderType: 522 case kFragment_ShaderType:
480 *shaderStr = fHeader; 523 *shaderStr = version;
481 append_default_precision_qualifier(kDefaultFragmentPrecision, 524 append_default_precision_qualifier(kDefaultFragmentPrecision,
482 fCtxInfo.binding(), 525 fCtxInfo.binding(),
483 shaderStr); 526 shaderStr);
484 shaderStr->append(fFSHeader); 527 shaderStr->append(fFSHeader);
485 this->appendUniformDecls(kFragment_ShaderType, shaderStr); 528 this->appendUniformDecls(kFragment_ShaderType, shaderStr);
486 this->appendDecls(fFSInputs, shaderStr); 529 this->appendDecls(fFSInputs, shaderStr);
487 // We shouldn't have declared outputs on 1.10 530 // We shouldn't have declared outputs on 1.10
488 GrAssert(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOu tputs.empty()); 531 GrAssert(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOu tputs.empty());
489 this->appendDecls(fFSOutputs, shaderStr); 532 this->appendDecls(fFSOutputs, shaderStr);
490 shaderStr->append(fFSFunctions); 533 shaderStr->append(fFSFunctions);
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
552 for (const AttributePair* attrib = this->getEffectAttributes().begin(); 595 for (const AttributePair* attrib = this->getEffectAttributes().begin();
553 attrib != attribEnd; 596 attrib != attribEnd;
554 ++attrib) { 597 ++attrib) {
555 if (attrib->fIndex == attributeIndex) { 598 if (attrib->fIndex == attributeIndex) {
556 return &attrib->fName; 599 return &attrib->fName;
557 } 600 }
558 } 601 }
559 602
560 return NULL; 603 return NULL;
561 } 604 }
OLDNEW
« no previous file with comments | « src/gpu/gl/GrGLShaderBuilder.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698