//////////////////////////////////////////////////////////////////////////////
-static GM* MyFactory(void*) { return new ImageLightingGM; }
-static GMRegistry reg(MyFactory);
+DEF_GM( return SkNEW(ImageLightingGM); )
}
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "gm.h"
+
+#include "SkColorPriv.h"
+#include "SkLightingShader.h"
+
+static SkBitmap make_checkerboard(int texSize) {
+ SkBitmap bitmap;
+ bitmap.allocN32Pixels(texSize, texSize);
+
+ SkCanvas canvas(bitmap);
+ sk_tool_utils::draw_checkerboard(&canvas,
+ sk_tool_utils::color_to_565(0x0),
+ sk_tool_utils::color_to_565(0xFF804020),
+ 16);
+ return bitmap;
+}
+
+// Create a hemispherical normal map
+static SkBitmap make_normalmap(int texSize) {
+ SkBitmap hemi;
+ hemi.allocN32Pixels(texSize, texSize);
+
+ for (int y = 0; y < texSize; ++y) {
+ for (int x = 0; x < texSize; ++x) {
+ SkScalar locX = (x + 0.5f - texSize/2.0f) / (texSize/2.0f);
+ SkScalar locY = (y + 0.5f - texSize/2.0f) / (texSize/2.0f);
+
+ SkScalar locZ = locX * locX + locY * locY;
+ if (locZ >= 1.0f) {
+ locX = 0.0f;
+ locY = 0.0f;
+ locZ = 0.0f;
+ }
+ locZ = sqrt(1.0f - locZ);
+ unsigned char r = static_cast<unsigned char>((0.5f * locX + 0.5f) * 255);
+ unsigned char g = static_cast<unsigned char>((-0.5f * locY + 0.5f) * 255);
+ unsigned char b = static_cast<unsigned char>((0.5f * locZ + 0.5f) * 255);
+ *hemi.getAddr32(x, y) = SkPackARGB32(0xFF, r, g, b);
+ }
+ }
+
+ return hemi;
+}
+
+
+namespace skiagm {
+
+// This GM exercises lighting shaders.
+class LightingShaderGM : public GM {
+public:
+ LightingShaderGM() {
+ this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
+ }
+
+protected:
+
+ SkString onShortName() override {
+ return SkString("lightingshader");
+ }
+
+ SkISize onISize() override {
+ return SkISize::Make(kTexSize, kTexSize);
+ }
+
+ void onOnceBeforeDraw() override {
+ fDiffuse = make_checkerboard(kTexSize);
+ fNormalMap = make_normalmap(kTexSize);
+ }
+
+ void onDraw(SkCanvas* canvas) override {
+
+ SkColor ambient = SkColorSetRGB(0x1f, 0x1f, 0x1f);
+
+ SkLightingShader::Light light;
+ light.fColor = SkColorSetRGB(0xff, 0xff, 0xff);
+ light.fDirection.fX = 0.0f;
+ light.fDirection.fY = 0.0f;
+ light.fDirection.fZ = 1.0f;
+
+ SkAutoTUnref<SkShader> fShader(SkLightingShader::Create(fDiffuse, fNormalMap,
+ light, ambient));
+
+ SkPaint paint;
+ paint.setShader(fShader);
+
+ SkRect r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize));
+
+ canvas->drawRect(r, paint);
+ }
+
+private:
+ static const int kTexSize = 128;
+
+ SkBitmap fDiffuse;
+ SkBitmap fNormalMap;
+
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+DEF_GM( return SkNEW(LightingShaderGM); )
+
+}
'<(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',
#include "Resources.h"
#include "SkCanvas.h"
-#include "SkErrorInternals.h"
-#include "SkGr.h"
-#include "SkPoint3.h"
-#include "SkReadBuffer.h"
-#include "SkShader.h"
-#include "SkWriteBuffer.h"
-#include "GrFragmentProcessor.h"
-#include "GrCoordTransform.h"
-#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-
-///////////////////////////////////////////////////////////////////////////////
-
-class LightingShader : public SkShader {
-public:
- struct Light {
- SkVector3 fDirection;
- SkColor fColor; // assumed to be linear color
- };
-
- LightingShader(const SkBitmap& diffuse, const SkBitmap& normal, const Light& light,
- const SkColor ambient)
- : fDiffuseMap(diffuse)
- , fNormalMap(normal)
- , fLight(light)
- , fAmbientColor(ambient) {}
-
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(LightingShader);
-
- void flatten(SkWriteBuffer& buf) const override {
- buf.writeBitmap(fDiffuseMap);
- buf.writeBitmap(fNormalMap);
- buf.writeScalarArray(&fLight.fDirection.fX, 3);
- buf.writeColor(fLight.fColor);
- buf.writeColor(fAmbientColor);
- }
-
- bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* color,
- GrProcessorDataManager*, GrFragmentProcessor** fp) const override;
-
- SkShader::BitmapType asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
- SkShader::TileMode* xy) const override {
- if (bitmap) {
- *bitmap = fDiffuseMap;
- }
- if (matrix) {
- matrix->reset();
- }
- if (xy) {
- xy[0] = kClamp_TileMode;
- xy[1] = kClamp_TileMode;
- }
- return kDefault_BitmapType;
- }
-
-#ifndef SK_IGNORE_TO_STRING
- void toString(SkString* str) const override {
- str->appendf("LightingShader: ()");
- }
-#endif
-
- void setLight(const Light& light) { fLight = light; }
-
-private:
- SkBitmap fDiffuseMap;
- SkBitmap fNormalMap;
- Light fLight;
- SkColor fAmbientColor;
-};
-
-SkFlattenable* LightingShader::CreateProc(SkReadBuffer& buf) {
- SkBitmap diffuse;
- if (!buf.readBitmap(&diffuse)) {
- return NULL;
- }
- diffuse.setImmutable();
-
- SkBitmap normal;
- if (!buf.readBitmap(&normal)) {
- return NULL;
- }
- normal.setImmutable();
-
- Light light;
- if (!buf.readScalarArray(&light.fDirection.fX, 3)) {
- return NULL;
- }
- light.fColor = buf.readColor();
-
- SkColor ambient = buf.readColor();
-
- return SkNEW_ARGS(LightingShader, (diffuse, normal, light, ambient));
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-class LightingFP : public GrFragmentProcessor {
-public:
- LightingFP(GrTexture* diffuse, GrTexture* normal, const SkMatrix& matrix,
- SkVector3 lightDir, GrColor lightColor, GrColor ambientColor)
- : fDeviceTransform(kDevice_GrCoordSet, matrix)
- , fDiffuseTextureAccess(diffuse)
- , fNormalTextureAccess(normal)
- , fLightDir(lightDir)
- , fLightColor(lightColor)
- , fAmbientColor(ambientColor) {
- this->addCoordTransform(&fDeviceTransform);
- this->addTextureAccess(&fDiffuseTextureAccess);
- this->addTextureAccess(&fNormalTextureAccess);
-
- this->initClassID<LightingFP>();
- }
-
- class LightingGLFP : public GrGLFragmentProcessor {
- public:
- LightingGLFP() : fLightColor(GrColor_ILLEGAL) {
- fLightDir.fX = 10000.0f;
- }
-
- void emitCode(EmitArgs& args) override {
-
- GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
-
- // add uniforms
- const char* lightDirUniName = NULL;
- fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
- kVec3f_GrSLType, kDefault_GrSLPrecision,
- "LightDir", &lightDirUniName);
-
- const char* lightColorUniName = NULL;
- fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "LightColor", &lightColorUniName);
-
- const char* ambientColorUniName = NULL;
- fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
- kVec4f_GrSLType, kDefault_GrSLPrecision,
- "AmbientColor", &ambientColorUniName);
-
- fpb->codeAppend("vec4 diffuseColor = ");
- fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0],
- args.fCoords[0].c_str(), args.fCoords[0].getType());
- fpb->codeAppend(";");
-
- fpb->codeAppend("vec4 normalColor = ");
- fpb->appendTextureLookup(args.fSamplers[1], args.fCoords[0].c_str(),
- args.fCoords[0].getType());
- fpb->codeAppend(";");
-
- fpb->codeAppend("vec3 normal = normalize(2.0*(normalColor.rgb - vec3(0.5)));");
- fpb->codeAppendf("vec3 lightDir = normalize(%s);", lightDirUniName);
- fpb->codeAppend("float NdotL = dot(normal, lightDir);");
- // diffuse light
- fpb->codeAppendf("vec3 result = %s.rgb*diffuseColor.rgb*NdotL;", lightColorUniName);
- // ambient light
- fpb->codeAppendf("result += %s.rgb;", ambientColorUniName);
- fpb->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOutputColor);
- }
-
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
- const LightingFP& lightingFP = proc.cast<LightingFP>();
-
- SkVector3 lightDir = lightingFP.lightDir();
- if (lightDir != fLightDir) {
- pdman.set3fv(fLightDirUni, 1, &lightDir.fX);
- fLightDir = lightDir;
- }
-
- GrColor lightColor = lightingFP.lightColor();
- if (lightColor != fLightColor) {
- GrGLfloat c[4];
- GrColorToRGBAFloat(lightColor, c);
- pdman.set4fv(fLightColorUni, 1, c);
- fLightColor = lightColor;
- }
-
- GrColor ambientColor = lightingFP.ambientColor();
- if (ambientColor != fAmbientColor) {
- GrGLfloat c[4];
- GrColorToRGBAFloat(ambientColor, c);
- pdman.set4fv(fAmbientColorUni, 1, c);
- fAmbientColor = ambientColor;
- }
- }
-
- static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
- GrProcessorKeyBuilder* b) {
-// const LightingFP& lightingFP = proc.cast<LightingFP>();
- // only one shader generated currently
- b->add32(0x0);
- }
-
- private:
- SkVector3 fLightDir;
- GrGLProgramDataManager::UniformHandle fLightDirUni;
-
- GrColor fLightColor;
- GrGLProgramDataManager::UniformHandle fLightColorUni;
-
- GrColor fAmbientColor;
- GrGLProgramDataManager::UniformHandle fAmbientColorUni;
- };
-
- GrGLFragmentProcessor* createGLInstance() const override { return SkNEW(LightingGLFP); }
-
- void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
- LightingGLFP::GenKey(*this, caps, b);
- }
-
- const char* name() const override { return "LightingFP"; }
-
- void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->mulByUnknownFourComponents();
- }
-
- SkVector3 lightDir() const { return fLightDir; }
- GrColor lightColor() const { return fLightColor; }
- GrColor ambientColor() const { return fAmbientColor; }
-
-private:
- bool onIsEqual(const GrFragmentProcessor& proc) const override {
- const LightingFP& lightingFP = proc.cast<LightingFP>();
- return fDeviceTransform == lightingFP.fDeviceTransform &&
- fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
- fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
- fLightDir == lightingFP.fLightDir &&
- fLightColor == lightingFP.fLightColor &&
- fAmbientColor == lightingFP.fAmbientColor;
- }
-
- GrCoordTransform fDeviceTransform;
- GrTextureAccess fDiffuseTextureAccess;
- GrTextureAccess fNormalTextureAccess;
- SkVector3 fLightDir;
- GrColor fLightColor;
- GrColor fAmbientColor;
-};
-
-bool LightingShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* color, GrProcessorDataManager*,
- 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 lmInverse;
- if (!this->getLocalMatrix().invert(&lmInverse)) {
- 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;
-
- }
-
- // TODO: support other tile modes
- GrTextureParams params(kClamp_TileMode, textureFilterMode);
- SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, fDiffuseMap, ¶ms));
- if (!diffuseTexture) {
- SkErrorInternals::SetError(kInternalError_SkError,
- "Couldn't convert bitmap to texture.");
- return false;
- }
-
- SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, ¶ms));
- if (!normalTexture) {
- SkErrorInternals::SetError(kInternalError_SkError,
- "Couldn't convert bitmap to texture.");
- return false;
- }
-
- GrColor lightColor = GrColorPackRGBA(SkColorGetR(fLight.fColor), SkColorGetG(fLight.fColor),
- SkColorGetB(fLight.fColor), SkColorGetA(fLight.fColor));
- GrColor ambientColor = GrColorPackRGBA(SkColorGetR(fAmbientColor), SkColorGetG(fAmbientColor),
- SkColorGetB(fAmbientColor), SkColorGetA(fAmbientColor));
-
- *fp = SkNEW_ARGS(LightingFP, (diffuseTexture, normalTexture, matrix,
- fLight.fDirection, lightColor, ambientColor));
- *color = GrColorPackA4(paint.getAlpha());
- return true;
-}
+#include "SkImageDecoder.h"
+#include "SkLightingShader.h"
////////////////////////////////////////////////////////////////////////////
class LightingView : public SampleView {
public:
- SkAutoTUnref<LightingShader> fShader;
- SkBitmap fDiffuseBitmap;
- SkBitmap fNormalBitmap;
- SkScalar fLightAngle;
- int fColorFactor;
+ SkAutoTUnref<SkShader> fShader;
+ SkBitmap fDiffuseBitmap;
+ SkBitmap fNormalBitmap;
+ SkScalar fLightAngle;
+ int fColorFactor;
+ SkColor fAmbientColor;
LightingView() {
SkString diffusePath = GetResourcePath("brickwork-texture.jpg");
fLightAngle = 0.0f;
fColorFactor = 0;
- LightingShader::Light light;
+ SkLightingShader::Light light;
light.fColor = SkColorSetRGB(0xff, 0xff, 0xff);
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);
- SkColor ambient = SkColorSetRGB(0x1f, 0x1f, 0x1f);
+ fAmbientColor = SkColorSetRGB(0x1f, 0x1f, 0x1f);
- fShader.reset(SkNEW_ARGS(LightingShader, (fDiffuseBitmap, fNormalBitmap, light, ambient)));
+ fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
+ light, fAmbientColor));
}
virtual ~LightingView() {}
fLightAngle += 0.015f;
fColorFactor++;
- LightingShader::Light light;
+ SkLightingShader::Light light;
light.fColor = SkColorSetRGB(0xff, 0xff, (fColorFactor >> 1) & 0xff);
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);
- fShader.get()->setLight(light);
+ fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
+ light, fAmbientColor));
SkPaint paint;
paint.setShader(fShader);
#include "effects/GrBicubicEffect.h"
#endif
-bool SkBitmapProcShader::CanDo(const SkBitmap& bm, TileMode tx, TileMode ty) {
- switch (bm.colorType()) {
- case kAlpha_8_SkColorType:
- case kRGB_565_SkColorType:
- case kIndex_8_SkColorType:
- case kN32_SkColorType:
- // if (tx == ty && (kClamp_TileMode == tx || kRepeat_TileMode == tx))
- return true;
- default:
- break;
- }
- return false;
-}
-
SkBitmapProcShader::SkBitmapProcShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
const SkMatrix* localMatrix)
: INHERITED(localMatrix) {
// returns true and set color if the bitmap can be drawn as a single color
// (for efficiency)
-static bool canUseColorShader(const SkBitmap& bm, SkColor* color) {
+static bool can_use_color_shader(const SkBitmap& bm, SkColor* color) {
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
// HWUI does not support color shaders (see b/22390304)
return false;
return false;
}
-static bool bitmapIsTooBig(const SkBitmap& bm) {
+static bool bitmap_is_too_big(const SkBitmap& bm) {
// SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it
// communicates between its matrix-proc and its sampler-proc. Until we can
// widen that, we have to reject bitmaps that are larger.
//
- const int maxSize = 65535;
+ static const int kMaxSize = 65535;
- return bm.width() > maxSize || bm.height() > maxSize;
+ return bm.width() > kMaxSize || bm.height() > kMaxSize;
}
SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
SkTBlitterAllocator* allocator) {
SkShader* shader;
SkColor color;
- if (src.isNull() || bitmapIsTooBig(src)) {
+ if (src.isNull() || bitmap_is_too_big(src)) {
if (NULL == allocator) {
shader = SkNEW(SkEmptyShader);
} else {
shader = allocator->createT<SkEmptyShader>();
}
- }
- else if (canUseColorShader(src, &color)) {
+ } else if (can_use_color_shader(src, &color)) {
if (NULL == allocator) {
shader = SkNEW_ARGS(SkColorShader, (color));
} else {
size_t contextSize() const override;
- static bool CanDo(const SkBitmap&, TileMode tx, TileMode ty);
-
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapProcShader)
// The context takes ownership of the state. It will call its destructor
// but will NOT free the memory.
BitmapProcShaderContext(const SkBitmapProcShader&, const ContextRec&, SkBitmapProcState*);
- virtual ~BitmapProcShaderContext();
+ ~BitmapProcShaderContext() override;
void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
ShadeProc asAShadeProc(void** ctx) override;
// an Sk3DBlitter in SkDraw.cpp
// Note that some contexts may contain other contexts (e.g. for compose shaders), but we've not
// yet found a situation where the size below isn't big enough.
-typedef SkSmallAllocator<3, 1024> SkTBlitterAllocator;
+typedef SkSmallAllocator<3, 1152> SkTBlitterAllocator;
// If alloc is non-NULL, it will be used to allocate the returned SkShader, and MUST outlive
// the SkShader.
private:
friend class SkBitmapProcShader;
+ friend class SkLightingShaderImpl;
ShaderProc32 fShaderProc32; // chooseProcs
ShaderProc16 fShaderProc16; // chooseProcs
--- /dev/null
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkBitmapProcState.h"
+#include "SkColor.h"
+#include "SkEmptyShader.h"
+#include "SkErrorInternals.h"
+#include "SkLightingShader.h"
+#include "SkMathPriv.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ SkLightingShader TODOs:
+ support other than clamp mode
+ allow 'diffuse' & 'normal' to be of different dimensions?
+ support different light types
+ support multiple lights
+ enforce normal map is 4 channel
+ use SkImages instead if SkBitmaps
+ vec3 for ambient and light-color
+ add dox for both lighting equation, and how we compute normal from bitmap
+
+ To Test:
+ non-opaque diffuse textures
+ A8 diffuse textures
+ down & upsampled draws
+*/
+
+
+
+/** \class SkLightingShaderImpl
+ This subclass of shader applies lighting.
+*/
+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
+ */
+ SkLightingShaderImpl(const SkBitmap& diffuse, const SkBitmap& normal,
+ const SkLightingShader::Light& light,
+ const SkColor ambient)
+ : fDiffuseMap(diffuse)
+ , fNormalMap(normal)
+ , fLight(light)
+ , fAmbientColor(ambient) {
+ if (!fLight.fDirection.normalize()) {
+ fLight.fDirection = SkPoint3::Make(0.0f, 0.0f, 1.0f);
+ }
+ SkColorSetA(fLight.fColor, 0xFF);
+ SkColorSetA(fAmbientColor, 0xFF);
+ }
+
+ bool isOpaque() const override;
+
+ bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
+ const SkMatrix* localMatrix, GrColor* color,
+ GrProcessorDataManager*, GrFragmentProcessor** fp) const override;
+
+ size_t contextSize() const override;
+
+ class LightingShaderContext : public SkShader::Context {
+ public:
+ // The context takes ownership of the states. It will call their destructors
+ // but will NOT free the memory.
+ LightingShaderContext(const SkLightingShaderImpl&, const ContextRec&,
+ SkBitmapProcState* diffuseState, SkBitmapProcState* normalState);
+ ~LightingShaderContext() override;
+
+ void shadeSpan(int x, int y, SkPMColor[], int count) override;
+
+ uint32_t getFlags() const override { return fFlags; }
+
+ private:
+ SkBitmapProcState* fDiffuseState;
+ SkBitmapProcState* fNormalState;
+ uint32_t fFlags;
+
+ typedef SkShader::Context INHERITED;
+ };
+
+ SK_TO_STRING_OVERRIDE()
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(LightingShader)
+
+protected:
+ void flatten(SkWriteBuffer&) const override;
+ Context* onCreateContext(const ContextRec&, void*) const override;
+
+private:
+ SkBitmap fDiffuseMap;
+ SkBitmap fNormalMap;
+ SkLightingShader::Light fLight;
+ SkColor fAmbientColor; // linear (unpremul) color
+
+ typedef SkShader INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////
+
+#if SK_SUPPORT_GPU
+
+#include "GrCoordTransform.h"
+#include "GrFragmentProcessor.h"
+#include "GrTextureAccess.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
+#include "SkGr.h"
+
+class LightingFP : public GrFragmentProcessor {
+public:
+ LightingFP(GrTexture* diffuse, GrTexture* normal, const SkMatrix& matrix,
+ SkVector3 lightDir, GrColor lightColor, GrColor ambientColor)
+ : fDeviceTransform(kDevice_GrCoordSet, matrix)
+ , fDiffuseTextureAccess(diffuse)
+ , fNormalTextureAccess(normal)
+ , fLightDir(lightDir)
+ , fLightColor(lightColor)
+ , fAmbientColor(ambientColor) {
+ this->addCoordTransform(&fDeviceTransform);
+ this->addTextureAccess(&fDiffuseTextureAccess);
+ this->addTextureAccess(&fNormalTextureAccess);
+
+ this->initClassID<LightingFP>();
+ }
+
+ class LightingGLFP : public GrGLFragmentProcessor {
+ public:
+ LightingGLFP() : fLightColor(GrColor_ILLEGAL), fAmbientColor(GrColor_ILLEGAL) {
+ fLightDir.fX = 10000.0f;
+ }
+
+ void emitCode(EmitArgs& args) override {
+
+ GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
+
+ // add uniforms
+ const char* lightDirUniName = NULL;
+ fLightDirUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ kVec3f_GrSLType, kDefault_GrSLPrecision,
+ "LightDir", &lightDirUniName);
+
+ const char* lightColorUniName = NULL;
+ fLightColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ kVec4f_GrSLType, kDefault_GrSLPrecision,
+ "LightColor", &lightColorUniName);
+
+ const char* ambientColorUniName = NULL;
+ fAmbientColorUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+ kVec4f_GrSLType, kDefault_GrSLPrecision,
+ "AmbientColor", &ambientColorUniName);
+
+ fpb->codeAppend("vec4 diffuseColor = ");
+ fpb->appendTextureLookupAndModulate(args.fInputColor, args.fSamplers[0],
+ args.fCoords[0].c_str(),
+ args.fCoords[0].getType());
+ fpb->codeAppend(";");
+
+ fpb->codeAppend("vec4 normalColor = ");
+ fpb->appendTextureLookup(args.fSamplers[1],
+ args.fCoords[0].c_str(),
+ args.fCoords[0].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);");
+ // diffuse light
+ fpb->codeAppendf("vec3 result = %s.rgb*diffuseColor.rgb*NdotL;", lightColorUniName);
+ // ambient light
+ fpb->codeAppendf("result += %s.rgb;", ambientColorUniName);
+ fpb->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOutputColor);
+ }
+
+ void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
+ const LightingFP& lightingFP = proc.cast<LightingFP>();
+
+ SkVector3 lightDir = lightingFP.lightDir();
+ if (lightDir != fLightDir) {
+ pdman.set3fv(fLightDirUni, 1, &lightDir.fX);
+ fLightDir = lightDir;
+ }
+
+ GrColor lightColor = lightingFP.lightColor();
+ if (lightColor != fLightColor) {
+ GrGLfloat c[4];
+ GrColorToRGBAFloat(lightColor, c);
+ pdman.set4fv(fLightColorUni, 1, c);
+ fLightColor = lightColor;
+ }
+
+ GrColor ambientColor = lightingFP.ambientColor();
+ if (ambientColor != fAmbientColor) {
+ GrGLfloat c[4];
+ GrColorToRGBAFloat(ambientColor, c);
+ pdman.set4fv(fAmbientColorUni, 1, c);
+ fAmbientColor = ambientColor;
+ }
+ }
+
+ static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
+ GrProcessorKeyBuilder* b) {
+// const LightingFP& lightingFP = proc.cast<LightingFP>();
+ // only one shader generated currently
+ b->add32(0x0);
+ }
+
+ private:
+ SkVector3 fLightDir;
+ GrGLProgramDataManager::UniformHandle fLightDirUni;
+
+ GrColor fLightColor;
+ GrGLProgramDataManager::UniformHandle fLightColorUni;
+
+ GrColor fAmbientColor;
+ GrGLProgramDataManager::UniformHandle fAmbientColorUni;
+ };
+
+ GrGLFragmentProcessor* createGLInstance() const override { return SkNEW(LightingGLFP); }
+
+ void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
+ LightingGLFP::GenKey(*this, caps, b);
+ }
+
+ const char* name() const override { return "LightingFP"; }
+
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
+ inout->mulByUnknownFourComponents();
+ }
+
+ SkVector3 lightDir() const { return fLightDir; }
+ GrColor lightColor() const { return fLightColor; }
+ GrColor ambientColor() const { return fAmbientColor; }
+
+private:
+ bool onIsEqual(const GrFragmentProcessor& proc) const override {
+ const LightingFP& lightingFP = proc.cast<LightingFP>();
+ return fDeviceTransform == lightingFP.fDeviceTransform &&
+ fDiffuseTextureAccess == lightingFP.fDiffuseTextureAccess &&
+ fNormalTextureAccess == lightingFP.fNormalTextureAccess &&
+ fLightDir == lightingFP.fLightDir &&
+ fLightColor == lightingFP.fLightColor &&
+ fAmbientColor == lightingFP.fAmbientColor;
+ }
+
+ GrCoordTransform fDeviceTransform;
+ GrTextureAccess fDiffuseTextureAccess;
+ GrTextureAccess fNormalTextureAccess;
+ SkVector3 fLightDir;
+ GrColor fLightColor;
+ GrColor fAmbientColor;
+};
+
+////////////////////////////////////////////////////////////////////////////
+
+bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint,
+ const SkMatrix& viewM, const SkMatrix* localMatrix,
+ GrColor* color, GrProcessorDataManager*,
+ 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 lmInverse;
+ if (!this->getLocalMatrix().invert(&lmInverse)) {
+ 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;
+
+ }
+
+ // TODO: support other tile modes
+ GrTextureParams params(kClamp_TileMode, textureFilterMode);
+ SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, fDiffuseMap, ¶ms));
+ if (!diffuseTexture) {
+ SkErrorInternals::SetError(kInternalError_SkError,
+ "Couldn't convert bitmap to texture.");
+ return false;
+ }
+
+ SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, ¶ms));
+ if (!normalTexture) {
+ SkErrorInternals::SetError(kInternalError_SkError,
+ "Couldn't convert bitmap to texture.");
+ return false;
+ }
+
+ GrColor lightColor = GrColorPackRGBA(SkColorGetR(fLight.fColor), SkColorGetG(fLight.fColor),
+ SkColorGetB(fLight.fColor), SkColorGetA(fLight.fColor));
+ GrColor ambientColor = GrColorPackRGBA(SkColorGetR(fAmbientColor), SkColorGetG(fAmbientColor),
+ SkColorGetB(fAmbientColor), SkColorGetA(fAmbientColor));
+
+ *fp = SkNEW_ARGS(LightingFP, (diffuseTexture, normalTexture, matrix,
+ fLight.fDirection, lightColor, ambientColor));
+ *color = GrColorPackA4(paint.getAlpha());
+ return true;
+}
+#else
+
+bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint,
+ const SkMatrix& viewM, const SkMatrix* localMatrix,
+ GrColor* color, GrProcessorDataManager*,
+ GrFragmentProcessor** fp) const {
+ SkDEBUGFAIL("Should not call in GPU-less build");
+ return false;
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+
+bool SkLightingShaderImpl::isOpaque() const {
+ return fDiffuseMap.isOpaque();
+}
+
+size_t SkLightingShaderImpl::contextSize() const {
+ return 2 * sizeof(SkBitmapProcState) + sizeof(LightingShaderContext);
+}
+
+SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(const SkLightingShaderImpl& shader,
+ const ContextRec& rec,
+ SkBitmapProcState* diffuseState,
+ SkBitmapProcState* normalState)
+ : INHERITED(shader, rec)
+ , fDiffuseState(diffuseState)
+ , fNormalState(normalState)
+{
+ const SkPixmap& pixmap = fDiffuseState->fPixmap;
+ bool isOpaque = pixmap.isOpaque();
+
+ // update fFlags
+ uint32_t flags = 0;
+ if (isOpaque && (255 == this->getPaintAlpha())) {
+ flags |= kOpaqueAlpha_Flag;
+ }
+
+ fFlags = flags;
+}
+
+SkLightingShaderImpl::LightingShaderContext::~LightingShaderContext() {
+ // The bitmap proc states have been created outside of the context on memory that will be freed
+ // elsewhere. Call the destructors but leave the freeing of the memory to the caller.
+ fDiffuseState->~SkBitmapProcState();
+ fNormalState->~SkBitmapProcState();
+}
+
+static inline int light(int light, int diff, SkScalar NdotL, int ambient) {
+ int color = int(light * diff * NdotL + 255 * ambient);
+ if (color <= 0) {
+ return 0;
+ } else if (color >= 255*255) {
+ return 255;
+ } else {
+ return SkDiv255Round(color);
+ }
+}
+
+// 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)
+#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];
+
+ SkBitmapProcState::MatrixProc diffMProc = fDiffuseState->getMatrixProc();
+ SkBitmapProcState::SampleProc32 diffSProc = fDiffuseState->getSampleProc32();
+
+ SkBitmapProcState::MatrixProc normalMProc = fNormalState->getMatrixProc();
+ SkBitmapProcState::SampleProc32 normalSProc = fNormalState->getSampleProc32();
+
+ SkASSERT(fDiffuseState->fPixmap.addr());
+ SkASSERT(fNormalState->fPixmap.addr());
+
+ SkPoint3 norm;
+ SkScalar NdotL;
+ int r, g, b;
+
+ do {
+ int n = count;
+ if (n > TMP_COUNT) {
+ n = TMP_COUNT;
+ }
+
+ diffMProc(*fDiffuseState, tmpColor, n, x, y);
+ diffSProc(*fDiffuseState, tmpColor, n, tmpColor2);
+
+ normalMProc(*fNormalState, tmpNormal, n, x, y);
+ normalSProc(*fNormalState, tmpNormal, n, tmpNormal2);
+
+ for (int i = 0; i < n; ++i) {
+ SkASSERT(0xFF == SkColorGetA(tmpNormal2[i])); // opaque -> unpremul
+ norm.set(SkIntToScalar(SkColorGetR(tmpNormal2[i]))-127.0f,
+ SkIntToScalar(SkColorGetG(tmpNormal2[i]))-127.0f,
+ SkIntToScalar(SkColorGetB(tmpNormal2[i]))-127.0f);
+ norm.normalize();
+
+ SkColor diffColor = SkUnPreMultiply::PMColorToColor(tmpColor2[i]);
+ NdotL = norm.dot(lightShader.fLight.fDirection);
+
+ // This is all done in linear unpremul color space
+ r = light(SkColorGetR(lightShader.fLight.fColor), SkColorGetR(diffColor), NdotL,
+ SkColorGetR(lightShader.fAmbientColor));
+ g = light(SkColorGetG(lightShader.fLight.fColor), SkColorGetG(diffColor), NdotL,
+ SkColorGetG(lightShader.fAmbientColor));
+ b = light(SkColorGetB(lightShader.fLight.fColor), SkColorGetB(diffColor), NdotL,
+ SkColorGetB(lightShader.fAmbientColor));
+
+ result[i] = SkPreMultiplyARGB(SkColorGetA(diffColor), r, g, b);
+ }
+
+ result += n;
+ x += n;
+ count -= n;
+ } while (count > 0);
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef SK_IGNORE_TO_STRING
+void SkLightingShaderImpl::toString(SkString* str) const {
+ str->appendf("LightingShader: ()");
+}
+#endif
+
+SkFlattenable* SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
+ SkBitmap diffuse;
+ if (!buf.readBitmap(&diffuse)) {
+ return NULL;
+ }
+ diffuse.setImmutable();
+
+ SkBitmap normal;
+ if (!buf.readBitmap(&normal)) {
+ return NULL;
+ }
+ normal.setImmutable();
+
+ SkLightingShader::Light light;
+ if (!buf.readScalarArray(&light.fDirection.fX, 3)) {
+ return NULL;
+ }
+ light.fColor = buf.readColor();
+
+ SkColor ambient = buf.readColor();
+
+ // TODO: this would be nice to enable
+ // return SkCreateLightingShader(diffuse, normal, light, ambient, NULL);
+ return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient));
+}
+
+void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
+ buf.writeBitmap(fDiffuseMap);
+ buf.writeBitmap(fNormalMap);
+ buf.writeScalarArray(&fLight.fDirection.fX, 3);
+ buf.writeColor(fLight.fColor);
+ buf.writeColor(fAmbientColor);
+}
+
+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)) {
+ return NULL;
+ }
+
+ void* diffuseStateStorage = (char*)storage + sizeof(LightingShaderContext);
+ SkBitmapProcState* diffuseState = SkNEW_PLACEMENT(diffuseStateStorage, SkBitmapProcState);
+ SkASSERT(diffuseState);
+
+ diffuseState->fTileModeX = SkShader::kClamp_TileMode;
+ diffuseState->fTileModeY = SkShader::kClamp_TileMode;
+ diffuseState->fOrigBitmap = fDiffuseMap;
+ if (!diffuseState->chooseProcs(totalInverse, *rec.fPaint)) {
+ diffuseState->~SkBitmapProcState();
+ return NULL;
+ }
+
+ void* normalStateStorage = (char*)storage + sizeof(LightingShaderContext) + sizeof(SkBitmapProcState);
+ SkBitmapProcState* normalState = SkNEW_PLACEMENT(normalStateStorage, SkBitmapProcState);
+ SkASSERT(normalState);
+
+ normalState->fTileModeX = SkShader::kClamp_TileMode;
+ normalState->fTileModeY = SkShader::kClamp_TileMode;
+ normalState->fOrigBitmap = fNormalMap;
+ if (!normalState->chooseProcs(totalInverse, *rec.fPaint)) {
+ diffuseState->~SkBitmapProcState();
+ normalState->~SkBitmapProcState();
+ return NULL;
+ }
+
+ return SkNEW_PLACEMENT_ARGS(storage, LightingShaderContext, (*this, rec,
+ diffuseState, normalState));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool bitmap_is_too_big(const SkBitmap& bm) {
+ // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it
+ // communicates between its matrix-proc and its sampler-proc. Until we can
+ // widen that, we have to reject bitmaps that are larger.
+ //
+ static const int kMaxSize = 65535;
+
+ return bm.width() > kMaxSize || bm.height() > kMaxSize;
+}
+
+SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& normal,
+ const SkLightingShader::Light& light,
+ const SkColor ambient) {
+ if (diffuse.isNull() || bitmap_is_too_big(diffuse) ||
+ normal.isNull() || bitmap_is_too_big(normal) ||
+ diffuse.width() != normal.width() ||
+ diffuse.height() != normal.height()) {
+ return nullptr;
+ }
+
+ return SkNEW_ARGS(SkLightingShaderImpl, (diffuse, normal, light, ambient));
+}
+
+///////////////////////////////////////////////////////////////////////////////
--- /dev/null
+
+/*
+ * 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 SkLightingShader_DEFINED
+#define SkLightingShader_DEFINED
+
+#include "SkPoint3.h"
+#include "SkShader.h"
+
+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).
+ SkColor fColor; // linear (unpremul) color. Note: alpha assumed to be 255.
+ };
+
+ /** Returns a shader that lights the diffuse and normal maps with a single light.
+
+ It returns a shader with a reference count of 1.
+ The caller should decrement the shader's reference count when done with the shader.
+ It is an error for count to be < 2.
+ @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. Note: alpha assumed to be 255.
+
+ NULL will be returned if:
+ either 'diffuse' or 'normal' are empty
+ either 'diffuse' or 'normal' are too big (> 65535 on a side)
+ 'diffuse' and 'normal' aren't the same size
+ */
+ static SkShader* Create(const SkBitmap& diffuse, const SkBitmap& normal,
+ const SkLightingShader::Light& light, const SkColor ambient);
+
+ SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
+};
+
+#endif
projects / platform / upstream / libSkiaSharp.git / commitdiff