gm/shadowmaps.cpp - platform/external/skqp - Gitiles

 /*
  * 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 "gm.h"
 #include "SkPaintFilterCanvas.h"
 #include "SkPathEffect.h"
 #include "SkPictureRecorder.h"
 #include "SkShadowShader.h"
 #include "SkSurface.h"

 #ifdef SK_EXPERIMENTAL_SHADOWING

 static sk_sp<SkShader> make_shadow_shader(sk_sp<SkImage> povDepth,
                                           sk_sp<SkImage> diffuse,
                                           sk_sp<SkLights> lights) {

     sk_sp<SkShader> povDepthShader = povDepth->makeShader(SkShader::kClamp_TileMode,
                                                           SkShader::kClamp_TileMode);

     sk_sp<SkShader> diffuseShader = diffuse->makeShader(SkShader::kClamp_TileMode,
                                                         SkShader::kClamp_TileMode);

     return SkShadowShader::Make(std::move(povDepthShader),
                                 std::move(diffuseShader),
                                 std::move(lights),
                                 diffuse->width(), diffuse->height());
 }

 static sk_sp<SkPicture> make_test_picture(int width, int height) {
     SkPictureRecorder recorder;

     // LONG RANGE TODO: eventually add SkBBHFactory (bounding box factory)
     SkCanvas* canvas = recorder.beginRecording(SkRect::MakeIWH(width, height));

     SkASSERT(canvas->getTotalMatrix().isIdentity());
     SkPaint paint;
     paint.setColor(SK_ColorGRAY);

     // LONG RANGE TODO: tag occluders
     // LONG RANGE TODO: track number of IDs we need (hopefully less than 256)
     //                  and determinate the mapping from z to id

     // universal receiver, "ground"
     canvas->drawRect(SkRect::MakeIWH(width, height), paint);

     // TODO: Maybe add the ID here along with the depth

     paint.setColor(0xFFEE8888);

     canvas->translateZ(80);
     canvas->drawRect(SkRect::MakeLTRB(200,150,350,300), paint);

     paint.setColor(0xFF88EE88);

     canvas->translateZ(80);
     canvas->drawRect(SkRect::MakeLTRB(150,200,300,350), paint);

     paint.setColor(0xFF8888EE);

     canvas->translateZ(80);
     canvas->drawRect(SkRect::MakeLTRB(100,100,250,250), paint);
     // TODO: Add an assert that Z order matches painter's order
     // TODO: think about if the Z-order always matching painting order is too strict

     return recorder.finishRecordingAsPicture();
 }

 namespace skiagm {

 /*  We override the onFilter method to draw depths into the canvas
  *  depending on the current draw depth of the canvas, throwing out
  *  the actual draw color.
  */
 class SkShadowPaintFilterCanvas : public SkPaintFilterCanvas {
 public:

     SkShadowPaintFilterCanvas(SkCanvas* canvas) : INHERITED(canvas) { }

     // TODO use a shader instead
     bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const override {
         if (*paint) {
             int z = this->getZ();
             SkASSERT(z <= 0xFF && z >= 0x00);

             SkPaint newPaint;
             newPaint.setPathEffect(sk_ref_sp<SkPathEffect>((*paint)->getPathEffect()));

             SkColor color = 0xFF000000; // init color to opaque black
             color |= z; // Put the index into the blue component
             newPaint.setColor(color);

             *paint->writable() = newPaint;
         }

         return true;
     }

     void onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {
         SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
         if (this->onFilter(&filteredPaint, kPicture_Type)) {
             // we directly call SkCanvas's onDrawPicture because calling the one
             // that INHERITED has (SkPaintFilterCanvas) leads to wrong behavior
             this->SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
         }
     }

     void updateMatrix() {
         this->save();

         // When we use the SkShadowPaintFilterCanvas, we can only render
         // one depth map at a time. Thus, we leave it up to the user to
         // set SkLights to only contain (or contain at the first position)
         // the light they intend to use for the current depth rendering.

         if (fLights->numLights() > 0 &&
             this->fLights->light(0).type() == SkLights::Light::kDirectional_LightType) {
             SkVector3 lightDir = this->fLights->light(0).dir();
             SkScalar x = lightDir.fX * this->getZ();
             SkScalar y = lightDir.fY * this->getZ();

             this->translate(x, y);
         }

     }

     void onDrawPaint(const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPaint(paint);
         this->restore();
     }

     void onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
                       const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPoints(mode, count, pts, paint);
         this->restore();
     }

     void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawRect(rect, paint);
         this->restore();
     }

     void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawRRect(rrect, paint);
         this->restore();
     }

     void onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
                       const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawDRRect(outer, inner, paint);
         this->restore();
     }

     void onDrawOval(const SkRect& rect, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawOval(rect, paint);
         this->restore();
     }

     void onDrawPath(const SkPath& path, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPath(path, paint);
         this->restore();
     }

     void onDrawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
                       const SkPaint* paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawBitmap(bm, left, top, paint);
         this->restore();
     }

     void onDrawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
                           const SkPaint* paint, SrcRectConstraint constraint) override {
         this->updateMatrix();
         this->INHERITED::onDrawBitmapRect(bm, src, dst, paint, constraint);
         this->restore();
     }

     void onDrawBitmapNine(const SkBitmap& bm, const SkIRect& center,
                           const SkRect& dst, const SkPaint* paint) {
         this->updateMatrix();
         this->INHERITED::onDrawBitmapNine(bm, center, dst, paint);
         this->restore();
     }

     void onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
                      const SkPaint* paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawImage(image, left, top, paint);
         this->restore();
     }

     void onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                          const SkPaint* paint, SrcRectConstraint constraint) override {
         this->updateMatrix();
         this->INHERITED::onDrawImageRect(image, src, dst, paint, constraint);
         this->restore();
     }

     void onDrawImageNine(const SkImage* image, const SkIRect& center,
                          const SkRect& dst, const SkPaint* paint) {
         this->updateMatrix();
         this->INHERITED::onDrawImageNine(image, center, dst, paint);
         this->restore();
     }

     void onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
                         const SkPoint texs[], const SkColor colors[], SkXfermode* xmode,
                         const uint16_t indices[], int indexCount, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawVertices(vmode, vertexCount, vertices, texs, colors,
                                         xmode, indices, indexCount, paint);
         this->restore();
     }

     void onDrawPatch(const SkPoint cubics[], const SkColor colors[], const SkPoint texCoords[],
                      SkXfermode* xmode, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPatch(cubics, colors, texCoords, xmode, paint);
         this->restore();
     }

     void onDrawText(const void* text, size_t byteLength,
                     SkScalar x, SkScalar y, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawText(text, byteLength, x, y, paint);
         this->restore();
     }

     void onDrawPosText(const void* text, size_t byteLength,
                        const SkPoint pos[], const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPosText(text, byteLength, pos, paint);
         this->restore();
     }

     void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                         SkScalar constY, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, paint);
         this->restore();
     }

     void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                           const SkMatrix* matrix, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
         this->restore();
     }

     void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
                            const SkRect* cull, const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawTextRSXform(text, byteLength, xform, cull, paint);
         this->restore();
     }

     void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                         const SkPaint& paint) override {
         this->updateMatrix();
         this->INHERITED::onDrawTextBlob(blob, x, y, paint);
         this->restore();
     }

 private:
     typedef SkPaintFilterCanvas INHERITED;
 };

 class ShadowMapsGM : public GM {
 public:
     ShadowMapsGM() {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
     }

     void onOnceBeforeDraw() override {
         // Create a light set consisting of
         //   - bluish directional light pointing more right than down
         //   - reddish directional light pointing more down than right
         //   - soft white ambient light

         SkLights::Builder builder;
         builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.3f, 0.4f),
                                     SkVector3::Make(0.2f, 0.1f, 1.0f)));
         builder.add(SkLights::Light(SkColor3f::Make(0.4f, 0.3f, 0.2f),
                                     SkVector3::Make(0.1f, 0.2f, 1.0f)));
         builder.add(SkLights::Light(SkColor3f::Make(0.4f, 0.4f, 0.4f)));
         fLights = builder.finish();
     }

 protected:
     static const int kWidth = 400;
     static const int kHeight = 400;

     SkString onShortName() override {
         return SkString("shadowmaps");
     }

     SkISize onISize() override {
         return SkISize::Make(kWidth, kHeight);
     }

     void onDraw(SkCanvas* canvas) override {
         // This picture stores the picture of the scene.
         // It's used to generate the depth maps.
         sk_sp<SkPicture> pic(make_test_picture(kWidth, kHeight));

         for (int i = 0; i < fLights->numLights(); ++i) {
             // skip over ambient lights; they don't cast shadows
             if (SkLights::Light::kAmbient_LightType == fLights->light(i).type()) {
                 continue;
             }
             // TODO: compute the correct size of the depth map from the light properties
             // TODO: maybe add a kDepth_8_SkColorType

             SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
                                                  kBGRA_8888_SkColorType,
                                                  kOpaque_SkAlphaType);

             // Create a new surface (that matches the backend of canvas)
             // for each shadow map
             sk_sp<SkSurface> surf(canvas->makeSurface(info));

             // Wrap another SPFCanvas around the surface
             sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
                     sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());

             // set the depth map canvas to have the light we're drawing.
             SkLights::Builder builder;
             builder.add(fLights->light(i));
             sk_sp<SkLights> curLight = builder.finish();

             depthMapCanvas->setLights(std::move(curLight));
             depthMapCanvas->drawPicture(pic);

             fLights->light(i).setShadowMap(surf->makeImageSnapshot());
         }

         sk_sp<SkImage> povDepthMap;
         sk_sp<SkImage> diffuseMap;

         // TODO: pass the depth to the shader in vertices, or uniforms
         //       so we don't have to render depth and color separately

         // povDepthMap
         {
             SkLights::Builder builder;
             builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),
                                         SkVector3::Make(0.0f, 0.0f, 1.0f)));
             sk_sp<SkLights> povLight = builder.finish();

             SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
                                                  kBGRA_8888_SkColorType,
                                                  kOpaque_SkAlphaType);

             // Create a new surface (that matches the backend of canvas)
             // to create the povDepthMap
             sk_sp<SkSurface> surf(canvas->makeSurface(info));

             // Wrap another SPFCanvas around the surface
             sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
                     sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());

             // set the depth map canvas to have the light as the user's POV
             depthMapCanvas->setLights(std::move(povLight));

             depthMapCanvas->drawPicture(pic);

             povDepthMap = surf->makeImageSnapshot();
         }

         // diffuseMap
         {
             SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
                                                  kBGRA_8888_SkColorType,
                                                  kOpaque_SkAlphaType);

             sk_sp<SkSurface> surf(canvas->makeSurface(info));
             surf->getCanvas()->drawPicture(pic);

             diffuseMap = surf->makeImageSnapshot();
         }

         SkPaint paint;
         paint.setShader(make_shadow_shader(std::move(povDepthMap), std::move(diffuseMap), fLights));

         canvas->drawRect(SkRect::MakeIWH(kWidth, kHeight), paint);
     }

 private:
     sk_sp<SkLights> fLights;

     typedef GM INHERITED;
 };

 //////////////////////////////////////////////////////////////////////////////

 DEF_GM(return new ShadowMapsGM;)
 }

 #endif
	/*
	* 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 "gm.h"
	#include "SkPaintFilterCanvas.h"
	#include "SkPathEffect.h"
	#include "SkPictureRecorder.h"
	#include "SkShadowShader.h"
	#include "SkSurface.h"

	#ifdef SK_EXPERIMENTAL_SHADOWING

	static sk_sp<SkShader> make_shadow_shader(sk_sp<SkImage> povDepth,
	sk_sp<SkImage> diffuse,
	sk_sp<SkLights> lights) {

	sk_sp<SkShader> povDepthShader = povDepth->makeShader(SkShader::kClamp_TileMode,
	SkShader::kClamp_TileMode);

	sk_sp<SkShader> diffuseShader = diffuse->makeShader(SkShader::kClamp_TileMode,
	SkShader::kClamp_TileMode);

	return SkShadowShader::Make(std::move(povDepthShader),
	std::move(diffuseShader),
	std::move(lights),
	diffuse->width(), diffuse->height());
	}

	static sk_sp<SkPicture> make_test_picture(int width, int height) {
	SkPictureRecorder recorder;

	// LONG RANGE TODO: eventually add SkBBHFactory (bounding box factory)
	SkCanvas* canvas = recorder.beginRecording(SkRect::MakeIWH(width, height));

	SkASSERT(canvas->getTotalMatrix().isIdentity());
	SkPaint paint;
	paint.setColor(SK_ColorGRAY);

	// LONG RANGE TODO: tag occluders
	// LONG RANGE TODO: track number of IDs we need (hopefully less than 256)
	// and determinate the mapping from z to id

	// universal receiver, "ground"
	canvas->drawRect(SkRect::MakeIWH(width, height), paint);

	// TODO: Maybe add the ID here along with the depth

	paint.setColor(0xFFEE8888);

	canvas->translateZ(80);
	canvas->drawRect(SkRect::MakeLTRB(200,150,350,300), paint);

	paint.setColor(0xFF88EE88);

	canvas->translateZ(80);
	canvas->drawRect(SkRect::MakeLTRB(150,200,300,350), paint);

	paint.setColor(0xFF8888EE);

	canvas->translateZ(80);
	canvas->drawRect(SkRect::MakeLTRB(100,100,250,250), paint);
	// TODO: Add an assert that Z order matches painter's order
	// TODO: think about if the Z-order always matching painting order is too strict

	return recorder.finishRecordingAsPicture();
	}

	namespace skiagm {

	/* We override the onFilter method to draw depths into the canvas
	* depending on the current draw depth of the canvas, throwing out
	* the actual draw color.
	*/
	class SkShadowPaintFilterCanvas : public SkPaintFilterCanvas {
	public:

	SkShadowPaintFilterCanvas(SkCanvas* canvas) : INHERITED(canvas) { }

	// TODO use a shader instead
	bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type type) const override {
	if (*paint) {
	int z = this->getZ();
	SkASSERT(z <= 0xFF && z >= 0x00);

	SkPaint newPaint;
	newPaint.setPathEffect(sk_ref_sp<SkPathEffect>((*paint)->getPathEffect()));

	SkColor color = 0xFF000000; // init color to opaque black
	color \|= z; // Put the index into the blue component
	newPaint.setColor(color);

	*paint->writable() = newPaint;
	}

	return true;
	}

	void onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {
	SkTCopyOnFirstWrite<SkPaint> filteredPaint(paint);
	if (this->onFilter(&filteredPaint, kPicture_Type)) {
	// we directly call SkCanvas's onDrawPicture because calling the one
	// that INHERITED has (SkPaintFilterCanvas) leads to wrong behavior
	this->SkCanvas::onDrawPicture(picture, matrix, filteredPaint);
	}
	}

	void updateMatrix() {
	this->save();

	// When we use the SkShadowPaintFilterCanvas, we can only render
	// one depth map at a time. Thus, we leave it up to the user to
	// set SkLights to only contain (or contain at the first position)
	// the light they intend to use for the current depth rendering.

	if (fLights->numLights() > 0 &&
	this->fLights->light(0).type() == SkLights::Light::kDirectional_LightType) {
	SkVector3 lightDir = this->fLights->light(0).dir();
	SkScalar x = lightDir.fX * this->getZ();
	SkScalar y = lightDir.fY * this->getZ();

	this->translate(x, y);
	}

	}

	void onDrawPaint(const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPaint(paint);
	this->restore();
	}

	void onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
	const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPoints(mode, count, pts, paint);
	this->restore();
	}

	void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawRect(rect, paint);
	this->restore();
	}

	void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawRRect(rrect, paint);
	this->restore();
	}

	void onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
	const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawDRRect(outer, inner, paint);
	this->restore();
	}

	void onDrawOval(const SkRect& rect, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawOval(rect, paint);
	this->restore();
	}

	void onDrawPath(const SkPath& path, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPath(path, paint);
	this->restore();
	}

	void onDrawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
	const SkPaint* paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawBitmap(bm, left, top, paint);
	this->restore();
	}

	void onDrawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
	const SkPaint* paint, SrcRectConstraint constraint) override {
	this->updateMatrix();
	this->INHERITED::onDrawBitmapRect(bm, src, dst, paint, constraint);
	this->restore();
	}

	void onDrawBitmapNine(const SkBitmap& bm, const SkIRect& center,
	const SkRect& dst, const SkPaint* paint) {
	this->updateMatrix();
	this->INHERITED::onDrawBitmapNine(bm, center, dst, paint);
	this->restore();
	}

	void onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
	const SkPaint* paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawImage(image, left, top, paint);
	this->restore();
	}

	void onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
	const SkPaint* paint, SrcRectConstraint constraint) override {
	this->updateMatrix();
	this->INHERITED::onDrawImageRect(image, src, dst, paint, constraint);
	this->restore();
	}

	void onDrawImageNine(const SkImage* image, const SkIRect& center,
	const SkRect& dst, const SkPaint* paint) {
	this->updateMatrix();
	this->INHERITED::onDrawImageNine(image, center, dst, paint);
	this->restore();
	}

	void onDrawVertices(VertexMode vmode, int vertexCount, const SkPoint vertices[],
	const SkPoint texs[], const SkColor colors[], SkXfermode* xmode,
	const uint16_t indices[], int indexCount, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawVertices(vmode, vertexCount, vertices, texs, colors,
	xmode, indices, indexCount, paint);
	this->restore();
	}

	void onDrawPatch(const SkPoint cubics[], const SkColor colors[], const SkPoint texCoords[],
	SkXfermode* xmode, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPatch(cubics, colors, texCoords, xmode, paint);
	this->restore();
	}

	void onDrawText(const void* text, size_t byteLength,
	SkScalar x, SkScalar y, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawText(text, byteLength, x, y, paint);
	this->restore();
	}

	void onDrawPosText(const void* text, size_t byteLength,
	const SkPoint pos[], const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPosText(text, byteLength, pos, paint);
	this->restore();
	}

	void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
	SkScalar constY, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, paint);
	this->restore();
	}

	void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
	const SkMatrix* matrix, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
	this->restore();
	}

	void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform xform[],
	const SkRect* cull, const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawTextRSXform(text, byteLength, xform, cull, paint);
	this->restore();
	}

	void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
	const SkPaint& paint) override {
	this->updateMatrix();
	this->INHERITED::onDrawTextBlob(blob, x, y, paint);
	this->restore();
	}

	private:
	typedef SkPaintFilterCanvas INHERITED;
	};

	class ShadowMapsGM : public GM {
	public:
	ShadowMapsGM() {
	this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
	}

	void onOnceBeforeDraw() override {
	// Create a light set consisting of
	// - bluish directional light pointing more right than down
	// - reddish directional light pointing more down than right
	// - soft white ambient light

	SkLights::Builder builder;
	builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.3f, 0.4f),
	SkVector3::Make(0.2f, 0.1f, 1.0f)));
	builder.add(SkLights::Light(SkColor3f::Make(0.4f, 0.3f, 0.2f),
	SkVector3::Make(0.1f, 0.2f, 1.0f)));
	builder.add(SkLights::Light(SkColor3f::Make(0.4f, 0.4f, 0.4f)));
	fLights = builder.finish();
	}

	protected:
	static const int kWidth = 400;
	static const int kHeight = 400;

	SkString onShortName() override {
	return SkString("shadowmaps");
	}

	SkISize onISize() override {
	return SkISize::Make(kWidth, kHeight);
	}

	void onDraw(SkCanvas* canvas) override {
	// This picture stores the picture of the scene.
	// It's used to generate the depth maps.
	sk_sp<SkPicture> pic(make_test_picture(kWidth, kHeight));

	for (int i = 0; i < fLights->numLights(); ++i) {
	// skip over ambient lights; they don't cast shadows
	if (SkLights::Light::kAmbient_LightType == fLights->light(i).type()) {
	continue;
	}
	// TODO: compute the correct size of the depth map from the light properties
	// TODO: maybe add a kDepth_8_SkColorType

	SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
	kBGRA_8888_SkColorType,
	kOpaque_SkAlphaType);

	// Create a new surface (that matches the backend of canvas)
	// for each shadow map
	sk_sp<SkSurface> surf(canvas->makeSurface(info));

	// Wrap another SPFCanvas around the surface
	sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
	sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());

	// set the depth map canvas to have the light we're drawing.
	SkLights::Builder builder;
	builder.add(fLights->light(i));
	sk_sp<SkLights> curLight = builder.finish();

	depthMapCanvas->setLights(std::move(curLight));
	depthMapCanvas->drawPicture(pic);

	fLights->light(i).setShadowMap(surf->makeImageSnapshot());
	}

	sk_sp<SkImage> povDepthMap;
	sk_sp<SkImage> diffuseMap;

	// TODO: pass the depth to the shader in vertices, or uniforms
	// so we don't have to render depth and color separately

	// povDepthMap
	{
	SkLights::Builder builder;
	builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f),
	SkVector3::Make(0.0f, 0.0f, 1.0f)));
	sk_sp<SkLights> povLight = builder.finish();

	SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
	kBGRA_8888_SkColorType,
	kOpaque_SkAlphaType);

	// Create a new surface (that matches the backend of canvas)
	// to create the povDepthMap
	sk_sp<SkSurface> surf(canvas->makeSurface(info));

	// Wrap another SPFCanvas around the surface
	sk_sp<SkShadowPaintFilterCanvas> depthMapCanvas =
	sk_make_sp<SkShadowPaintFilterCanvas>(surf->getCanvas());

	// set the depth map canvas to have the light as the user's POV
	depthMapCanvas->setLights(std::move(povLight));

	depthMapCanvas->drawPicture(pic);

	povDepthMap = surf->makeImageSnapshot();
	}

	// diffuseMap
	{
	SkImageInfo info = SkImageInfo::Make(kWidth, kHeight,
	kBGRA_8888_SkColorType,
	kOpaque_SkAlphaType);

	sk_sp<SkSurface> surf(canvas->makeSurface(info));
	surf->getCanvas()->drawPicture(pic);

	diffuseMap = surf->makeImageSnapshot();
	}

	SkPaint paint;
	paint.setShader(make_shadow_shader(std::move(povDepthMap), std::move(diffuseMap), fLights));

	canvas->drawRect(SkRect::MakeIWH(kWidth, kHeight), paint);
	}

	private:
	sk_sp<SkLights> fLights;

	typedef GM INHERITED;
	};

	//////////////////////////////////////////////////////////////////////////////

	DEF_GM(return new ShadowMapsGM;)
	}

	#endif