Making a sample for shadow maps for more intensive development

src/core/SkShadowShader.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkLights.h"
 #include "SkReadBuffer.h"
 #include "SkShadowShader.h"
 #include "SkPoint3.h"
 
 ////////////////////////////////////////////////////////////////////////////
 #ifdef SK_EXPERIMENTAL_SHADOWING
 
-#define SK_MAX_NON_AMBIENT_LIGHTS 4
 
 /** \class SkShadowShaderImpl
     This subclass of shader applies shadowing
 */
 class SkShadowShaderImpl : public SkShader {
 public:
     /** Create a new shadowing shader that shadows
         @param to do        to do
     */
     SkShadowShaderImpl(sk_sp<SkShader> povDepthShader,
@@ skipping 81 matching lines @@
              int diffuseWidth, int diffuseHeight,
              GrContext* context) {
 
         // fuse all ambient lights into a single one
         fAmbientColor.set(0.0f, 0.0f, 0.0f);
 
         fNumDirLights = 0; // refers to directional lights.
         for (int i = 0; i < lights->numLights(); ++i) {
             if (SkLights::Light::kAmbient_LightType == lights->light(i).type()) {
                 fAmbientColor += lights->light(i).color();
-            } else if (fNumDirLights < SK_MAX_NON_AMBIENT_LIGHTS){
+            } else if (fNumDirLights < SkShadowShader::kMaxNonAmbientLights) {
                 fLightColor[fNumDirLights] = lights->light(i).color();
                 fLightDir[fNumDirLights] = lights->light(i).dir();
-                SkImage_Base* shadowMap = ((SkImage_Base*)lights->light(i).getShadowMap().get());
+                SkImage_Base* shadowMap = ((SkImage_Base*)lights->light(i).getShadowMap());
 
-                // this sk_sp gets deleted when the ShadowFP is destroyed, and frees the GrTexture*
+                // gets deleted when the ShadowFP is destroyed, and frees the GrTexture*
                 fTexture[fNumDirLights] = sk_sp<GrTexture>(shadowMap->asTextureRef(context,
                                                            GrTextureParams::ClampNoFilter(),
                                                            SkSourceGammaTreatment::kIgnore));
                 fDepthMapAccess[fNumDirLights].reset(fTexture[fNumDirLights].get());
                 this->addTextureAccess(&fDepthMapAccess[fNumDirLights]);
 
                 fDepthMapHeight[fNumDirLights] = shadowMap->height();
                 fDepthMapWidth[fNumDirLights] = shadowMap->width();
 
                 fNumDirLights++;
@@ skipping 12 matching lines @@
     public:
         GLSLShadowFP() { }
 
         void emitCode(EmitArgs& args) override {
 
             GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             // add uniforms
             int32_t numLights = args.fFp.cast<ShadowFP>().fNumDirLights;
-            SkASSERT(numLights <= SK_MAX_NON_AMBIENT_LIGHTS);
+            SkASSERT(numLights <= SkShadowShader::kMaxNonAmbientLights);
 
-            const char* lightDirUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
-            const char* lightColorUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
+            const char* lightDirUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
+            const char* lightColorUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
 
-            const char* depthMapWidthUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
-            const char* depthMapHeightUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
+            const char* depthMapWidthUniName[SkShadowShader::kMaxNonAmbientLights]
+                    = {nullptr};
+            const char* depthMapHeightUniName[SkShadowShader::kMaxNonAmbientLights]
+                    = {nullptr};
 
             SkString lightDirUniNameBase("lightDir");
             SkString lightColorUniNameBase("lightColor");
 
             SkString depthMapWidthUniNameBase("dmapWidth");
             SkString depthMapHeightUniNameBase("dmapHeight");
 
             for (int i = 0; i < numLights; i++) {
                 SkString lightDirUniNameStr(lightDirUniNameBase);
                 lightDirUniNameStr.appendf("%d", i);
@@ skipping 41 matching lines @@
                                                     kDefault_GrSLPrecision,
                                                     "height", &heightUniName);
 
 
             SkString povDepth("povDepth");
             this->emitChild(0, nullptr, &povDepth, args);
 
             SkString diffuseColor("inDiffuseColor");
             this->emitChild(1, nullptr, &diffuseColor, args);
 
-            SkString depthMaps[SK_MAX_NON_AMBIENT_LIGHTS];
+            SkString depthMaps[SkShadowShader::kMaxNonAmbientLights];
 
             for (int i = 0; i < numLights; i++) {
                 SkString povCoord("povCoord");
                 povCoord.appendf("%d", i);
 
                 // vMatrixCoord_0_1_Stage0 is the texture sampler coordinates.
                 // povDepth.b * 255 scales it to 0 - 255, bringing it to world space,
                 // and the / 400 brings it back to a sampler coordinate, 0 - 1
                 // The 400 comes from the shadowmaps GM.
                 // TODO use real shadowmaps size
@@ skipping 111 matching lines @@
             }
 
             const SkColor3f& ambientColor = shadowFP.ambientColor();
             if (ambientColor != fAmbientColor) {
                 pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
                 fAmbientColor = ambientColor;
             }
         }
 
     private:
-        SkVector3 fLightDir[SK_MAX_NON_AMBIENT_LIGHTS];
-        GrGLSLProgramDataManager::UniformHandle fLightDirUni[SK_MAX_NON_AMBIENT_LIGHTS];
-        SkColor3f fLightColor[SK_MAX_NON_AMBIENT_LIGHTS];
-        GrGLSLProgramDataManager::UniformHandle fLightColorUni[SK_MAX_NON_AMBIENT_LIGHTS];
+        SkVector3 fLightDir[SkShadowShader::kMaxNonAmbientLights];
+        GrGLSLProgramDataManager::UniformHandle
+                fLightDirUni[SkShadowShader::kMaxNonAmbientLights];
 
-        int fDepthMapWidth[SK_MAX_NON_AMBIENT_LIGHTS];
-        GrGLSLProgramDataManager::UniformHandle fDepthMapWidthUni[SK_MAX_NON_AMBIENT_LIGHTS];
-        int fDepthMapHeight[SK_MAX_NON_AMBIENT_LIGHTS];
-        GrGLSLProgramDataManager::UniformHandle fDepthMapHeightUni[SK_MAX_NON_AMBIENT_LIGHTS];
+        SkColor3f fLightColor[SkShadowShader::kMaxNonAmbientLights];
+        GrGLSLProgramDataManager::UniformHandle
+                fLightColorUni[SkShadowShader::kMaxNonAmbientLights];
+
+        int fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
+        GrGLSLProgramDataManager::UniformHandle
+                fDepthMapWidthUni[SkShadowShader::kMaxNonAmbientLights];
+
+        int fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
+        GrGLSLProgramDataManager::UniformHandle
+                fDepthMapHeightUni[SkShadowShader::kMaxNonAmbientLights];
 
         int fWidth;
         GrGLSLProgramDataManager::UniformHandle fWidthUni;
         int fHeight;
         GrGLSLProgramDataManager::UniformHandle fHeightUni;
 
         SkColor3f fAmbientColor;
         GrGLSLProgramDataManager::UniformHandle fAmbientColorUni;
 
         int fNumDirLights;
@@ skipping 53 matching lines @@
                 fDepthMapHeight[i] != shadowFP.fDepthMapHeight[i]) {
                 return false;
             }
         }
 
         return true;
     }
 
     int              fNumDirLights;
 
-    SkVector3        fLightDir[SK_MAX_NON_AMBIENT_LIGHTS];
-    SkColor3f        fLightColor[SK_MAX_NON_AMBIENT_LIGHTS];
-    GrTextureAccess  fDepthMapAccess[SK_MAX_NON_AMBIENT_LIGHTS];
-    sk_sp<GrTexture> fTexture[SK_MAX_NON_AMBIENT_LIGHTS];
+    SkVector3        fLightDir[SkShadowShader::kMaxNonAmbientLights];
+    SkColor3f        fLightColor[SkShadowShader::kMaxNonAmbientLights];
+    GrTextureAccess  fDepthMapAccess[SkShadowShader::kMaxNonAmbientLights];
+    sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
 
-    int              fDepthMapWidth[SK_MAX_NON_AMBIENT_LIGHTS];
-    int              fDepthMapHeight[SK_MAX_NON_AMBIENT_LIGHTS];
+    int              fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
+    int              fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
 
     int              fHeight;
     int              fWidth;
 
     SkColor3f        fAmbientColor;
 };
 
 ////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> SkShadowShaderImpl::asFragmentProcessor(const AsFPArgs& fpargs) const {
@@ skipping 184 matching lines @@
         const SkLights::Light& light = fLights->light(l);
 
         bool isAmbient = SkLights::Light::kAmbient_LightType == light.type();
 
         buf.writeBool(isAmbient);
         buf.writeScalarArray(&light.color().fX, 3);
         if (!isAmbient) {
             buf.writeScalarArray(&light.dir().fX, 3);
         }
 
-        buf.writeImage(light.getShadowMap().get());
+        buf.writeImage(light.getShadowMap());
     }
 
     buf.writeInt(fDiffuseWidth);
     buf.writeInt(fDiffuseHeight);
 
     buf.writeFlattenable(fPovDepthShader.get());
     buf.writeFlattenable(fDiffuseShader.get());
 }
 
 size_t SkShadowShaderImpl::onContextSize(const ContextRec& rec) const {
@@ skipping 49 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif