AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Breaking out full program and frag only

Browse Source 
BUG=skia:
R=bsalomon@google.com

Author: joshualitt@chromium.org

Review URL: https://codereview.chromium.org/576543005
This commit is contained in:
joshualitt 2014-09-17 07:00:35 -07:00 committed by Commit bot
parent 963504bd0a
commit 408d6125b3
18 changed files with 321 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gyp/gpu.gypi
View File

@ -257,6 +257,10 @@
'<(skia_src_path)/gpu/gl/builders/GrGLSLPrettyPrint.cpp',
'<(skia_src_path)/gpu/gl/builders/GrGLShaderBuilder.cpp',
'<(skia_src_path)/gpu/gl/builders/GrGLShaderBuilder.h',
'<(skia_src_path)/gpu/gl/builders/GrGLFragmentOnlyProgramBuilder.cpp',
'<(skia_src_path)/gpu/gl/builders/GrGLFragmentOnlyProgramBuilder.h',
'<(skia_src_path)/gpu/gl/builders/GrGLFullProgramBuilder.cpp',
'<(skia_src_path)/gpu/gl/builders/GrGLFullProgramBuilder.h',
'<(skia_src_path)/gpu/gl/builders/GrGLProgramBuilder.cpp',
'<(skia_src_path)/gpu/gl/builders/GrGLProgramBuilder.h',
'<(skia_src_path)/gpu/gl/builders/GrGLShaderStringBuilder.cpp',

2
src/gpu/GrAAConvexPathRenderer.cpp
View File

@ -6,7 +6,6 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrAAConvexPathRenderer.h"
#include "GrContext.h"
@ -19,6 +18,7 @@
#include "SkStrokeRec.h"
#include "SkTraceEvent.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLGeometryProcessor.h"

2
src/gpu/GrAARectRenderer.cpp
View File

@ -5,9 +5,9 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrAARectRenderer.h"
#include "GrGpu.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLGeometryProcessor.h"
#include "GrTBackendEffectFactory.h"

4
src/gpu/GrOvalRenderer.cpp
View File

@ -5,13 +5,13 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrOvalRenderer.h"
#include "GrEffect.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLGeometryProcessor.h"
#include "GrEffect.h"
#include "GrTBackendEffectFactory.h"
#include "GrDrawState.h"

2
src/gpu/effects/GrBezierEffect.cpp
View File

@ -5,9 +5,9 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrBezierEffect.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLGeometryProcessor.h"

2
src/gpu/effects/GrCustomCoordsTextureEffect.cpp
View File

@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrCustomCoordsTextureEffect.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLTexture.h"

2
src/gpu/effects/GrDashingEffect.cpp
View File

@ -5,12 +5,12 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrDashingEffect.h"
#include "../GrAARectRenderer.h"
#include "effects/GrGeometryProcessor.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLGeometryProcessor.h"
#include "gl/GrGLSL.h"

2
src/gpu/effects/GrDistanceFieldTextureEffect.cpp
View File

@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrDistanceFieldTextureEffect.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLTexture.h"

2
src/gpu/gl/GrGLProgram.cpp
View File

@ -6,6 +6,8 @@
*/
#include "GrGLProgram.h"
#include "builders/GrGLFragmentOnlyProgramBuilder.h"
#include "builders/GrGLFullProgramBuilder.h"
#include "GrAllocator.h"
#include "GrEffect.h"
#include "GrCoordTransform.h"

4
src/gpu/gl/GrGLProgramEffects.cpp
View File

@ -5,11 +5,11 @@
* found in the LICENSE file.
*/
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrGLProgramEffects.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLPathRendering.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "gl/builders/GrGLFullProgramBuilder.h"
#include "gl/builders/GrGLFragmentOnlyProgramBuilder.h"
#include "gl/GrGLGeometryProcessor.h"
#include "gl/GrGpuGL.h"

39
src/gpu/gl/builders/GrGLFragmentOnlyProgramBuilder.cpp Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrGLFragmentOnlyProgramBuilder.h"
#include "../GrGpuGL.h"
GrGLFragmentOnlyProgramBuilder::GrGLFragmentOnlyProgramBuilder(GrGpuGL* gpu,
const GrGLProgramDesc& desc)
: INHERITED(gpu, desc) {
SkASSERT(!desc.getHeader().fRequiresVertexShader);
SkASSERT(gpu->glCaps().pathRenderingSupport());
SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
}
int GrGLFragmentOnlyProgramBuilder::addTexCoordSets(int count) {
int firstFreeCoordSet = fTexCoordSetCnt;
fTexCoordSetCnt += count;
SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fTexCoordSetCnt);
return firstFreeCoordSet;
}
GrGLProgramEffects* GrGLFragmentOnlyProgramBuilder::createAndEmitEffects(
const GrEffectStage* effectStages[], int effectCnt,
const GrGLProgramDesc::EffectKeyProvider& keyProvider, GrGLSLExpr4* inOutFSColor) {
GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
effectCnt);
this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
effectStages,
effectCnt,
keyProvider,
inOutFSColor);
return pathTexGenEffectsBuilder.finish();
}

38
src/gpu/gl/builders/GrGLFragmentOnlyProgramBuilder.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLFragmentOnlyProgramBuilder_DEFINED
#define GrGLFragmentOnlyProgramBuilder_DEFINED
#include "GrGLProgramBuilder.h"
class GrGLFragmentOnlyProgramBuilder : public GrGLProgramBuilder {
public:
GrGLFragmentOnlyProgramBuilder(GrGpuGL*, const GrGLProgramDesc&);
int addTexCoordSets(int count);
private:
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) SK_OVERRIDE {}
virtual void emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) SK_OVERRIDE {
SkASSERT(NULL == geometryProcessor);
}
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
virtual void emitCodeAfterEffects() SK_OVERRIDE {}
typedef GrGLProgramBuilder INHERITED;
};
#endif

149
src/gpu/gl/builders/GrGLFullProgramBuilder.cpp Normal file
View File

@ -0,0 +1,149 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrGLFullProgramBuilder.h"
#include "../GrGpuGL.h"
GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu,
const GrGLProgramDesc& desc)
: INHERITED(gpu, desc)
, fGS(this)
, fVS(this) {
}
void GrGLFullProgramBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) {
fVS.emitCodeBeforeEffects(color, coverage);
}
void GrGLFullProgramBuilder::emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) {
if (geometryProcessor) {
GrGLProgramDesc::EffectKeyProvider geometryProcessorKeyProvider(
&this->desc(), GrGLProgramDesc::EffectKeyProvider::kGeometryProcessor_EffectType);
fGeometryProcessor.reset(this->createAndEmitEffect(
geometryProcessor,
geometryProcessorKeyProvider,
coverage));
}
}
void GrGLFullProgramBuilder::emitCodeAfterEffects() {
fVS.emitCodeAfterEffects();
}
void GrGLFullProgramBuilder::addVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName,
GrGLShaderVar::Precision fsPrecision) {
fVS.addVarying(type, name, vsOutName);
SkString* fsInputName = fVS.fOutputs.back().accessName();
#if GR_GL_EXPERIMENTAL_GS
if (desc().getHeader().fExperimentalGS) {
// TODO let the caller use these names
fGS.addVarying(type, fsInputName->c_str(), NULL);
fsInputName = fGS.fOutputs.back().accessName();
}
#endif
fFS.addVarying(type, fsInputName->c_str(), fsInName, fsPrecision);
}
GrGLFullProgramBuilder::VaryingHandle
GrGLFullProgramBuilder::addSeparableVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName) {
addVarying(type, name, vsOutName, fsInName);
SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back();
varying.fVariable = fFS.fInputs.back();
return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos.count() - 1);
}
GrGLProgramEffects* GrGLFullProgramBuilder::createAndEmitEffects(
const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* inOutFSColor) {
GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
effectStages,
effectCnt,
keyProvider,
inOutFSColor);
return programEffectsBuilder.finish();
}
void GrGLFullProgramBuilder::createAndEmitEffect(GrGLProgramEffectsBuilder* programEffectsBuilder,
const GrEffectStage* effectStages,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* fsInOutColor) {
GrGLSLExpr4 inColor = *fsInOutColor;
GrGLSLExpr4 outColor;
SkASSERT(effectStages && effectStages->getEffect());
const GrEffectStage& stage = *effectStages;
// Using scope to force ASR destructor to be triggered
{
CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
if (inColor.isZeros()) {
SkString inColorName;
// Effects have no way to communicate zeros, they treat an empty string as ones.
this->nameVariable(&inColorName, '\0', "input");
fFS.codeAppendf("vec4 %s = %s;", inColorName.c_str(), inColor.c_str());
inColor = inColorName;
}
// create var to hold stage result
SkString outColorName;
this->nameVariable(&outColorName, '\0', "output");
fFS.codeAppendf("vec4 %s;", outColorName.c_str());
outColor = outColorName;
programEffectsBuilder->emitEffect(stage,
keyProvider.get(0),
outColor.c_str(),
inColor.isOnes() ? NULL : inColor.c_str(),
fCodeStage.stageIndex());
}
*fsInOutColor = outColor;
}
GrGLProgramEffects* GrGLFullProgramBuilder::createAndEmitEffect(
const GrEffectStage* geometryProcessor,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* inOutFSColor) {
GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, 1);
this->createAndEmitEffect(&programEffectsBuilder, geometryProcessor, keyProvider, inOutFSColor);
return programEffectsBuilder.finish();
}
bool GrGLFullProgramBuilder::compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const {
return INHERITED::compileAndAttachShaders(programId, shaderIds)
&& fVS.compileAndAttachShaders(programId, shaderIds)
#if GR_GL_EXPERIMENTAL_GS
&& (!desc().getHeader().fExperimentalGS
|| fGS.compileAndAttachShaders(programId, shaderIds))
#endif
;
}
void GrGLFullProgramBuilder::bindProgramLocations(GrGLuint programId) {
fVS.bindProgramLocations(programId);
INHERITED::bindProgramLocations(programId);
}

77
src/gpu/gl/builders/GrGLFullProgramBuilder.h Normal file
View File

@ -0,0 +1,77 @@
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLFullProgramBuilder_DEFINED
#define GrGLFullProgramBuilder_DEFINED
#include "GrGLProgramBuilder.h"
class GrGLFullProgramBuilder : public GrGLProgramBuilder {
public:
GrGLFullProgramBuilder(GrGpuGL*, const GrGLProgramDesc&);
/** Add a varying variable to the current program to pass values between vertex and fragment
shaders. If the last two parameters are non-NULL, they are filled in with the name
generated. */
void addVarying(GrSLType type,
const char* name,
const char** vsOutName = NULL,
const char** fsInName = NULL,
GrGLShaderVar::Precision fsPrecision=GrGLShaderVar::kDefault_Precision);
/** Add a separable varying input variable to the current program.
* A separable varying (fragment shader input) is a varying that can be used also when vertex
* shaders are not used. With a vertex shader, the operation is same as with other
* varyings. Without a vertex shader, such as with NV_path_rendering, GL APIs are used to
* populate the variable. The APIs can refer to the variable through the returned handle.
*/
VaryingHandle addSeparableVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName);
GrGLVertexShaderBuilder* getVertexShaderBuilder() { return &fVS; }
private:
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) SK_OVERRIDE;
virtual void emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) SK_OVERRIDE;
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
/*
* These functions are temporary and will eventually operate not on effects but on
* geometry processors
*/
void createAndEmitEffect(GrGLProgramEffectsBuilder*,
const GrEffectStage* effectStage,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor);
GrGLProgramEffects* createAndEmitEffect(const GrEffectStage* geometryProcessor,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor);
virtual void emitCodeAfterEffects() SK_OVERRIDE;
virtual bool compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
virtual void bindProgramLocations(GrGLuint programId) SK_OVERRIDE;
GrGLGeometryShaderBuilder fGS;
GrGLVertexShaderBuilder fVS;
typedef GrGLProgramBuilder INHERITED;
};
#endif

174
src/gpu/gl/builders/GrGLProgramBuilder.cpp
View File

@ -326,177 +326,3 @@ void GrGLProgramBuilder::resolveProgramLocations(GrGLuint programId) {
const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
return fGpu->ctxInfo();
}
////////////////////////////////////////////////////////////////////////////////
GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu,
const GrGLProgramDesc& desc)
: INHERITED(gpu, desc)
, fGS(this)
, fVS(this) {
}
void GrGLFullProgramBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) {
fVS.emitCodeBeforeEffects(color, coverage);
}
void GrGLFullProgramBuilder::emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) {
if (geometryProcessor) {
GrGLProgramDesc::EffectKeyProvider geometryProcessorKeyProvider(
&this->desc(), GrGLProgramDesc::EffectKeyProvider::kGeometryProcessor_EffectType);
fGeometryProcessor.reset(this->createAndEmitEffect(
geometryProcessor,
geometryProcessorKeyProvider,
coverage));
}
}
void GrGLFullProgramBuilder::emitCodeAfterEffects() {
fVS.emitCodeAfterEffects();
}
void GrGLFullProgramBuilder::addVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName,
GrGLShaderVar::Precision fsPrecision) {
fVS.addVarying(type, name, vsOutName);
SkString* fsInputName = fVS.fOutputs.back().accessName();
#if GR_GL_EXPERIMENTAL_GS
if (desc().getHeader().fExperimentalGS) {
// TODO let the caller use these names
fGS.addVarying(type, fsInputName->c_str(), NULL);
fsInputName = fGS.fOutputs.back().accessName();
}
#endif
fFS.addVarying(type, fsInputName->c_str(), fsInName, fsPrecision);
}
GrGLFullProgramBuilder::VaryingHandle
GrGLFullProgramBuilder::addSeparableVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName) {
addVarying(type, name, vsOutName, fsInName);
SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back();
varying.fVariable = fFS.fInputs.back();
return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos.count() - 1);
}
GrGLProgramEffects* GrGLFullProgramBuilder::createAndEmitEffects(
const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* inOutFSColor) {
GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
effectStages,
effectCnt,
keyProvider,
inOutFSColor);
return programEffectsBuilder.finish();
}
void GrGLFullProgramBuilder::createAndEmitEffect(GrGLProgramEffectsBuilder* programEffectsBuilder,
const GrEffectStage* effectStages,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* fsInOutColor) {
GrGLSLExpr4 inColor = *fsInOutColor;
GrGLSLExpr4 outColor;
SkASSERT(effectStages && effectStages->getEffect());
const GrEffectStage& stage = *effectStages;
// Using scope to force ASR destructor to be triggered
{
CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
if (inColor.isZeros()) {
SkString inColorName;
// Effects have no way to communicate zeros, they treat an empty string as ones.
this->nameVariable(&inColorName, '\0', "input");
fFS.codeAppendf("vec4 %s = %s;", inColorName.c_str(), inColor.c_str());
inColor = inColorName;
}
// create var to hold stage result
SkString outColorName;
this->nameVariable(&outColorName, '\0', "output");
fFS.codeAppendf("vec4 %s;", outColorName.c_str());
outColor = outColorName;
programEffectsBuilder->emitEffect(stage,
keyProvider.get(0),
outColor.c_str(),
inColor.isOnes() ? NULL : inColor.c_str(),
fCodeStage.stageIndex());
}
*fsInOutColor = outColor;
}
GrGLProgramEffects* GrGLFullProgramBuilder::createAndEmitEffect(
const GrEffectStage* geometryProcessor,
const GrGLProgramDesc::EffectKeyProvider& keyProvider,
GrGLSLExpr4* inOutFSColor) {
GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, 1);
this->createAndEmitEffect(&programEffectsBuilder, geometryProcessor, keyProvider, inOutFSColor);
return programEffectsBuilder.finish();
}
bool GrGLFullProgramBuilder::compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const {
return INHERITED::compileAndAttachShaders(programId, shaderIds)
&& fVS.compileAndAttachShaders(programId, shaderIds)
#if GR_GL_EXPERIMENTAL_GS
&& (!desc().getHeader().fExperimentalGS
|| fGS.compileAndAttachShaders(programId, shaderIds))
#endif
;
}
void GrGLFullProgramBuilder::bindProgramLocations(GrGLuint programId) {
fVS.bindProgramLocations(programId);
INHERITED::bindProgramLocations(programId);
}
////////////////////////////////////////////////////////////////////////////////
GrGLFragmentOnlyProgramBuilder::GrGLFragmentOnlyProgramBuilder(GrGpuGL* gpu,
const GrGLProgramDesc& desc)
: INHERITED(gpu, desc) {
SkASSERT(!desc.getHeader().fRequiresVertexShader);
SkASSERT(gpu->glCaps().pathRenderingSupport());
SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
}
int GrGLFragmentOnlyProgramBuilder::addTexCoordSets(int count) {
int firstFreeCoordSet = fTexCoordSetCnt;
fTexCoordSetCnt += count;
SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fTexCoordSetCnt);
return firstFreeCoordSet;
}
GrGLProgramEffects* GrGLFragmentOnlyProgramBuilder::createAndEmitEffects(
const GrEffectStage* effectStages[], int effectCnt,
const GrGLProgramDesc::EffectKeyProvider& keyProvider, GrGLSLExpr4* inOutFSColor) {
GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
effectCnt);
this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
effectStages,
effectCnt,
keyProvider,
inOutFSColor);
return pathTexGenEffectsBuilder.finish();
}

93
src/gpu/gl/builders/GrGLProgramBuilder.h
View File

@ -281,97 +281,4 @@ private:
friend class GrGLGeometryShaderBuilder;
};
////////////////////////////////////////////////////////////////////////////////
class GrGLFullProgramBuilder : public GrGLProgramBuilder {
public:
GrGLFullProgramBuilder(GrGpuGL*, const GrGLProgramDesc&);
/** Add a varying variable to the current program to pass values between vertex and fragment
shaders. If the last two parameters are non-NULL, they are filled in with the name
generated. */
void addVarying(GrSLType type,
const char* name,
const char** vsOutName = NULL,
const char** fsInName = NULL,
GrGLShaderVar::Precision fsPrecision=GrGLShaderVar::kDefault_Precision);
/** Add a separable varying input variable to the current program.
* A separable varying (fragment shader input) is a varying that can be used also when vertex
* shaders are not used. With a vertex shader, the operation is same as with other
* varyings. Without a vertex shader, such as with NV_path_rendering, GL APIs are used to
* populate the variable. The APIs can refer to the variable through the returned handle.
*/
VaryingHandle addSeparableVarying(GrSLType type,
const char* name,
const char** vsOutName,
const char** fsInName);
GrGLVertexShaderBuilder* getVertexShaderBuilder() { return &fVS; }
private:
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) SK_OVERRIDE;
virtual void emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) SK_OVERRIDE;
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
/*
* These functions are temporary and will eventually operate not on effects but on
* geometry processors
*/
void createAndEmitEffect(GrGLProgramEffectsBuilder*,
const GrEffectStage* effectStage,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor);
GrGLProgramEffects* createAndEmitEffect(const GrEffectStage* geometryProcessor,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor);
virtual void emitCodeAfterEffects() SK_OVERRIDE;
virtual bool compileAndAttachShaders(GrGLuint programId,
SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
virtual void bindProgramLocations(GrGLuint programId) SK_OVERRIDE;
GrGLGeometryShaderBuilder fGS;
GrGLVertexShaderBuilder fVS;
typedef GrGLProgramBuilder INHERITED;
};
////////////////////////////////////////////////////////////////////////////////
class GrGLFragmentOnlyProgramBuilder : public GrGLProgramBuilder {
public:
GrGLFragmentOnlyProgramBuilder(GrGpuGL*, const GrGLProgramDesc&);
int addTexCoordSets(int count);
private:
virtual void emitCodeBeforeEffects(GrGLSLExpr4* color,
GrGLSLExpr4* coverage) SK_OVERRIDE {}
virtual void emitGeometryProcessor(const GrEffectStage* geometryProcessor,
GrGLSLExpr4* coverage) SK_OVERRIDE {
SkASSERT(NULL == geometryProcessor);
}
virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
int effectCnt,
const GrGLProgramDesc::EffectKeyProvider&,
GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
virtual void emitCodeAfterEffects() SK_OVERRIDE {}
typedef GrGLProgramBuilder INHERITED;
};
#endif

1
src/gpu/gl/builders/GrGLShaderBuilder.cpp
View File

@ -6,6 +6,7 @@
*/
#include "GrGLShaderBuilder.h"
#include "GrGLFullProgramBuilder.h"
#include "GrGLProgramBuilder.h"
#include "../GrGpuGL.h"
#include "../GrGLShaderVar.h"

2
src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
View File

@ -6,7 +6,7 @@
*/
#include "GrGLVertexShaderBuilder.h"
#include "GrGLProgramBuilder.h"
#include "GrGLFullProgramBuilder.h"
#include "GrGLShaderStringBuilder.h"
#include "../GrGpuGL.h"
#include "../../GrOptDrawState.h"