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

Update SkLightingShader to support rotation

Browse Source 
This also:
makes the SkLightingShader handle normal maps where the rects aren't aligned between the diffuse and normal maps.

adds a light aggregating class (Lights) to SkLightingShader (along with a Builder nested class).

Split out of https://codereview.chromium.org/1261433009/ (Add SkCanvas::drawLitAtlas call)

Committed: https://skia.googlesource.com/skia/+/45b59ed6e4e231814dbdb9f707b3d2a7ee50de84

Review URL: https://codereview.chromium.org/1291783003
This commit is contained in:
robertphillips 2015-08-20 05:15:06 -07:00 committed by Commit bot
parent d1c6b7c500
commit 2f0dbc761a
15 changed files with 615 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
gm/lightingshader.cpp
View File

@ -19,7 +19,7 @@ static SkBitmap make_checkerboard(int texSize) {
sk_tool_utils::draw_checkerboard(&canvas,
sk_tool_utils::color_to_565(0x0),
sk_tool_utils::color_to_565(0xFF804020),
2);
8);
return bitmap;
}
@ -58,10 +58,13 @@ public:
LightingShaderGM() {
this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
fLight.fColor = SkColor3f::Make(1.0f, 1.0f, 1.0f);
fLight.fDirection = SkVector3::Make(0.0f, 0.0f, 1.0f);
SkLightingShader::Lights::Builder builder;
fAmbient = SkColor3f::Make(0.1f, 0.1f, 0.1f);
builder.add(SkLight(SkColor3f::Make(1.0f, 1.0f, 1.0f),
SkVector3::Make(1.0f, 0.0f, 0.0f)));
builder.add(SkLight(SkColor3f::Make(0.2f, 0.2f, 0.2f)));
fLights.reset(builder.finish());
}
protected:
@ -98,11 +101,16 @@ protected:
SkMatrix matrix;
matrix.setRectToRect(bitmapBounds, r, SkMatrix::kFill_ScaleToFit);
const SkMatrix& ctm = canvas->getTotalMatrix();
// TODO: correctly pull out the pure rotation
SkVector invNormRotation = { ctm[SkMatrix::kMScaleX], ctm[SkMatrix::kMSkewY] };
SkAutoTUnref<SkShader> fShader(SkLightingShader::Create(
fDiffuse,
fNormalMaps[mapType],
fLight, fAmbient,
&matrix));
fLights,
invNormRotation, &matrix, &matrix));
SkPaint paint;
paint.setShader(fShader);
@ -111,17 +119,56 @@ protected:
}
void onDraw(SkCanvas* canvas) override {
SkRect r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
this->drawRect(canvas, r, kHemi_NormalMap);
SkMatrix m;
SkRect r;
r.offset(kGMSize - kTexSize, 0);
this->drawRect(canvas, r, kFrustum_NormalMap);
{
r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
this->drawRect(canvas, r, kHemi_NormalMap);
r.offset(0, kGMSize - kTexSize);
this->drawRect(canvas, r, kTetra_NormalMap);
canvas->save();
m.setRotate(45.0f, r.centerX(), r.centerY());
m.postTranslate(kGMSize/2.0f - kTexSize/2.0f, 0.0f);
canvas->setMatrix(m);
this->drawRect(canvas, r, kHemi_NormalMap);
canvas->restore();
}
r.offset(kTexSize - kGMSize, 0);
this->drawRect(canvas, r, kHemi_NormalMap);
{
r.offset(kGMSize - kTexSize, 0);
this->drawRect(canvas, r, kFrustum_NormalMap);
canvas->save();
m.setRotate(45.0f, r.centerX(), r.centerY());
m.postTranslate(0.0f, kGMSize/2.0f - kTexSize/2.0f);
canvas->setMatrix(m);
this->drawRect(canvas, r, kFrustum_NormalMap);
canvas->restore();
}
{
r.offset(0, kGMSize - kTexSize);
this->drawRect(canvas, r, kTetra_NormalMap);
canvas->save();
m.setRotate(45.0f, r.centerX(), r.centerY());
m.postTranslate(-kGMSize/2.0f + kTexSize/2.0f, 0.0f);
canvas->setMatrix(m);
this->drawRect(canvas, r, kTetra_NormalMap);
canvas->restore();
}
{
r.offset(kTexSize - kGMSize, 0);
this->drawRect(canvas, r, kHemi_NormalMap);
canvas->save();
m.setRotate(45.0f, r.centerX(), r.centerY());
m.postTranslate(0.0f, -kGMSize/2.0f + kTexSize/2.0f);
canvas->setMatrix(m);
this->drawRect(canvas, r, kHemi_NormalMap);
canvas->restore();
}
}
private:
@ -131,8 +178,7 @@ private:
SkBitmap fDiffuse;
SkBitmap fNormalMaps[kNormalMapCount];
SkLightingShader::Light fLight;
SkColor3f fAmbient;
SkAutoTUnref<const SkLightingShader::Lights> fLights;
typedef GM INHERITED;
};

8
gyp/SampleApp.gyp
View File

@ -84,7 +84,7 @@
'../samplecode/SampleLayerMask.cpp',
'../samplecode/SampleLayers.cpp',
'../samplecode/SampleLCD.cpp',
'../samplecode/SampleLighting.cpp',
'../samplecode/SampleLighting.cpp',
'../samplecode/SampleLines.cpp',
'../samplecode/SampleLua.cpp',
'../samplecode/SampleManyRects.cpp',
@ -245,9 +245,9 @@
'android_deps.gyp:Android_SampleApp',
],
}],
[ 'skia_os == "chromeos"', {
'sources!': [
'../samplecode/SampleLighting.cpp', #doesn't compile due to gpu dependencies
[ 'skia_os == "chromeos"', {
'sources!': [
'../samplecode/SampleLighting.cpp', #doesn't compile due to gpu dependencies
],
}],
[ 'skia_gpu == 1', {

7
gyp/core.gypi
View File

@ -117,8 +117,11 @@
'<(skia_src_path)/core/SkImageCacherator.cpp',
'<(skia_src_path)/core/SkImageGenerator.cpp',
'<(skia_src_path)/core/SkLayerInfo.h',
'<(skia_src_path)/core/SkLocalMatrixShader.cpp',
'<(skia_src_path)/core/SkLight.h',
'<(skia_src_path)/core/SkLightingShader.h',
'<(skia_src_path)/core/SkLightingShader.cpp',
'<(skia_src_path)/core/SkLineClipper.cpp',
'<(skia_src_path)/core/SkLocalMatrixShader.cpp',
'<(skia_src_path)/core/SkMallocPixelRef.cpp',
'<(skia_src_path)/core/SkMask.cpp',
'<(skia_src_path)/core/SkMaskCache.cpp',
@ -162,6 +165,7 @@
'<(skia_src_path)/core/SkPixelRef.cpp',
'<(skia_src_path)/core/SkPixmap.cpp',
'<(skia_src_path)/core/SkPoint.cpp',
'<(skia_src_path)/core/SkPoint3.cpp',
'<(skia_src_path)/core/SkPtrRecorder.cpp',
'<(skia_src_path)/core/SkQuadClipper.cpp',
'<(skia_src_path)/core/SkQuadClipper.h',
@ -305,6 +309,7 @@
'<(skia_include_path)/core/SkPictureRecorder.h',
'<(skia_include_path)/core/SkPixelRef.h',
'<(skia_include_path)/core/SkPoint.h',
'<(skia_include_path)/core/SkPoint3.h',
'<(skia_include_path)/core/SkPreConfig.h',
'<(skia_include_path)/core/SkRasterizer.h',
'<(skia_include_path)/core/SkRect.h',

4
gyp/effects.gypi
View File

@ -45,8 +45,6 @@
'<(skia_src_path)/effects/SkLayerRasterizer.cpp',
'<(skia_src_path)/effects/SkLerpXfermode.cpp',
'<(skia_src_path)/effects/SkLightingImageFilter.cpp',
'<(skia_src_path)/effects/SkLightingShader.h',
'<(skia_src_path)/effects/SkLightingShader.cpp',
'<(skia_src_path)/effects/SkLumaColorFilter.cpp',
'<(skia_src_path)/effects/SkMagnifierImageFilter.cpp',
'<(skia_src_path)/effects/SkMatrixConvolutionImageFilter.cpp',
@ -57,7 +55,6 @@
'<(skia_src_path)/effects/SkPerlinNoiseShader.cpp',
'<(skia_src_path)/effects/SkPictureImageFilter.cpp',
'<(skia_src_path)/effects/SkPixelXorXfermode.cpp',
'<(skia_src_path)/effects/SkPoint3.cpp',
'<(skia_src_path)/effects/SkRectShaderImageFilter.cpp',
'<(skia_src_path)/effects/SkTableColorFilter.cpp',
'<(skia_src_path)/effects/SkTableMaskFilter.cpp',
@ -114,7 +111,6 @@
'<(skia_include_path)/effects/SkPaintFlagsDrawFilter.h',
'<(skia_include_path)/effects/SkPerlinNoiseShader.h',
'<(skia_include_path)/effects/SkPixelXorXfermode.h',
'<(skia_include_path)/effects/SkPoint3.h',
'<(skia_include_path)/effects/SkRectShaderImageFilter.h',
'<(skia_include_path)/effects/SkTableColorFilter.h',
'<(skia_include_path)/effects/SkTableMaskFilter.h',

1
gyp/tools.gyp
View File

@ -101,6 +101,7 @@
],
'include_dirs': [
'../src/fonts',
'../src/core',
],
'dependencies': [
'resources',

16
include/effects/SkPoint3.h → include/core/SkPoint3.h
View File

@ -91,6 +91,22 @@ struct SK_API SkPoint3 {
return v;
}
/** Add v's coordinates to the point's
*/
void operator+=(const SkPoint3& v) {
fX += v.fX;
fY += v.fY;
fZ += v.fZ;
}
/** Subtract v's coordinates from the point's
*/
void operator-=(const SkPoint3& v) {
fX -= v.fX;
fY -= v.fY;
fZ -= v.fZ;
}
/** Returns the dot product of a and b, treating them as 3D vectors
*/
static SkScalar DotProduct(const SkPoint3& a, const SkPoint3& b) {

8
include/effects/SkLightingImageFilter.h
View File

@ -12,7 +12,7 @@
#include "SkColor.h"
class SkLight;
class SkImageFilterLight;
struct SkPoint3;
class SK_API SkLightingImageFilter : public SkImageFilter {
@ -42,17 +42,17 @@ public:
SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
protected:
SkLightingImageFilter(SkLight* light,
SkLightingImageFilter(SkImageFilterLight* light,
SkScalar surfaceScale,
SkImageFilter* input,
const CropRect* cropRect);
void flatten(SkWriteBuffer&) const override;
const SkLight* light() const { return fLight.get(); }
const SkImageFilterLight* light() const { return fLight.get(); }
SkScalar surfaceScale() const { return fSurfaceScale; }
private:
typedef SkImageFilter INHERITED;
SkAutoTUnref<SkLight> fLight;
SkAutoTUnref<SkImageFilterLight> fLight;
SkScalar fSurfaceScale;
};

37
samplecode/SampleLighting.cpp
View File

@ -11,6 +11,21 @@
#include "SkCanvas.h"
#include "SkImageDecoder.h"
#include "SkLightingShader.h"
#include "SkPoint3.h"
static const SkLightingShader::Lights* create_lights(SkScalar angle, SkScalar blue) {
const SkVector3 dir = SkVector3::Make(SkScalarSin(angle)*SkScalarSin(SK_ScalarPI*0.25f),
SkScalarCos(angle)*SkScalarSin(SK_ScalarPI*0.25f),
SkScalarCos(SK_ScalarPI*0.25f));
SkLightingShader::Lights::Builder builder;
builder.add(SkLight(SkColor3f::Make(1.0f, 1.0f, blue), dir));
builder.add(SkLight(SkColor3f::Make(0.1f, 0.1f, 0.1f)));
return builder.finish();
}
////////////////////////////////////////////////////////////////////////////
@ -21,7 +36,6 @@ public:
SkBitmap fNormalBitmap;
SkScalar fLightAngle;
SkScalar fColorFactor;
SkColor3f fAmbientColor;
LightingView() {
SkString diffusePath = GetResourcePath("brickwork-texture.jpg");
@ -32,16 +46,11 @@ public:
fLightAngle = 0.0f;
fColorFactor = 0.0f;
SkLightingShader::Light light;
light.fColor = SkColor3f::Make(1.0f, 1.0f, 1.0f);
light.fDirection.fX = SkScalarSin(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fY = SkScalarCos(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fZ = SkScalarCos(SK_ScalarPI*0.25f);
fAmbientColor = SkColor3f::Make(0.1f, 0.1f, 0.1f);
SkAutoTUnref<const SkLightingShader::Lights> lights(create_lights(fLightAngle, 1.0f));
fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
light, fAmbientColor, nullptr));
lights, SkVector::Make(1.0f, 0.0f),
nullptr, nullptr));
}
virtual ~LightingView() {}
@ -63,14 +72,12 @@ protected:
fColorFactor = 0.0f;
}
SkLightingShader::Light light;
light.fColor = SkColor3f::Make(1.0f, 1.0f, fColorFactor);
light.fDirection.fX = SkScalarSin(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fY = SkScalarCos(fLightAngle)*SkScalarSin(SK_ScalarPI*0.25f);
light.fDirection.fZ = SkScalarCos(SK_ScalarPI*0.25f);
SkAutoTUnref<const SkLightingShader::Lights> lights(create_lights(fLightAngle,
fColorFactor));
fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
light, fAmbientColor, nullptr));
lights, SkVector::Make(1.0f, 0.0f),
nullptr, nullptr));
SkPaint paint;
paint.setShader(fShader);

56
src/core/SkLight.h Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkLight_DEFINED
#define SkLight_DEFINED
#include "SkPoint3.h"
class SK_API SkLight {
public:
enum LightType {
kAmbient_LightType, // only 'fColor' is used
kDirectional_LightType
};
SkLight() : fType(kAmbient_LightType) {
fColor.set(0.0f, 0.0f, 0.0f);
fDirection.set(0.0f, 0.0f, 1.0f);
}
SkLight(const SkColor3f& color)
: fType(kAmbient_LightType)
, fColor(color) {
fDirection.set(0.0f, 0.0f, 1.0f);
}
SkLight(const SkColor3f& color, const SkVector3& dir)
: fType(kDirectional_LightType)
, fColor(color)
, fDirection(dir) {
if (!fDirection.normalize()) {
fDirection.set(0.0f, 0.0f, 1.0f);
}
}
LightType type() const { return fType; }
const SkColor3f& color() const { return fColor; }
const SkVector3& dir() const {
SkASSERT(kAmbient_LightType != fType);
return fDirection;
}
private:
LightType fType;
SkColor3f fColor; // linear (unpremul) color. Range is 0..1 in each channel.
SkVector3 fDirection; // direction towards the light (+Z is out of the screen).
// If degenerate, it will be replaced with (0, 0, 1).
};
#endif

424
src/effects/SkLightingShader.cpp → src/core/SkLightingShader.cpp
View File

@ -12,6 +12,7 @@
#include "SkErrorInternals.h"
#include "SkLightingShader.h"
#include "SkMathPriv.h"
#include "SkPoint3.h"
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
@ -40,24 +41,33 @@
class SK_API SkLightingShaderImpl : public SkShader {
public:
/** Create a new lighting shader that use the provided normal map, light
and ambient color to light the diffuse bitmap.
@param diffuse the diffuse bitmap
@param normal the normal map
@param light the light applied to the normal map
@param ambient the linear (unpremul) ambient light color
/** Create a new lighting shader that uses the provided normal map and
lights to light the diffuse bitmap.
@param diffuse the diffuse bitmap
@param normal the normal map
@param lights the lights applied to the normal map
@param invNormRotation rotation applied to the normal map's normals
@param diffLocalM the local matrix for the diffuse coordinates
@param normLocalM the local matrix for the normal coordinates
*/
SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
const SkLightingShader::Light& light,
const SkColor3f& ambient, const SkMatrix* localMatrix)
: INHERITED(localMatrix)
const SkLightingShader::Lights* lights,
const SkVector& invNormRotation,
const SkMatrix* diffLocalM, const SkMatrix* normLocalM)
: INHERITED(diffLocalM)
, fDiffuseMap(diffuse)
, fNormalMap(normal)
, fLight(light)
, fAmbientColor(ambient) {
if (!fLight.fDirection.normalize()) {
fLight.fDirection = SkPoint3::Make(0.0f, 0.0f, 1.0f);
, fLights(SkRef(lights))
, fInvNormRotation(invNormRotation) {
if (normLocalM) {
fNormLocalMatrix = *normLocalM;
} else {
fNormLocalMatrix.reset();
}
// Pre-cache so future calls to fNormLocalMatrix.getType() are threadsafe.
(void)fNormLocalMatrix.getType();
}
bool isOpaque() const override;
@ -94,12 +104,16 @@ public:
protected:
void flatten(SkWriteBuffer&) const override;
Context* onCreateContext(const ContextRec&, void*) const override;
bool computeNormTotalInverse(const ContextRec& rec, SkMatrix* normTotalInverse) const;
private:
SkBitmap fDiffuseMap;
SkBitmap fNormalMap;
SkLightingShader::Light fLight;
SkColor3f fAmbientColor; // linear (unpremul) color. Range is 0..1/channel.
SkBitmap fDiffuseMap;
SkBitmap fNormalMap;
SkAutoTUnref<const SkLightingShader::Lights> fLights;
SkMatrix fNormLocalMatrix;
SkVector fInvNormRotation;
friend class SkLightingShader;
@ -119,19 +133,32 @@ private:
class LightingFP : public GrFragmentProcessor {
public:
LightingFP(GrTexture* diffuse, GrTexture* normal, const SkMatrix& matrix,
const SkVector3& lightDir, const SkColor3f& lightColor,
const SkColor3f& ambientColor)
: fDeviceTransform(kDevice_GrCoordSet, matrix)
, fDiffuseTextureAccess(diffuse)
, fNormalTextureAccess(normal)
, fLightDir(lightDir)
, fLightColor(lightColor)
, fAmbientColor(ambientColor) {
this->addCoordTransform(&fDeviceTransform);
LightingFP(GrProcessorDataManager* pdm, GrTexture* diffuse, GrTexture* normal,
const SkMatrix& diffMatrix, const SkMatrix& normMatrix,
const GrTextureParams& diffParams, const GrTextureParams& normParams,
const SkLightingShader::Lights* lights, const SkVector& invNormRotation)
: fDiffDeviceTransform(kLocal_GrCoordSet, diffMatrix, diffuse, diffParams.filterMode())
, fNormDeviceTransform(kLocal_GrCoordSet, normMatrix, normal, normParams.filterMode())
, fDiffuseTextureAccess(diffuse, diffParams)
, fNormalTextureAccess(normal, normParams)
, fInvNormRotation(invNormRotation) {
this->addCoordTransform(&fDiffDeviceTransform);
this->addCoordTransform(&fNormDeviceTransform);
this->addTextureAccess(&fDiffuseTextureAccess);
this->addTextureAccess(&fNormalTextureAccess);
// fuse all ambient lights into a single one
fAmbientColor.set(0.0f, 0.0f, 0.0f);
for (int i = 0; i < lights->numLights(); ++i) {
if (SkLight::kAmbient_LightType == lights->light(i).type()) {
fAmbientColor += lights->light(i).color();
} else {
// TODO: handle more than one of these
fLightColor = lights->light(i).color();
fLightDir = lights->light(i).dir();
}
}
this->initClassID<LightingFP>();
}
@ -141,6 +168,7 @@ public:
fLightDir.fX = 10000.0f;
fLightColor.fX = 0.0f;
fAmbientColor.fX = 0.0f;
fInvNormRotation.fX = 0.0f;
}
void emitCode(EmitArgs& args) override {
@ -163,6 +191,11 @@ public:
kVec3f_GrSLType, kDefault_GrSLPrecision,
"AmbientColor", &ambientColorUniName);
const char* xformUniName = NULL;
fXformUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, kDefault_GrSLPrecision,
"Xform", &xformUniName);
fpb->codeAppend("vec4 diffuseColor = ");
fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0],
args.fCoords[0].c_str(),
@ -171,13 +204,20 @@ public:
fpb->codeAppend("vec4 normalColor = ");
fpb->appendTextureLookup(args.fSamplers[1],
args.fCoords[0].c_str(),
args.fCoords[0].getType());
args.fCoords[1].c_str(),
args.fCoords[1].getType());
fpb->codeAppend(";");
fpb->codeAppend("vec3 normal = normalize(normalColor.rgb - vec3(0.5));");
fpb->codeAppendf("vec3 lightDir = normalize(%s);", lightDirUniName);
fpb->codeAppend("float NdotL = dot(normal, lightDir);");
fpb->codeAppend("vec3 normal = normalColor.rgb - vec3(0.5);");
fpb->codeAppendf("mat3 m = mat3(%s.x, -%s.y, 0.0, %s.y, %s.x, 0.0, 0.0, 0.0, 1.0);",
xformUniName, xformUniName, xformUniName, xformUniName);
// TODO: inverse map the light direction vectors in the vertex shader rather than
// transforming all the normals here!
fpb->codeAppend("normal = normalize(m*normal);");
fpb->codeAppendf("float NdotL = clamp(dot(normal, %s), 0.0, 1.0);", lightDirUniName);
// diffuse light
fpb->codeAppendf("vec3 result = %s*diffuseColor.rgb*NdotL;", lightColorUniName);
// ambient light
@ -213,6 +253,12 @@ public:
pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
fAmbientColor = ambientColor;
}
const SkVector& invNormRotation = lightingFP.invNormRotation();
if (invNormRotation != fInvNormRotation) {
pdman.set2fv(fXformUni, 1, &invNormRotation.fX);
fInvNormRotation = invNormRotation;
}
}
private:
@ -224,6 +270,9 @@ public:
SkColor3f fAmbientColor;
GrGLProgramDataManager::UniformHandle fAmbientColorUni;
SkVector fInvNormRotation;
GrGLProgramDataManager::UniformHandle fXformUni;
};
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
@ -239,106 +288,116 @@ public:
const SkVector3& lightDir() const { return fLightDir; }
const SkColor3f& lightColor() const { return fLightColor; }
const SkColor3f& ambientColor() const { return fAmbientColor; }
const SkVector& invNormRotation() const { return fInvNormRotation; }
private:
GrGLFragmentProcessor* onCreateGLInstance() const override { return SkNEW(LightingGLFP); }
bool onIsEqual(const GrFragmentProcessor& proc) const override {
const LightingFP& lightingFP = proc.cast<LightingFP>();
return fDeviceTransform == lightingFP.fDeviceTransform &&
return fDiffDeviceTransform == lightingFP.fDiffDeviceTransform &&
fNormDeviceTransform == lightingFP.fNormDeviceTransform &&
fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
fLightDir == lightingFP.fLightDir &&
fLightColor == lightingFP.fLightColor &&
fAmbientColor == lightingFP.fAmbientColor;
fAmbientColor == lightingFP.fAmbientColor &&
fInvNormRotation == lightingFP.fInvNormRotation;
}
GrCoordTransform fDeviceTransform;
GrCoordTransform fDiffDeviceTransform;
GrCoordTransform fNormDeviceTransform;
GrTextureAccess fDiffuseTextureAccess;
GrTextureAccess fNormalTextureAccess;
SkVector3 fLightDir;
SkColor3f fLightColor;
SkColor3f fAmbientColor;
SkVector fInvNormRotation;
};
////////////////////////////////////////////////////////////////////////////
static bool make_mat(const SkBitmap& bm,
const SkMatrix& localMatrix1,
const SkMatrix* localMatrix2,
SkMatrix* result) {
result->setIDiv(bm.width(), bm.height());
SkMatrix lmInverse;
if (!localMatrix1.invert(&lmInverse)) {
return false;
}
if (localMatrix2) {
SkMatrix inv;
if (!localMatrix2->invert(&inv)) {
return false;
}
lmInverse.postConcat(inv);
}
result->preConcat(lmInverse);
return true;
}
bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint,
const SkMatrix& viewM, const SkMatrix* localMatrix,
GrColor* color, GrProcessorDataManager*,
GrColor* color, GrProcessorDataManager* pdm,
GrFragmentProcessor** fp) const {
// we assume diffuse and normal maps have same width and height
// TODO: support different sizes
SkASSERT(fDiffuseMap.width() == fNormalMap.width() &&
fDiffuseMap.height() == fNormalMap.height());
SkMatrix matrix;
matrix.setIDiv(fDiffuseMap.width(), fDiffuseMap.height());
SkMatrix diffM, normM;
if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) {
return false;
}
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
if (!make_mat(fNormalMap, fNormLocalMatrix, localMatrix, &normM)) {
return false;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
return false;
}
lmInverse.postConcat(inv);
}
matrix.preConcat(lmInverse);
// Must set wrap and filter on the sampler before requesting a texture. In two places below
// we check the matrix scale factors to determine how to interpret the filter quality setting.
// This completely ignores the complexity of the drawVertices case where explicit local coords
// are provided by the caller.
GrTextureParams::FilterMode textureFilterMode = GrTextureParams::kBilerp_FilterMode;
switch (paint.getFilterQuality()) {
case kNone_SkFilterQuality:
textureFilterMode = GrTextureParams::kNone_FilterMode;
break;
case kLow_SkFilterQuality:
textureFilterMode = GrTextureParams::kBilerp_FilterMode;
break;
case kMedium_SkFilterQuality:{
SkMatrix matrix;
matrix.setConcat(viewM, this->getLocalMatrix());
if (matrix.getMinScale() < SK_Scalar1) {
textureFilterMode = GrTextureParams::kMipMap_FilterMode;
} else {
// Don't trigger MIP level generation unnecessarily.
textureFilterMode = GrTextureParams::kBilerp_FilterMode;
}
break;
}
case kHigh_SkFilterQuality:
default:
SkErrorInternals::SetError(kInvalidPaint_SkError,
"Sorry, I don't understand the filtering "
"mode you asked for. Falling back to "
"MIPMaps.");
textureFilterMode = GrTextureParams::kMipMap_FilterMode;
break;
bool doBicubic;
GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode(
SkTMin(paint.getFilterQuality(), kMedium_SkFilterQuality),
viewM,
this->getLocalMatrix(),
&doBicubic);
SkASSERT(!doBicubic);
}
GrTextureParams::FilterMode normFilterMode = GrSkFilterQualityToGrFilterMode(
SkTMin(paint.getFilterQuality(), kMedium_SkFilterQuality),
viewM,
fNormLocalMatrix,
&doBicubic);
SkASSERT(!doBicubic);
// TODO: support other tile modes
GrTextureParams params(kClamp_TileMode, textureFilterMode);
SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, fDiffuseMap, &params));
GrTextureParams diffParams(kClamp_TileMode, diffFilterMode);
SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context,
fDiffuseMap, &diffParams));
if (!diffuseTexture) {
SkErrorInternals::SetError(kInternalError_SkError,
"Couldn't convert bitmap to texture.");
return false;
}
SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, &params));
GrTextureParams normParams(kClamp_TileMode, normFilterMode);
SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context,
fNormalMap, &normParams));
if (!normalTexture) {
SkErrorInternals::SetError(kInternalError_SkError,
"Couldn't convert bitmap to texture.");
return false;
}
*fp = SkNEW_ARGS(LightingFP, (diffuseTexture, normalTexture, matrix,
fLight.fDirection, fLight.fColor, fAmbientColor));
*fp = SkNEW_ARGS(LightingFP, (pdm, diffuseTexture, normalTexture,
diffM, normM, diffParams, normParams, fLights,
fInvNormRotation));
*color = GrColorPackA4(paint.getAlpha());
return true;
}
@ -391,27 +450,38 @@ SkLightingShaderImpl::LightingShaderContext::~LightingShaderContext() {
fNormalState->~SkBitmapProcState();
}
static inline int light(SkScalar light, int diff, SkScalar NdotL, SkScalar ambient) {
SkScalar color = light * diff * NdotL + 255 * ambient;
if (color <= 0.0f) {
return 0;
} else if (color >= 255.0f) {
return 255;
} else {
return (int) color;
}
static inline SkPMColor convert(SkColor3f color, U8CPU a) {
if (color.fX <= 0.0f) {
color.fX = 0.0f;
} else if (color.fX >= 255.0f) {
color.fX = 255.0f;
}
if (color.fY <= 0.0f) {
color.fY = 0.0f;
} else if (color.fY >= 255.0f) {
color.fY = 255.0f;
}
if (color.fZ <= 0.0f) {
color.fZ = 0.0f;
} else if (color.fZ >= 255.0f) {
color.fZ = 255.0f;
}
return SkPreMultiplyARGB(a, (int) color.fX, (int) color.fY, (int) color.fZ);
}
// larger is better (fewer times we have to loop), but we shouldn't
// take up too much stack-space (each could here costs 16 bytes)
// take up too much stack-space (each one here costs 16 bytes)
#define TMP_COUNT 16
void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
SkPMColor result[], int count) {
const SkLightingShaderImpl& lightShader = static_cast<const SkLightingShaderImpl&>(fShader);
SkPMColor tmpColor[TMP_COUNT], tmpColor2[TMP_COUNT];
SkPMColor tmpNormal[TMP_COUNT], tmpNormal2[TMP_COUNT];
uint32_t tmpColor[TMP_COUNT], tmpNormal[TMP_COUNT];
SkPMColor tmpColor2[2*TMP_COUNT], tmpNormal2[2*TMP_COUNT];
SkBitmapProcState::MatrixProc diffMProc = fDiffuseState->getMatrixProc();
SkBitmapProcState::SampleProc32 diffSProc = fDiffuseState->getSampleProc32();
@ -419,17 +489,19 @@ void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
SkBitmapProcState::MatrixProc normalMProc = fNormalState->getMatrixProc();
SkBitmapProcState::SampleProc32 normalSProc = fNormalState->getSampleProc32();
int diffMax = fDiffuseState->maxCountForBufferSize(sizeof(tmpColor[0]) * TMP_COUNT);
int normMax = fNormalState->maxCountForBufferSize(sizeof(tmpNormal[0]) * TMP_COUNT);
int max = SkTMin(diffMax, normMax);
SkASSERT(fDiffuseState->fPixmap.addr());
SkASSERT(fNormalState->fPixmap.addr());
SkPoint3 norm;
SkScalar NdotL;
int r, g, b;
SkPoint3 norm, xformedNorm;
do {
int n = count;
if (n > TMP_COUNT) {
n = TMP_COUNT;
if (n > max) {
n = max;
}
diffMProc(*fDiffuseState, tmpColor, n, x, y);
@ -445,18 +517,34 @@ void SkLightingShaderImpl::LightingShaderContext::shadeSpan(int x, int y,
SkIntToScalar(SkGetPackedB32(tmpNormal2[i]))-127.0f);
norm.normalize();
xformedNorm.fX = lightShader.fInvNormRotation.fX * norm.fX +
lightShader.fInvNormRotation.fY * norm.fY;
xformedNorm.fY = lightShader.fInvNormRotation.fX * norm.fX -
lightShader.fInvNormRotation.fY * norm.fY;
xformedNorm.fZ = norm.fZ;
SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
NdotL = norm.dot(lightShader.fLight.fDirection);
// This is all done in linear unpremul color space
r = light(lightShader.fLight.fColor.fX, SkColorGetR(diffColor), NdotL,
lightShader.fAmbientColor.fX);
g = light(lightShader.fLight.fColor.fY, SkColorGetG(diffColor), NdotL,
lightShader.fAmbientColor.fY);
b = light(lightShader.fLight.fColor.fZ, SkColorGetB(diffColor), NdotL,
lightShader.fAmbientColor.fZ);
SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
// This is all done in linear unpremul color space (each component 0..255.0f though)
for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
const SkLight& light = lightShader.fLights->light(l);
result[i] = SkPreMultiplyARGB(SkColorGetA(diffColor), r, g, b);
if (SkLight::kAmbient_LightType == light.type()) {
accum += light.color().makeScale(255.0f);
} else {
SkScalar NdotL = xformedNorm.dot(light.dir());
if (NdotL < 0.0f) {
NdotL = 0.0f;
}
accum.fX += light.color().fX * SkColorGetR(diffColor) * NdotL;
accum.fY += light.color().fY * SkColorGetG(diffColor) * NdotL;
accum.fZ += light.color().fZ * SkColorGetB(diffColor) * NdotL;
}
}
result[i] = convert(accum, SkColorGetA(diffColor));
}
result += n;
@ -474,8 +562,21 @@ void SkLightingShaderImpl::toString(SkString* str) const {
#endif
SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
SkMatrix localMatrix;
buf.readMatrix(&localMatrix);
SkMatrix diffLocalM;
bool hasDiffLocalM = buf.readBool();
if (hasDiffLocalM) {
buf.readMatrix(&diffLocalM);
} else {
diffLocalM.reset();
}
SkMatrix normLocalM;
bool hasNormLocalM = buf.readBool();
if (hasNormLocalM) {
buf.readMatrix(&normLocalM);
} else {
normLocalM.reset();
}
SkBitmap diffuse;
if (!buf.readBitmap(&diffuse)) {
@ -489,38 +590,84 @@ SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
}
normal.setImmutable();
SkLightingShader::Light light;
if (!buf.readScalarArray(&light.fDirection.fX, 3)) {
return NULL;
}
if (!buf.readScalarArray(&light.fColor.fX, 3)) {
return NULL;
int numLights = buf.readInt();
SkLightingShader::Lights::Builder builder;
for (int l = 0; l < numLights; ++l) {
bool isAmbient = buf.readBool();
SkColor3f color;
if (!buf.readScalarArray(&color.fX, 3)) {
return NULL;
}
if (isAmbient) {
builder.add(SkLight(color));
} else {
SkVector3 dir;
if (!buf.readScalarArray(&dir.fX, 3)) {
return NULL;
}
builder.add(SkLight(color, dir));
}
}
SkColor3f ambient;
if (!buf.readScalarArray(&ambient.fX, 3)) {
return NULL;
}
SkAutoTUnref<const SkLightingShader::Lights> lights(builder.finish());
return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient, &localMatrix));
return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights,
SkVector::Make(1.0f, 0.0f),
&diffLocalM, &normLocalM));
}
void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
buf.writeMatrix(this->getLocalMatrix());
this->INHERITED::flatten(buf);
bool hasNormLocalM = !fNormLocalMatrix.isIdentity();
buf.writeBool(hasNormLocalM);
if (hasNormLocalM) {
buf.writeMatrix(fNormLocalMatrix);
}
buf.writeBitmap(fDiffuseMap);
buf.writeBitmap(fNormalMap);
buf.writeScalarArray(&fLight.fDirection.fX, 3);
buf.writeScalarArray(&fLight.fColor.fX, 3);
buf.writeScalarArray(&fAmbientColor.fX, 3);
buf.writeInt(fLights->numLights());
for (int l = 0; l < fLights->numLights(); ++l) {
const SkLight& light = fLights->light(l);
bool isAmbient = SkLight::kAmbient_LightType == light.type();
buf.writeBool(isAmbient);
buf.writeScalarArray(&light.color().fX, 3);
if (!isAmbient) {
buf.writeScalarArray(&light.dir().fX, 3);
}
}
}
bool SkLightingShaderImpl::computeNormTotalInverse(const ContextRec& rec,
SkMatrix* normTotalInverse) const {
SkMatrix total;
total.setConcat(*rec.fMatrix, fNormLocalMatrix);
const SkMatrix* m = &total;
if (rec.fLocalMatrix) {
total.setConcat(*m, *rec.fLocalMatrix);
m = &total;
}
return m->invert(normTotalInverse);
}
SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
void* storage) const {
SkMatrix totalInverse;
// Do this first, so we know the matrix can be inverted.
if (!this->computeTotalInverse(rec, &totalInverse)) {
SkMatrix diffTotalInv;
// computeTotalInverse was called in SkShader::createContext so we know it will succeed
SkAssertResult(this->computeTotalInverse(rec, &diffTotalInv));
SkMatrix normTotalInv;
if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
return NULL;
}
@ -531,7 +678,7 @@ SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
diffuseState->fTileModeX = SkShader::kClamp_TileMode;
diffuseState->fTileModeY = SkShader::kClamp_TileMode;
diffuseState->fOrigBitmap = fDiffuseMap;
if (!diffuseState->chooseProcs(totalInverse, *rec.fPaint)) {
if (!diffuseState->chooseProcs(diffTotalInv, *rec.fPaint)) {
diffuseState->~SkBitmapProcState();
return NULL;
}
@ -543,7 +690,7 @@ SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
normalState->fTileModeX = SkShader::kClamp_TileMode;
normalState->fTileModeY = SkShader::kClamp_TileMode;
normalState->fOrigBitmap = fNormalMap;
if (!normalState->chooseProcs(totalInverse, *rec.fPaint)) {
if (!normalState->chooseProcs(normTotalInv, *rec.fPaint)) {
diffuseState->~SkBitmapProcState();
normalState->~SkBitmapProcState();
return NULL;
@ -566,9 +713,9 @@ static bool bitmap_is_too_big(const SkBitmap& bm) {
}
SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& normal,
const SkLightingShader::Light& light,
const SkColor3f& ambient,
const SkMatrix* localMatrix) {
const Lights* lights,
const SkVector& invNormRotation,
const SkMatrix* diffLocalM, const SkMatrix* normLocalM) {
if (diffuse.isNull() || bitmap_is_too_big(diffuse) ||
normal.isNull() || bitmap_is_too_big(normal) ||
diffuse.width() != normal.width() ||
@ -576,7 +723,10 @@ SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& norm
return nullptr;
}
return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient, localMatrix));
SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1));
return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, lights,
invNormRotation, diffLocalM, normLocalM));
}
///////////////////////////////////////////////////////////////////////////////

56
src/effects/SkLightingShader.h → src/core/SkLightingShader.h
View File

@ -10,15 +10,57 @@
#ifndef SkLightingShader_DEFINED
#define SkLightingShader_DEFINED
#include "SkPoint3.h"
#include "SkFlattenable.h"
#include "SkLight.h"
#include "SkShader.h"
#include "SkTDArray.h"
class SkBitmap;
class SkMatrix;
class SK_API SkLightingShader {
public:
struct Light {
SkVector3 fDirection; // direction towards the light (+Z is out of the screen).
// If degenerate, it will be replaced with (0, 0, 1).
SkColor3f fColor; // linear (unpremul) color. Range is 0..1 in each channel.
class Lights : public SkRefCnt {
public:
class Builder {
public:
Builder(const SkLight lights[], int numLights)
: fLights(SkNEW_ARGS(Lights, (lights, numLights))) {
}
Builder() : fLights(SkNEW(Lights)) { }
// TODO: limit the number of lights here or just ignore those
// above some maximum?
void add(const SkLight& light) {
if (fLights) {
*fLights->fLights.push() = light;
}
}
const Lights* finish() {
return fLights.detach();
}
private:
SkAutoTUnref<Lights> fLights;
};
int numLights() const {
return fLights.count();
}
const SkLight& light(int index) const {
return fLights[index];
}
private:
Lights() {}
Lights(const SkLight lights[], int numLights) : fLights(lights, numLights) {}
SkTDArray<SkLight> fLights;
typedef SkRefCnt INHERITED;
};
/** Returns a shader that lights the diffuse and normal maps with a single light.
@ -50,8 +92,8 @@ public:
(127, 127, 0).
*/
static SkShader* Create(const SkBitmap& diffuse, const SkBitmap& normal,
const SkLightingShader::Light& light, const SkColor3f& ambient,
const SkMatrix* localMatrix);
const Lights* lights, const SkVector& invNormRotation,
const SkMatrix* diffLocalMatrix, const SkMatrix* normLocalMatrix);
SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
};

0
src/effects/SkPoint3.cpp → src/core/SkPoint3.cpp
View File

194
src/effects/SkLightingImageFilter.cpp
View File

@ -181,9 +181,12 @@ inline SkPoint3 bottomRightNormal(int m[9], SkScalar surfaceScale) {
surfaceScale);
}
template <class LightingType, class LightType> void lightBitmap(
const LightingType& lightingType, const SkLight* light, const SkBitmap& src, SkBitmap* dst,
SkScalar surfaceScale, const SkIRect& bounds) {
template <class LightingType, class LightType> void lightBitmap(const LightingType& lightingType,
const SkImageFilterLight* light,
const SkBitmap& src,
SkBitmap* dst,
SkScalar surfaceScale,
const SkIRect& bounds) {
SkASSERT(dst->width() == bounds.width() && dst->height() == bounds.height());
const LightType* l = static_cast<const LightType*>(light);
int left = bounds.left(), right = bounds.right();
@ -308,7 +311,7 @@ enum BoundaryMode {
class SkLightingImageFilterInternal : public SkLightingImageFilter {
protected:
SkLightingImageFilterInternal(SkLight* light,
SkLightingImageFilterInternal(SkImageFilterLight* light,
SkScalar surfaceScale,
SkImageFilter* input,
const CropRect* cropRect)
@ -431,7 +434,8 @@ bool SkLightingImageFilterInternal::filterImageGPU(Proxy* proxy,
class SkDiffuseLightingImageFilter : public SkLightingImageFilterInternal {
public:
static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter*,
static SkImageFilter* Create(SkImageFilterLight* light, SkScalar surfaceScale,
SkScalar kd, SkImageFilter*,
const CropRect*);
SK_TO_STRING_OVERRIDE()
@ -439,7 +443,7 @@ public:
SkScalar kd() const { return fKD; }
protected:
SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
SkDiffuseLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale,
SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
void flatten(SkWriteBuffer& buffer) const override;
bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
@ -457,7 +461,7 @@ private:
class SkSpecularLightingImageFilter : public SkLightingImageFilterInternal {
public:
static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale,
static SkImageFilter* Create(SkImageFilterLight* light, SkScalar surfaceScale,
SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*);
SK_TO_STRING_OVERRIDE()
@ -467,7 +471,7 @@ public:
SkScalar shininess() const { return fShininess; }
protected:
SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
SkSpecularLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale, SkScalar ks,
SkScalar shininess, SkImageFilter* input, const CropRect*);
void flatten(SkWriteBuffer& buffer) const override;
bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
@ -488,11 +492,11 @@ private:
class GrLightingEffect : public GrSingleTextureEffect {
public:
GrLightingEffect(GrProcessorDataManager*, GrTexture* texture, const SkLight* light,
GrLightingEffect(GrProcessorDataManager*, GrTexture* texture, const SkImageFilterLight* light,
SkScalar surfaceScale, const SkMatrix& matrix, BoundaryMode boundaryMode);
virtual ~GrLightingEffect();
const SkLight* light() const { return fLight; }
const SkImageFilterLight* light() const { return fLight; }
SkScalar surfaceScale() const { return fSurfaceScale; }
const SkMatrix& filterMatrix() const { return fFilterMatrix; }
BoundaryMode boundaryMode() const { return fBoundaryMode; }
@ -506,18 +510,19 @@ protected:
}
private:
typedef GrSingleTextureEffect INHERITED;
const SkLight* fLight;
const SkImageFilterLight* fLight;
SkScalar fSurfaceScale;
SkMatrix fFilterMatrix;
BoundaryMode fBoundaryMode;
typedef GrSingleTextureEffect INHERITED;
};
class GrDiffuseLightingEffect : public GrLightingEffect {
public:
static GrFragmentProcessor* Create(GrProcessorDataManager* procDataManager,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar kd,
@ -544,7 +549,7 @@ private:
GrDiffuseLightingEffect(GrProcessorDataManager*,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar kd,
@ -559,7 +564,7 @@ class GrSpecularLightingEffect : public GrLightingEffect {
public:
static GrFragmentProcessor* Create(GrProcessorDataManager* procDataManager,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar ks,
@ -589,7 +594,7 @@ private:
GrSpecularLightingEffect(GrProcessorDataManager*,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar ks,
@ -627,8 +632,7 @@ public:
// This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLight must call
// INHERITED::setData().
virtual void setData(const GrGLProgramDataManager&,
const SkLight* light) const;
virtual void setData(const GrGLProgramDataManager&, const SkImageFilterLight* light) const;
protected:
/**
@ -648,7 +652,7 @@ private:
class GrGLDistantLight : public GrGLLight {
public:
virtual ~GrGLDistantLight() {}
void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
void setData(const GrGLProgramDataManager&, const SkImageFilterLight* light) const override;
void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
private:
@ -661,7 +665,7 @@ private:
class GrGLPointLight : public GrGLLight {
public:
virtual ~GrGLPointLight() {}
void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
void setData(const GrGLProgramDataManager&, const SkImageFilterLight* light) const override;
void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
private:
@ -674,7 +678,7 @@ private:
class GrGLSpotLight : public GrGLLight {
public:
virtual ~GrGLSpotLight() {}
void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
void setData(const GrGLProgramDataManager&, const SkImageFilterLight* light) const override;
void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) override;
@ -699,7 +703,7 @@ class GrGLLight;
///////////////////////////////////////////////////////////////////////////////
class SkLight : public SkRefCnt {
class SkImageFilterLight : public SkRefCnt {
public:
@ -711,26 +715,26 @@ public:
virtual LightType type() const = 0;
const SkPoint3& color() const { return fColor; }
virtual GrGLLight* createGLLight() const = 0;
virtual bool isEqual(const SkLight& other) const {
virtual bool isEqual(const SkImageFilterLight& other) const {
return fColor == other.fColor;
}
// Called to know whether the generated GrGLLight will require access to the fragment position.
virtual bool requiresFragmentPosition() const = 0;
virtual SkLight* transform(const SkMatrix& matrix) const = 0;
virtual SkImageFilterLight* transform(const SkMatrix& matrix) const = 0;
// Defined below SkLight's subclasses.
void flattenLight(SkWriteBuffer& buffer) const;
static SkLight* UnflattenLight(SkReadBuffer& buffer);
static SkImageFilterLight* UnflattenLight(SkReadBuffer& buffer);
protected:
SkLight(SkColor color) {
SkImageFilterLight(SkColor color) {
fColor = SkPoint3::Make(SkIntToScalar(SkColorGetR(color)),
SkIntToScalar(SkColorGetG(color)),
SkIntToScalar(SkColorGetB(color)));
}
SkLight(const SkPoint3& color)
SkImageFilterLight(const SkPoint3& color)
: fColor(color) {}
SkLight(SkReadBuffer& buffer) {
SkImageFilterLight(SkReadBuffer& buffer) {
fColor = readPoint3(buffer);
}
@ -744,7 +748,7 @@ private:
///////////////////////////////////////////////////////////////////////////////
class SkDistantLight : public SkLight {
class SkDistantLight : public SkImageFilterLight {
public:
SkDistantLight(const SkPoint3& direction, SkColor color)
: INHERITED(color), fDirection(direction) {
@ -766,7 +770,7 @@ public:
}
bool requiresFragmentPosition() const override { return false; }
bool isEqual(const SkLight& other) const override {
bool isEqual(const SkImageFilterLight& other) const override {
if (other.type() != kDistant_LightType) {
return false;
}
@ -784,7 +788,7 @@ protected:
SkDistantLight(const SkPoint3& direction, const SkPoint3& color)
: INHERITED(color), fDirection(direction) {
}
SkLight* transform(const SkMatrix& matrix) const override {
SkImageFilterLight* transform(const SkMatrix& matrix) const override {
return new SkDistantLight(direction(), color());
}
void onFlattenLight(SkWriteBuffer& buffer) const override {
@ -792,13 +796,14 @@ protected:
}
private:
typedef SkLight INHERITED;
SkPoint3 fDirection;
typedef SkImageFilterLight INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
class SkPointLight : public SkLight {
class SkPointLight : public SkImageFilterLight {
public:
SkPointLight(const SkPoint3& location, SkColor color)
: INHERITED(color), fLocation(location) {}
@ -823,7 +828,7 @@ public:
#endif
}
bool requiresFragmentPosition() const override { return true; }
bool isEqual(const SkLight& other) const override {
bool isEqual(const SkImageFilterLight& other) const override {
if (other.type() != kPoint_LightType) {
return false;
}
@ -831,7 +836,7 @@ public:
return INHERITED::isEqual(other) &&
fLocation == o.fLocation;
}
SkLight* transform(const SkMatrix& matrix) const override {
SkImageFilterLight* transform(const SkMatrix& matrix) const override {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
@ -855,13 +860,14 @@ protected:
}
private:
typedef SkLight INHERITED;
SkPoint3 fLocation;
typedef SkImageFilterLight INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
class SkSpotLight : public SkLight {
class SkSpotLight : public SkImageFilterLight {
public:
SkSpotLight(const SkPoint3& location,
const SkPoint3& target,
@ -881,7 +887,7 @@ public:
fConeScale = SkScalarInvert(antiAliasThreshold);
}
SkLight* transform(const SkMatrix& matrix) const override {
SkImageFilterLight* transform(const SkMatrix& matrix) const override {
SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
matrix.mapPoints(&location2, 1);
// Use X scale and Y scale on Z and average the result
@ -987,7 +993,7 @@ protected:
writePoint3(fS, buffer);
}
bool isEqual(const SkLight& other) const override {
bool isEqual(const SkImageFilterLight& other) const override {
if (other.type() != kSpot_LightType) {
return false;
}
@ -1004,7 +1010,6 @@ private:
static const SkScalar kSpecularExponentMin;
static const SkScalar kSpecularExponentMax;
typedef SkLight INHERITED;
SkPoint3 fLocation;
SkPoint3 fTarget;
SkScalar fSpecularExponent;
@ -1012,6 +1017,8 @@ private:
SkScalar fCosInnerConeAngle;
SkScalar fConeScale;
SkPoint3 fS;
typedef SkImageFilterLight INHERITED;
};
// According to the spec, the specular term should be in the range [1, 128] :
@ -1021,22 +1028,22 @@ const SkScalar SkSpotLight::kSpecularExponentMax = 128.0f;
///////////////////////////////////////////////////////////////////////////////
void SkLight::flattenLight(SkWriteBuffer& buffer) const {
void SkImageFilterLight::flattenLight(SkWriteBuffer& buffer) const {
// Write type first, then baseclass, then subclass.
buffer.writeInt(this->type());
writePoint3(fColor, buffer);
this->onFlattenLight(buffer);
}
/*static*/ SkLight* SkLight::UnflattenLight(SkReadBuffer& buffer) {
/*static*/ SkImageFilterLight* SkImageFilterLight::UnflattenLight(SkReadBuffer& buffer) {
// Read type first.
const SkLight::LightType type = (SkLight::LightType)buffer.readInt();
const SkImageFilterLight::LightType type = (SkImageFilterLight::LightType)buffer.readInt();
switch (type) {
// Each of these constructors must first call SkLight's, so we'll read the baseclass
// then subclass, same order as flattenLight.
case SkLight::kDistant_LightType: return SkNEW_ARGS(SkDistantLight, (buffer));
case SkLight::kPoint_LightType: return SkNEW_ARGS(SkPointLight, (buffer));
case SkLight::kSpot_LightType: return SkNEW_ARGS(SkSpotLight, (buffer));
case SkImageFilterLight::kDistant_LightType: return SkNEW_ARGS(SkDistantLight, (buffer));
case SkImageFilterLight::kPoint_LightType: return SkNEW_ARGS(SkPointLight, (buffer));
case SkImageFilterLight::kSpot_LightType: return SkNEW_ARGS(SkSpotLight, (buffer));
default:
SkDEBUGFAIL("Unknown LightType.");
buffer.validate(false);
@ -1045,7 +1052,7 @@ void SkLight::flattenLight(SkWriteBuffer& buffer) const {
}
///////////////////////////////////////////////////////////////////////////////
SkLightingImageFilter::SkLightingImageFilter(SkLight* light, SkScalar surfaceScale,
SkLightingImageFilter::SkLightingImageFilter(SkImageFilterLight* light, SkScalar surfaceScale,
SkImageFilter* input, const CropRect* cropRect)
: INHERITED(1, &input, cropRect)
, fLight(SkRef(light))
@ -1058,7 +1065,7 @@ SkImageFilter* SkLightingImageFilter::CreateDistantLitDiffuse(const SkPoint3& di
SkScalar kd,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
@ -1068,7 +1075,7 @@ SkImageFilter* SkLightingImageFilter::CreatePointLitDiffuse(const SkPoint3& loca
SkScalar kd,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
@ -1081,8 +1088,9 @@ SkImageFilter* SkLightingImageFilter::CreateSpotLitDiffuse(const SkPoint3& locat
SkScalar kd,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent,
cutoffAngle, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkSpotLight, (location, target,
specularExponent,
cutoffAngle, lightColor)));
return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
@ -1093,7 +1101,7 @@ SkImageFilter* SkLightingImageFilter::CreateDistantLitSpecular(const SkPoint3& d
SkScalar shine,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
@ -1104,7 +1112,7 @@ SkImageFilter* SkLightingImageFilter::CreatePointLitSpecular(const SkPoint3& loc
SkScalar shine,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
@ -1118,8 +1126,9 @@ SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(const SkPoint3& loca
SkScalar shine,
SkImageFilter* input,
const CropRect* cropRect) {
SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent,
cutoffAngle, lightColor)));
SkAutoTUnref<SkImageFilterLight> light(SkNEW_ARGS(SkSpotLight, (location, target,
specularExponent,
cutoffAngle, lightColor)));
return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
@ -1133,8 +1142,11 @@ void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
///////////////////////////////////////////////////////////////////////////////
SkImageFilter* SkDiffuseLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale,
SkScalar kd, SkImageFilter* input, const CropRect* cropRect) {
SkImageFilter* SkDiffuseLightingImageFilter::Create(SkImageFilterLight* light,
SkScalar surfaceScale,
SkScalar kd,
SkImageFilter* input,
const CropRect* cropRect) {
if (NULL == light) {
return NULL;
}
@ -1149,7 +1161,7 @@ SkImageFilter* SkDiffuseLightingImageFilter::Create(SkLight* light, SkScalar sur
return SkNEW_ARGS(SkDiffuseLightingImageFilter, (light, surfaceScale, kd, input, cropRect));
}
SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light,
SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkImageFilterLight* light,
SkScalar surfaceScale,
SkScalar kd,
SkImageFilter* input,
@ -1161,7 +1173,7 @@ SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light,
SkFlattenable* SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
SkScalar surfaceScale = buffer.readScalar();
SkScalar kd = buffer.readScalar();
return Create(light, surfaceScale, kd, common.getInput(0), &common.cropRect());
@ -1205,14 +1217,14 @@ bool SkDiffuseLightingImageFilter::onFilterImage(Proxy* proxy,
return false;
}
SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
SkAutoTUnref<SkImageFilterLight> transformedLight(light()->transform(ctx.ctm()));
DiffuseLightingType lightingType(fKD);
offset->fX = bounds.left();
offset->fY = bounds.top();
bounds.offset(-srcOffset);
switch (transformedLight->type()) {
case SkLight::kDistant_LightType:
case SkImageFilterLight::kDistant_LightType:
lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType,
transformedLight,
src,
@ -1220,7 +1232,7 @@ bool SkDiffuseLightingImageFilter::onFilterImage(Proxy* proxy,
surfaceScale(),
bounds);
break;
case SkLight::kPoint_LightType:
case SkImageFilterLight::kPoint_LightType:
lightBitmap<DiffuseLightingType, SkPointLight>(lightingType,
transformedLight,
src,
@ -1228,7 +1240,7 @@ bool SkDiffuseLightingImageFilter::onFilterImage(Proxy* proxy,
surfaceScale(),
bounds);
break;
case SkLight::kSpot_LightType:
case SkImageFilterLight::kSpot_LightType:
lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType,
transformedLight,
src,
@ -1265,8 +1277,12 @@ GrFragmentProcessor* SkDiffuseLightingImageFilter::getFragmentProcessor(
///////////////////////////////////////////////////////////////////////////////
SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale,
SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
SkImageFilter* SkSpecularLightingImageFilter::Create(SkImageFilterLight* light,
SkScalar surfaceScale,
SkScalar ks,
SkScalar shininess,
SkImageFilter* input,
const CropRect* cropRect) {
if (NULL == light) {
return NULL;
}
@ -1282,7 +1298,7 @@ SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar su
(light, surfaceScale, ks, shininess, input, cropRect));
}
SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light,
SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkImageFilterLight* light,
SkScalar surfaceScale,
SkScalar ks,
SkScalar shininess,
@ -1296,7 +1312,7 @@ SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light,
SkFlattenable* SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
SkAutoTUnref<SkImageFilterLight> light(SkImageFilterLight::UnflattenLight(buffer));
SkScalar surfaceScale = buffer.readScalar();
SkScalar ks = buffer.readScalar();
SkScalar shine = buffer.readScalar();
@ -1347,9 +1363,9 @@ bool SkSpecularLightingImageFilter::onFilterImage(Proxy* proxy,
offset->fX = bounds.left();
offset->fY = bounds.top();
bounds.offset(-srcOffset);
SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
SkAutoTUnref<SkImageFilterLight> transformedLight(light()->transform(ctx.ctm()));
switch (transformedLight->type()) {
case SkLight::kDistant_LightType:
case SkImageFilterLight::kDistant_LightType:
lightBitmap<SpecularLightingType, SkDistantLight>(lightingType,
transformedLight,
src,
@ -1357,7 +1373,7 @@ bool SkSpecularLightingImageFilter::onFilterImage(Proxy* proxy,
surfaceScale(),
bounds);
break;
case SkLight::kPoint_LightType:
case SkImageFilterLight::kPoint_LightType:
lightBitmap<SpecularLightingType, SkPointLight>(lightingType,
transformedLight,
src,
@ -1365,7 +1381,7 @@ bool SkSpecularLightingImageFilter::onFilterImage(Proxy* proxy,
surfaceScale(),
bounds);
break;
case SkLight::kSpot_LightType:
case SkImageFilterLight::kSpot_LightType:
lightBitmap<SpecularLightingType, SkSpotLight>(lightingType,
transformedLight,
src,
@ -1409,7 +1425,7 @@ SkPoint3 random_point3(SkRandom* random) {
SkScalarToFloat(random->nextSScalar1()));
}
SkLight* create_random_light(SkRandom* random) {
SkImageFilterLight* create_random_light(SkRandom* random) {
int type = random->nextULessThan(3);
switch (type) {
case 0: {
@ -1571,7 +1587,7 @@ private:
GrLightingEffect::GrLightingEffect(GrProcessorDataManager* procDataManager,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
BoundaryMode boundaryMode)
@ -1601,7 +1617,7 @@ bool GrLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrProcessorDataManager* procDataManager,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar kd,
@ -1630,7 +1646,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar kd = d->fRandom->nextUScalar1();
SkAutoTUnref<SkLight> light(create_random_light(d->fRandom));
SkAutoTUnref<SkImageFilterLight> light(create_random_light(d->fRandom));
SkMatrix matrix;
for (int i = 0; i < 9; i++) {
matrix[i] = d->fRandom->nextUScalar1();
@ -1754,7 +1770,8 @@ void GrGLLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale());
SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.filterMatrix()));
SkAutoTUnref<SkImageFilterLight> transformedLight(
lighting.light()->transform(lighting.filterMatrix()));
fLight->setData(pdman, transformedLight);
}
@ -1799,15 +1816,15 @@ void GrGLDiffuseLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
GrSpecularLightingEffect::GrSpecularLightingEffect(GrProcessorDataManager* procDataManager,
GrTexture* texture,
const SkLight* light,
const SkImageFilterLight* light,
SkScalar surfaceScale,
const SkMatrix& matrix,
SkScalar ks,
SkScalar shininess,
BoundaryMode boundaryMode)
: INHERITED(procDataManager, texture, light, surfaceScale, matrix, boundaryMode),
fKS(ks),
fShininess(shininess) {
: INHERITED(procDataManager, texture, light, surfaceScale, matrix, boundaryMode)
, fKS(ks)
, fShininess(shininess) {
this->initClassID<GrSpecularLightingEffect>();
}
@ -1833,7 +1850,7 @@ GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar ks = d->fRandom->nextUScalar1();
SkScalar shininess = d->fRandom->nextUScalar1();
SkAutoTUnref<SkLight> light(create_random_light(d->fRandom));
SkAutoTUnref<SkImageFilterLight> light(create_random_light(d->fRandom));
SkMatrix matrix;
for (int i = 0; i < 9; i++) {
matrix[i] = d->fRandom->nextUScalar1();
@ -1899,7 +1916,8 @@ void GrGLLight::emitLightColor(GrGLFPBuilder* builder, const char *surfaceToLigh
builder->getFragmentShaderBuilder()->codeAppend(builder->getUniformCStr(this->lightColorUni()));
}
void GrGLLight::setData(const GrGLProgramDataManager& pdman, const SkLight* light) const {
void GrGLLight::setData(const GrGLProgramDataManager& pdman,
const SkImageFilterLight* light) const {
setUniformPoint3(pdman, fColorUni,
light->color().makeScale(SkScalarInvert(SkIntToScalar(255))));
}
@ -1907,9 +1925,9 @@ void GrGLLight::setData(const GrGLProgramDataManager& pdman, const SkLight* ligh
///////////////////////////////////////////////////////////////////////////////
void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman,
const SkLight* light) const {
const SkImageFilterLight* light) const {
INHERITED::setData(pdman, light);
SkASSERT(light->type() == SkLight::kDistant_LightType);
SkASSERT(light->type() == SkImageFilterLight::kDistant_LightType);
const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light);
setUniformNormal3(pdman, fDirectionUni, distantLight->direction());
}
@ -1925,9 +1943,9 @@ void GrGLDistantLight::emitSurfaceToLight(GrGLFPBuilder* builder, const char* z)
///////////////////////////////////////////////////////////////////////////////
void GrGLPointLight::setData(const GrGLProgramDataManager& pdman,
const SkLight* light) const {
const SkImageFilterLight* light) const {
INHERITED::setData(pdman, light);
SkASSERT(light->type() == SkLight::kPoint_LightType);
SkASSERT(light->type() == SkImageFilterLight::kPoint_LightType);
const SkPointLight* pointLight = static_cast<const SkPointLight*>(light);
setUniformPoint3(pdman, fLocationUni, pointLight->location());
}
@ -1945,9 +1963,9 @@ void GrGLPointLight::emitSurfaceToLight(GrGLFPBuilder* builder, const char* z) {
///////////////////////////////////////////////////////////////////////////////
void GrGLSpotLight::setData(const GrGLProgramDataManager& pdman,
const SkLight* light) const {
const SkImageFilterLight* light) const {
INHERITED::setData(pdman, light);
SkASSERT(light->type() == SkLight::kSpot_LightType);
SkASSERT(light->type() == SkImageFilterLight::kSpot_LightType);
const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light);
setUniformPoint3(pdman, fLocationUni, spotLight->location());
pdman.set1f(fExponentUni, spotLight->specularExponent());

2
src/ports/SkGlobalInitialization_chromium.cpp
View File

@ -41,7 +41,7 @@
#include "SkLayerRasterizer.h"
#include "SkLerpXfermode.h"
#include "SkLightingImageFilter.h"
#include "../effects/SkLightingShader.h"
#include "SkLightingShader.h"
#include "SkLocalMatrixShader.h"
#include "SkLumaColorFilter.h"
#include "SkMagnifierImageFilter.h"

2
src/ports/SkGlobalInitialization_default.cpp
View File

@ -37,7 +37,7 @@
#include "SkLayerRasterizer.h"
#include "SkLerpXfermode.h"
#include "SkLightingImageFilter.h"
#include "../effects/SkLightingShader.h"
#include "SkLightingShader.h"
#include "SkLocalMatrixShader.h"
#include "SkLumaColorFilter.h"
#include "SkMagnifierImageFilter.h"