Add normal map sample

samplecode/SampleLighting.cpp

Index: samplecode/SampleLighting.cpp
diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..db0976ca5305308ef470862ff6b7d9509c7a2ace
--- /dev/null
+++ b/samplecode/SampleLighting.cpp
@@ -0,0 +1,391 @@
+
+/*
+ * 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 x, y, z;
+
+    bool operator!=(const SkVector3& other) {
+        return x != other.x || y != other.y || z != other.z;
+    }
+};
+
+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.writeMatrix(fDeviceMatrix);
+    }
+
+    bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
+        const SkMatrix* localMatrix, GrColor* color,
+        GrFragmentProcessor** fp) const override;
+
+#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) {
+    //SkMatrix matrix;
+    //buf.readMatrix(&matrix);
+    //return SkNEW_ARGS(LightingShader, (matrix));
+
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+class LightingFP : public GrFragmentProcessor {
+public:
+    LightingFP(GrTexture* diffuse, GrTexture* normal, const SkMatrix& matrix,
+               SkVector3 lightDir, GrColor lightColor, GrColor ambientColor)
+        : fDiffuseTextureAccess(diffuse)
+        , fNormalTextureAccess(normal)
+        , fDeviceTransform(kDevice_GrCoordSet, matrix)
+        , fLightDir(lightDir)
+        , fLightColor(lightColor)
+        , fAmbientColor(ambientColor) {
+        this->addCoordTransform(&fDeviceTransform);
+        this->addTextureAccess(&fDiffuseTextureAccess);
+        this->addTextureAccess(&fNormalTextureAccess);
+
+        this->initClassID<LightingFP>();
+    }
+

[robertphillips, 2015/07/08 16:15:14]

one line ?
Is this right ?

[jvanverth1, 2015/07/08 19:58:06]

I think it's okay, but added the full GenKey() code for extensibility.

+    void getGLProcessorKey(const GrGLSLCaps& caps,
+        GrProcessorKeyBuilder* b) const override {}
+
+    GrGLFragmentProcessor* createGLInstance() const override {
+        class LightingGLFP : public GrGLFragmentProcessor {
+        public:
+            LightingGLFP() 
+                : fLightColor(GrColor_ILLEGAL) {
+                fLightDir.x = 10000.0f;
+            }
+
+            void emitCode(GrGLFPBuilder* builder,

[robertphillips, 2015/07/08 16:15:14]

tab these over ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+            const GrFragmentProcessor& fp,
+            const char* outputColor,
+            const char* inputColor,
+            const TransformedCoordsArray& coords,

[robertphillips, 2015/07/08 16:15:14]

override ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+            const TextureSamplerArray& samplers) {
+
+                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,

[robertphillips, 2015/07/08 16:15:14]

tabs ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+                    kVec4f_GrSLType, kDefault_GrSLPrecision,
+                    "AmbientColor", &ambientColorUniName);
+
+                fpb->codeAppend("vec4 diffuseColor = ");
+                fpb->appendTextureLookupAndModulate(inputColor,

[robertphillips, 2015/07/08 16:15:14]

tabs ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+                    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.x);
+                    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;
+                }
+            }
+        private:
+            SkVector3 fLightDir;
+            GrGLProgramDataManager::UniformHandle fLightDirUni;
+
+            GrColor fLightColor;
+            GrGLProgramDataManager::UniformHandle fLightColorUni;
+
+            GrColor fAmbientColor;
+            GrGLProgramDataManager::UniformHandle fAmbientColorUni;
+        };
+        return SkNEW(LightingGLFP);
+    }
+
+    const char* name() const override { return "LightingGLFP"; }
+
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
+        inout->mulByUnknownFourComponents();
+    }
+
+    SkVector3 lightDir() const { return fLightDir; }
+    GrColor lightColor() const { return fLightColor; }
+    GrColor ambientColor() const { return fAmbientColor; }
+
+private:

[robertphillips, 2015/07/08 16:15:14]

??

[jvanverth1, 2015/07/08 19:58:06]

Done.

+    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
+
+    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, 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, &params));
+    if (!diffuseTexture) {
+        SkErrorInternals::SetError(kInternalError_SkError,
+            "Couldn't convert bitmap to texture.");
+        return false;
+    }
+
+    SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, &params));
+    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:

[robertphillips, 2015/07/08 16:15:14]

Can this be an AutoTUnref ?

[jvanverth1, 2015/07/08 19:58:06]

Done, I think.

+    SkShader*   fShader;
+    SkBitmap    fDiffuseBitmap;
+    SkBitmap    fNormalBitmap;
+    SkScalar    fLightAngle;
+    SkScalar    fAngleDelta;
+
+    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.785f;
+        fAngleDelta = -0.01f;
+
+        LightingShader::Light light;
+        light.fColor = SkColorSetRGB(0xff, 0xff, 0xff);
+        light.fDirection.x = 0;
+        light.fDirection.y = SkScalarSin(fLightAngle);
+        light.fDirection.z = SkScalarCos(fLightAngle);
+
+        SkColor ambient = SkColorSetRGB(0x1f, 0x1f, 0x1f);
+
+        fShader = new LightingShader(fDiffuseBitmap, fNormalBitmap, light, ambient);
+    }
+
+    virtual ~LightingView() {
+        SkSafeUnref(fShader);
+    }
+
+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 += fAngleDelta;
+        if (fLightAngle > 0.785f)  {
+            fAngleDelta = -0.01f;
+        } else if (fLightAngle < -0.785f) {
+            fAngleDelta = 0.01f;
+        }
+

[robertphillips, 2015/07/08 16:15:14]

Color animation ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+        LightingShader::Light light;
+        light.fColor = SkColorSetRGB(0xff, 0xff, 0xff);
+        light.fDirection.x = 0;
+        light.fDirection.y = SkScalarSin(fLightAngle);
+        light.fDirection.z = SkScalarCos(fLightAngle);
+

[robertphillips, 2015/07/08 16:15:14]

Can we just store it as a LightingShader ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+        reinterpret_cast<LightingShader*>(fShader)->setLight(light);
+
+        SkPaint paint;
+        paint.setShader(fShader);
+
+        SkRect  r;
+        int w = fDiffuseBitmap.width();
+        int h = fDiffuseBitmap.height();
+        r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h));
+
+        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);
+    }
+

[robertphillips, 2015/07/08 16:15:14]

rm this ?

[jvanverth1, 2015/07/08 19:58:06]

Done.

+    bool onClick(Click* click)  override {
+        return this->INHERITED::onClick(click);
+    }
+
+private:
+    typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LightingView; }
+static SkViewRegister reg(MyFactory);