diff options
Diffstat (limited to 'samplecode')
| -rwxr-xr-x | samplecode/SampleLighting.cpp | 429 |
1 files changed, 429 insertions, 0 deletions
diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp new file mode 100755 index 0000000000..40e6fbb073 --- /dev/null +++ b/samplecode/SampleLighting.cpp @@ -0,0 +1,429 @@ + +/* + * 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 "SampleCode.h" +#include "Resources.h" + +#include "SkCanvas.h" +#include "SkErrorInternals.h" +#include "SkGr.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" + +/////////////////////////////////////////////////////////////////////////////// + +struct SkVector3 { + SkScalar fX, fY, fZ; + + bool operator==(const SkVector3& other) const { + return fX == other.fX && fY == other.fY && fZ == other.fZ; + } + + bool operator!=(const SkVector3& other) const { + return !(*this == other); + } +}; + +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(GrGLFPBuilder* builder, + const GrFragmentProcessor& fp, + const char* outputColor, + const char* inputColor, + const TransformedCoordsArray& coords, + const TextureSamplerArray& samplers) override { + + GrGLFragmentBuilder* fpb = builder->getFragmentShaderBuilder(); + + // add uniforms + const char* lightDirUniName = NULL; + fLightDirUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, + kVec3f_GrSLType, kDefault_GrSLPrecision, + "LightDir", &lightDirUniName); + + const char* lightColorUniName = NULL; + fLightColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, + kVec4f_GrSLType, kDefault_GrSLPrecision, + "LightColor", &lightColorUniName); + + const char* ambientColorUniName = NULL; + fAmbientColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, + kVec4f_GrSLType, kDefault_GrSLPrecision, + "AmbientColor", &ambientColorUniName); + + fpb->codeAppend("vec4 diffuseColor = "); + fpb->appendTextureLookupAndModulate(inputColor, samplers[0], + coords[0].c_str(), coords[0].getType()); + fpb->codeAppend(";"); + + fpb->codeAppend("vec4 normalColor = "); + fpb->appendTextureLookup(samplers[1], coords[0].c_str(), coords[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);", outputColor); + } + + 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; +} + +//////////////////////////////////////////////////////////////////////////// + +class LightingView : public SampleView { +public: + SkAutoTUnref<LightingShader> fShader; + SkBitmap fDiffuseBitmap; + SkBitmap fNormalBitmap; + SkScalar fLightAngle; + int fColorFactor; + + LightingView() { + SkString diffusePath = GetResourcePath("brickwork-texture.jpg"); + SkImageDecoder::DecodeFile(diffusePath.c_str(), &fDiffuseBitmap); + SkString normalPath = GetResourcePath("brickwork_normal-map.jpg"); + SkImageDecoder::DecodeFile(normalPath.c_str(), &fNormalBitmap); + + fLightAngle = 0.0f; + fColorFactor = 0; + + LightingShader::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); + + fShader.reset(SkNEW_ARGS(LightingShader, (fDiffuseBitmap, fNormalBitmap, light, ambient))); + } + + virtual ~LightingView() {} + +protected: + // overrides from SkEventSink + bool onQuery(SkEvent* evt) override { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Lighting"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void onDrawContent(SkCanvas* canvas) override { + fLightAngle += 0.015f; + fColorFactor++; + + LightingShader::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); + + SkPaint paint; + paint.setShader(fShader); + paint.setColor(SK_ColorBLACK); + + SkRect r = SkRect::MakeWH((SkScalar)fDiffuseBitmap.width(), + (SkScalar)fDiffuseBitmap.height()); + canvas->drawRect(r, paint); + + // so we're constantly updating + this->inval(NULL); + } + + SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y, modi); + } + +private: + typedef SampleView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new LightingView; } +static SkViewRegister reg(MyFactory); |