src/effects/SkLightingImageFilter.cpp - Issue 23018003: Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

Unified Diff: src/effects/SkLightingImageFilter.cpp

Issue 23018003: Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly Base URL: https://skia.googlecode.com/svn/trunk

Patch Set: Created 7 years, 4 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 side-by-side diff with in-line comments

Download patch

Index: src/effects/SkLightingImageFilter.cpp

diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp

index 7a74f73624bc89411c12d79c8e149417f2e50852..7dcd7297a4deee0225a55761c5f126621ad1d6b4 100644

--- a/src/effects/SkLightingImageFilter.cpp

+++ b/src/effects/SkLightingImageFilter.cpp

@@ -23,9 +23,6 @@

class GrGLDiffuseLightingEffect;

class GrGLSpecularLightingEffect;

-// For brevity

-typedef GrGLUniformManager::UniformHandle UniformHandle;

-static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;

#endif

namespace {

@@ -36,13 +33,13 @@ const SkScalar gOneHalf = SkFloatToScalar(0.5f);

const SkScalar gOneQuarter = SkFloatToScalar(0.25f);

#if SK_SUPPORT_GPU

-void setUniformPoint3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {

+void setUniformPoint3(const GrGLContext& context, GrGLUniform* uni, const SkPoint3& point) {

GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(GrGLfloat));

- uman.set3fv(uni, 0, 1, &point.fX);

+ uni->set3fv(context, 0, 1, &point.fX);

}

-void setUniformNormal3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {

- setUniformPoint3(uman, uni, SkPoint3(point.fX, point.fY, point.fZ));

+void setUniformNormal3(const GrGLContext& context, GrGLUniform* uni, const SkPoint3& point) {

+ setUniformPoint3(context, uni, SkPoint3(point.fX, point.fY, point.fZ));

}

#endif

@@ -419,7 +416,7 @@ public:

* This is called by GrGLLightingEffect::emitCode() before either of the two virtual functions

* below. It adds a vec3f uniform visible in the FS that represents the constant light color.

- void emitLightColorUniform(GrGLShaderBuilder*);

+ GrGLShaderBuilder::Uniform* emitLightColorUniform(GrGLShaderBuilder*);

/**

* These two functions are called from GrGLLightingEffect's emitCode() function.

@@ -430,11 +427,11 @@ public:

* and so this function only needs to be overridden if the light color varies spatially.

virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) = 0;

- virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight);

+ virtual void emitLightColor(GrGLShaderBuilder*, GrGLShaderBuilder::Uniform*, const char *surfaceToLight);

// This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLight must call

// INHERITED::setData().

- virtual void setData(const GrGLUniformManager&,

+ virtual void setData(const GrGLContext&,

const SkLight* light,

const SkIPoint& offset) const;

@@ -443,10 +440,10 @@ protected:

* Gets the constant light color uniform. Subclasses can use this in their emitLightColor

* function.

- UniformHandle lightColorUni() const { return fColorUni; }

+ GrGLUniform* lightColorUni() const { return fColorUni; }

private:

- UniformHandle fColorUni;

+ GrGLUniform* fColorUni;

typedef SkRefCnt INHERITED;

};

@@ -456,14 +453,14 @@ private:

class GrGLDistantLight : public GrGLLight {

public:

virtual ~GrGLDistantLight() {}

- virtual void setData(const GrGLUniformManager&,

+ virtual void setData(const GrGLContext&,

const SkLight* light,

const SkIPoint& offset) const SK_OVERRIDE;

virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;

private:

typedef GrGLLight INHERITED;

- UniformHandle fDirectionUni;

+ GrGLUniform* fDirectionUni;

};

///////////////////////////////////////////////////////////////////////////////

@@ -471,14 +468,14 @@ private:

class GrGLPointLight : public GrGLLight {

public:

virtual ~GrGLPointLight() {}

- virtual void setData(const GrGLUniformManager&,

+ virtual void setData(const GrGLContext&,

const SkLight* light,

const SkIPoint& offset) const SK_OVERRIDE;

virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;

private:

typedef GrGLLight INHERITED;

- UniformHandle fLocationUni;

+ GrGLUniform* fLocationUni;

};

///////////////////////////////////////////////////////////////////////////////

@@ -486,22 +483,22 @@ private:

class GrGLSpotLight : public GrGLLight {

public:

virtual ~GrGLSpotLight() {}

- virtual void setData(const GrGLUniformManager&,

+ virtual void setData(const GrGLContext&,

const SkLight* light,

const SkIPoint& offset) const SK_OVERRIDE;

virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;

- virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight) SK_OVERRIDE;

+ virtual void emitLightColor(GrGLShaderBuilder*, GrGLShaderBuilder::Uniform*, const char *surfaceToLight) SK_OVERRIDE;

private:

typedef GrGLLight INHERITED;

SkString fLightColorFunc;

- UniformHandle fLocationUni;

- UniformHandle fExponentUni;

- UniformHandle fCosOuterConeAngleUni;

- UniformHandle fCosInnerConeAngleUni;

- UniformHandle fConeScaleUni;

- UniformHandle fSUni;

+ GrGLUniform* fLocationUni;

+ GrGLUniform* fExponentUni;

+ GrGLUniform* fCosOuterConeAngleUni;

+ GrGLUniform* fCosInnerConeAngleUni;

+ GrGLUniform* fConeScaleUni;

+ GrGLUniform* fSUni;

};

#else

@@ -1038,7 +1035,7 @@ public:

/**

* Subclasses of GrGLLightingEffect must call INHERITED::setData();

- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;

protected:

virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) = 0;

@@ -1046,8 +1043,8 @@ protected:

private:

typedef GrGLEffect INHERITED;

- UniformHandle fImageIncrementUni;

- UniformHandle fSurfaceScaleUni;

+ GrGLUniform* fImageIncrementUni;

+ GrGLUniform* fSurfaceScaleUni;

GrGLLight* fLight;

GrGLEffectMatrix fEffectMatrix;

};

@@ -1059,12 +1056,12 @@ public:

GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,

const GrDrawEffect& drawEffect);

virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;

- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;

private:

typedef GrGLLightingEffect INHERITED;

- UniformHandle fKDUni;

+ GrGLUniform* fKDUni;

};

///////////////////////////////////////////////////////////////////////////////

@@ -1074,13 +1071,13 @@ public:

GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,

const GrDrawEffect& effect);

virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;

- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;

private:

typedef GrGLLightingEffect INHERITED;

- UniformHandle fKSUni;

- UniformHandle fShininessUni;

+ GrGLUniform* fKSUni;

+ GrGLUniform* fShininessUni;

};

///////////////////////////////////////////////////////////////////////////////

@@ -1150,8 +1147,8 @@ GrEffectRef* GrDiffuseLightingEffect::TestCreate(SkMWCRandom* random,

GrGLLightingEffect::GrGLLightingEffect(const GrBackendEffectFactory& factory,

const GrDrawEffect& drawEffect)

: INHERITED(factory)

- , fImageIncrementUni(kInvalidUniformHandle)

- , fSurfaceScaleUni(kInvalidUniformHandle)

+ , fImageIncrementUni(NULL)

+ , fSurfaceScaleUni(NULL)

, fEffectMatrix(drawEffect.castEffect<GrLightingEffect>().coordsType()) {

const GrLightingEffect& m = drawEffect.castEffect<GrLightingEffect>();

fLight = m.light()->createGLLight();

@@ -1170,13 +1167,16 @@ void GrGLLightingEffect::emitCode(GrGLShaderBuilder* builder,

const char* coords;

fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &coords);

- fImageIncrementUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kVec2f_GrSLType,

- "ImageIncrement");

- fSurfaceScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType,

- "SurfaceScale");

- fLight->emitLightColorUniform(builder);

+ GrGLShaderBuilder::Uniform* imageIncrementUni =

+ builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec2f_GrSLType,

+ "ImageIncrement");

+ fImageIncrementUni = imageIncrementUni->glUniform();

+ GrGLShaderBuilder::Uniform* surfaceScaleUni =

+ builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType, "SurfaceScale");

+ fSurfaceScaleUni = surfaceScaleUni->glUniform();

+ GrGLShaderBuilder::Uniform* lightColorUni = fLight->emitLightColorUniform(builder);

SkString lightFunc;

this->emitLightFunc(builder, &lightFunc);

static const GrGLShaderVar gSobelArgs[] = {

@@ -1233,14 +1233,11 @@ void GrGLLightingEffect::emitCode(GrGLShaderBuilder* builder,

builder->fsCodeAppendf("\t\tvec2 coord = %s;\n", coords);

builder->fsCodeAppend("\t\tfloat m[9];\n");

- const char* imgInc = builder->getUniformCStr(fImageIncrementUni);

- const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni);

int index = 0;

for (int dy = -1; dy <= 1; dy++) {

for (int dx = -1; dx <= 1; dx++) {

SkString texCoords;

- texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc);

+ texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imageIncrementUni->c_str());

builder->fsCodeAppendf("\t\tm[%d] = ", index++);

builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,

samplers[0],

@@ -1250,12 +1247,12 @@ void GrGLLightingEffect::emitCode(GrGLShaderBuilder* builder,

}

builder->fsCodeAppend("\t\tvec3 surfaceToLight = ");

SkString arg;

- arg.appendf("%s * m[4]", surfScale);

+ arg.appendf("%s * m[4]", surfaceScaleUni->c_str());

fLight->emitSurfaceToLight(builder, arg.c_str());

builder->fsCodeAppend(";\n");

builder->fsCodeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ",

- outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale);

- fLight->emitLightColor(builder, "surfaceToLight");

+ outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfaceScaleUni->c_str());

+ fLight->emitLightColor(builder, lightColorUni, "surfaceToLight");

builder->fsCodeAppend(");\n");

SkString modulate;

GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor);

@@ -1274,15 +1271,15 @@ GrGLEffect::EffectKey GrGLLightingEffect::GenKey(const GrDrawEffect& drawEffect,

return key | matrixKey;

}

-void GrGLLightingEffect::setData(const GrGLUniformManager& uman,

+void GrGLLightingEffect::setData(const GrGLContext& context,

const GrDrawEffect& drawEffect) {

const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>();

GrTexture* texture = lighting.texture(0);

float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;

- uman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());

- uman.set1f(fSurfaceScaleUni, lighting.surfaceScale());

- fLight->setData(uman, lighting.light(), lighting.offset());

- fEffectMatrix.setData(uman,

+ fImageIncrementUni->set2f(context, 1.0f / texture->width(), ySign / texture->height());

+ fSurfaceScaleUni->set1f(context, lighting.surfaceScale());

+ fLight->setData(context, lighting.light(), lighting.offset());

+ fEffectMatrix.setData(context,

lighting.getMatrix(),

drawEffect,

lighting.texture(0));

@@ -1295,7 +1292,7 @@ void GrGLLightingEffect::setData(const GrGLUniformManager& uman,

GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,

const GrDrawEffect& drawEffect)

: INHERITED(factory, drawEffect)

- , fKDUni(kInvalidUniformHandle) {

+ , fKDUni(NULL) {

}

void GrGLDiffuseLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkString* funcName) {

@@ -1303,7 +1300,7 @@ void GrGLDiffuseLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStri

fKDUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

kFloat_GrSLType,

"KD",

- &kd);

+ &kd)->glUniform();

static const GrGLShaderVar gLightArgs[] = {

GrGLShaderVar("normal", kVec3f_GrSLType),

@@ -1322,11 +1319,11 @@ void GrGLDiffuseLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStri

funcName);

}

-void GrGLDiffuseLightingEffect::setData(const GrGLUniformManager& uman,

+void GrGLDiffuseLightingEffect::setData(const GrGLContext& context,

const GrDrawEffect& drawEffect) {

- INHERITED::setData(uman, drawEffect);

+ INHERITED::setData(context, drawEffect);

const GrDiffuseLightingEffect& diffuse = drawEffect.castEffect<GrDiffuseLightingEffect>();

- uman.set1f(fKDUni, diffuse.kd());

+ fKDUni->set1f(context, diffuse.kd());

}

///////////////////////////////////////////////////////////////////////////////

@@ -1372,9 +1369,9 @@ GrEffectRef* GrSpecularLightingEffect::TestCreate(SkMWCRandom* random,

GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,

const GrDrawEffect& drawEffect)

- : GrGLLightingEffect(factory, drawEffect)

- , fKSUni(kInvalidUniformHandle)

- , fShininessUni(kInvalidUniformHandle) {

+ : INHERITED(factory, drawEffect)

+ , fKSUni(NULL)

+ , fShininessUni(NULL) {

}

void GrGLSpecularLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkString* funcName) {

@@ -1382,9 +1379,9 @@ void GrGLSpecularLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStr

const char* shininess;

fKSUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "KS", &ks);

+ kFloat_GrSLType, "KS", &ks)->glUniform();

fShininessUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "Shininess", &shininess);

+ kFloat_GrSLType, "Shininess", &shininess)->glUniform();

static const GrGLShaderVar gLightArgs[] = {

GrGLShaderVar("normal", kVec3f_GrSLType),

@@ -1405,101 +1402,106 @@ void GrGLSpecularLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkStr

funcName);

}

-void GrGLSpecularLightingEffect::setData(const GrGLUniformManager& uman,

+void GrGLSpecularLightingEffect::setData(const GrGLContext& context,

const GrDrawEffect& drawEffect) {

- INHERITED::setData(uman, drawEffect);

+ INHERITED::setData(context, drawEffect);

const GrSpecularLightingEffect& spec = drawEffect.castEffect<GrSpecularLightingEffect>();

- uman.set1f(fKSUni, spec.ks());

- uman.set1f(fShininessUni, spec.shininess());

+ fKSUni->set1f(context, spec.ks());

+ fShininessUni->set1f(context, spec.shininess());

}

///////////////////////////////////////////////////////////////////////////////

-void GrGLLight::emitLightColorUniform(GrGLShaderBuilder* builder) {

- fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kVec3f_GrSLType, "LightColor");

+GrGLShaderBuilder::Uniform* GrGLLight::emitLightColorUniform(GrGLShaderBuilder* builder) {

+ GrGLShaderBuilder::Uniform* colorUni =

+ builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

+ kVec3f_GrSLType, "LightColor");

+ fColorUni = colorUni->glUniform();

+ return colorUni;

}

void GrGLLight::emitLightColor(GrGLShaderBuilder* builder,

+ GrGLShaderBuilder::Uniform* colorUni,

const char *surfaceToLight) {

- builder->fsCodeAppend(builder->getUniformCStr(this->lightColorUni()));

+ builder->fsCodeAppend(colorUni->c_str());

}

-void GrGLLight::setData(const GrGLUniformManager& uman,

+void GrGLLight::setData(const GrGLContext& context,

const SkLight* light,

const SkIPoint&) const {

- setUniformPoint3(uman, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255)));

+ setUniformPoint3(context, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255)));

}

///////////////////////////////////////////////////////////////////////////////

-void GrGLDistantLight::setData(const GrGLUniformManager& uman,

+void GrGLDistantLight::setData(const GrGLContext& context,

const SkLight* light,

const SkIPoint& offset) const {

- INHERITED::setData(uman, light, offset);

+ INHERITED::setData(context, light, offset);

SkASSERT(light->type() == SkLight::kDistant_LightType);

const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light);

- setUniformNormal3(uman, fDirectionUni, distantLight->direction());

+ setUniformNormal3(context, fDirectionUni, distantLight->direction());

}

void GrGLDistantLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {

const char* dir;

fDirectionUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec3f_GrSLType,

- "LightDirection", &dir);

+ "LightDirection", &dir)->glUniform();

builder->fsCodeAppend(dir);

}

///////////////////////////////////////////////////////////////////////////////

-void GrGLPointLight::setData(const GrGLUniformManager& uman,

+void GrGLPointLight::setData(const GrGLContext& context,

const SkLight* light,

const SkIPoint& offset) const {

- INHERITED::setData(uman, light, offset);

+ INHERITED::setData(context, light, offset);

SkASSERT(light->type() == SkLight::kPoint_LightType);

const SkPointLight* pointLight = static_cast<const SkPointLight*>(light);

SkPoint3 location = pointLight->location();

location.fX -= offset.fX;

location.fY -= offset.fY;

- setUniformPoint3(uman, fLocationUni, location);

+ setUniformPoint3(context, fLocationUni, location);

}

void GrGLPointLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {

const char* loc;

fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec3f_GrSLType,

- "LightLocation", &loc);

+ "LightLocation", &loc)->glUniform();

builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))", loc, builder->fragmentPosition(), z);

}

///////////////////////////////////////////////////////////////////////////////

-void GrGLSpotLight::setData(const GrGLUniformManager& uman,

+void GrGLSpotLight::setData(const GrGLContext& context,

const SkLight* light,

const SkIPoint& offset) const {

- INHERITED::setData(uman, light, offset);

+ INHERITED::setData(context, light, offset);

SkASSERT(light->type() == SkLight::kSpot_LightType);

const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light);

SkPoint3 location = spotLight->location();

location.fX -= offset.fX;

location.fY -= offset.fY;

- setUniformPoint3(uman, fLocationUni, location);

- uman.set1f(fExponentUni, spotLight->specularExponent());

- uman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle());

- uman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle());

- uman.set1f(fConeScaleUni, spotLight->coneScale());

- setUniformNormal3(uman, fSUni, spotLight->s());

+ setUniformPoint3(context, fLocationUni, location);

+ fExponentUni->set1f(context, spotLight->specularExponent());

+ fCosInnerConeAngleUni->set1f(context, spotLight->cosInnerConeAngle());

+ fCosOuterConeAngleUni->set1f(context, spotLight->cosOuterConeAngle());

+ fConeScaleUni->set1f(context, spotLight->coneScale());

+ setUniformNormal3(context, fSUni, spotLight->s());

}

void GrGLSpotLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {

const char* location;

fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kVec3f_GrSLType, "LightLocation", &location);

+ kVec3f_GrSLType, "LightLocation", &location)->glUniform();

builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))",

location, builder->fragmentPosition(), z);

}

void GrGLSpotLight::emitLightColor(GrGLShaderBuilder* builder,

+ GrGLShaderBuilder::Uniform* lightUni,

const char *surfaceToLight) {

- const char* color = builder->getUniformCStr(this->lightColorUni()); // created by parent class.

+ const char* color = lightUni->c_str(); // created by parent class.

const char* exponent;

const char* cosInner;

@@ -1507,15 +1509,15 @@ void GrGLSpotLight::emitLightColor(GrGLShaderBuilder* builder,

const char* coneScale;

const char* s;

fExponentUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "Exponent", &exponent);

+ kFloat_GrSLType, "Exponent", &exponent)->glUniform();

fCosInnerConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "CosInnerConeAngle", &cosInner);

+ kFloat_GrSLType, "CosInnerConeAngle", &cosInner)->glUniform();

fCosOuterConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "CosOuterConeAngle", &cosOuter);

+ kFloat_GrSLType, "CosOuterConeAngle", &cosOuter)->glUniform();

fConeScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kFloat_GrSLType, "ConeScale", &coneScale);

+ kFloat_GrSLType, "ConeScale", &coneScale)->glUniform();

fSUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,

- kVec3f_GrSLType, "S", &s);

+ kVec3f_GrSLType, "S", &s)->glUniform();

static const GrGLShaderVar gLightColorArgs[] = {

GrGLShaderVar("surfaceToLight", kVec3f_GrSLType)

« no previous file with comments | « src/effects/SkDisplacementMapEffect.cpp ('k') | src/effects/SkMagnifierImageFilter.cpp » ('j') | no next file with comments »