/*
* 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 "SkCanvas.h"
#include "SkReadBuffer.h"
#include "SkShadowShader.h"
////////////////////////////////////////////////////////////////////////////
#ifdef SK_EXPERIMENTAL_SHADOWING
/** \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,
sk_sp<SkShader> diffuseShader,
sk_sp<SkLights> lights,
int diffuseWidth, int diffuseHeight,
const SkShadowParams& params)
: fPovDepthShader(std::move(povDepthShader))
, fDiffuseShader(std::move(diffuseShader))
, fLights(std::move(lights))
, fDiffuseWidth(diffuseWidth)
, fDiffuseHeight(diffuseHeight)
, fShadowParams(params) { }
bool isOpaque() const override;
#if SK_SUPPORT_GPU
sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
#endif
class ShadowShaderContext : public SkShader::Context {
public:
// The context takes ownership of the states. It will call their destructors
// but will NOT free the memory.
ShadowShaderContext(const SkShadowShaderImpl&, const ContextRec&,
SkShader::Context* povDepthContext,
SkShader::Context* diffuseContext,
void* heapAllocated);
~ShadowShaderContext() override;
void shadeSpan(int x, int y, SkPMColor[], int count) override;
uint32_t getFlags() const override { return fFlags; }
private:
SkShader::Context* fPovDepthContext;
SkShader::Context* fDiffuseContext;
uint32_t fFlags;
void* fHeapAllocated;
int fNonAmbLightCnt;
SkPixmap* fShadowMapPixels;
typedef SkShader::Context INHERITED;
};
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkShadowShaderImpl)
protected:
void flatten(SkWriteBuffer&) const override;
size_t onContextSize(const ContextRec&) const override;
Context* onCreateContext(const ContextRec&, void*) const override;
private:
sk_sp<SkShader> fPovDepthShader;
sk_sp<SkShader> fDiffuseShader;
sk_sp<SkLights> fLights;
int fDiffuseWidth;
int fDiffuseHeight;
SkShadowParams fShadowParams;
friend class SkShadowShader;
typedef SkShader INHERITED;
};
////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "glsl/GrGLSLFragmentProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "SkGr.h"
#include "SkSpecialImage.h"
#include "SkImage_Base.h"
#include "GrContext.h"
class ShadowFP : public GrFragmentProcessor {
public:
ShadowFP(sk_sp<GrFragmentProcessor> povDepth,
sk_sp<GrFragmentProcessor> diffuse,
sk_sp<SkLights> lights,
int diffuseWidth, int diffuseHeight,
const SkShadowParams& params,
GrContext* context) {
fAmbientColor = lights->ambientLightColor();
fNumNonAmbLights = 0; // count of non-ambient lights
for (int i = 0; i < lights->numLights(); ++i) {
if (fNumNonAmbLights < SkShadowShader::kMaxNonAmbientLights) {
fLightColor[fNumNonAmbLights] = lights->light(i).color();
if (SkLights::Light::kPoint_LightType == lights->light(i).type()) {
fLightDirOrPos[fNumNonAmbLights] = lights->light(i).pos();
fLightColor[fNumNonAmbLights].scale(lights->light(i).intensity());
} else {
fLightDirOrPos[fNumNonAmbLights] = lights->light(i).dir();
}
fIsPointLight[fNumNonAmbLights] =
SkLights::Light::kPoint_LightType == lights->light(i).type();
fIsRadialLight[fNumNonAmbLights] = lights->light(i).isRadial();
SkImage_Base* shadowMap = ((SkImage_Base*)lights->light(i).getShadowMap());
// gets deleted when the ShadowFP is destroyed, and frees the GrTexture*
fTexture[fNumNonAmbLights] = sk_sp<GrTexture>(shadowMap->asTextureRef(context,
GrSamplerParams::ClampNoFilter(),
SkDestinationSurfaceColorMode::kLegacy,
nullptr));
fDepthMapSampler[fNumNonAmbLights].reset(fTexture[fNumNonAmbLights].get());
this->addTextureSampler(&fDepthMapSampler[fNumNonAmbLights]);
fDepthMapHeight[fNumNonAmbLights] = shadowMap->height();
fDepthMapWidth[fNumNonAmbLights] = shadowMap->width();
fNumNonAmbLights++;
}
}
fWidth = diffuseWidth;
fHeight = diffuseHeight;
fShadowParams = params;
this->registerChildProcessor(std::move(povDepth));
this->registerChildProcessor(std::move(diffuse));
this->initClassID<ShadowFP>();
}
class GLSLShadowFP : public GrGLSLFragmentProcessor {
public:
GLSLShadowFP() { }
void emitCode(EmitArgs& args) override {
GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
const ShadowFP& shadowFP = args.fFp.cast<ShadowFP>();
SkASSERT(shadowFP.fNumNonAmbLights <= SkShadowShader::kMaxNonAmbientLights);
// add uniforms
int32_t numLights = shadowFP.fNumNonAmbLights;
SkASSERT(numLights <= SkShadowShader::kMaxNonAmbientLights);
int blurAlgorithm = shadowFP.fShadowParams.fType;
const char* lightDirOrPosUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
const char* lightColorUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
const char* ambientColorUniName = nullptr;
const char* depthMapWidthUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
const char* depthMapHeightUniName[SkShadowShader::kMaxNonAmbientLights] = {nullptr};
const char* widthUniName = nullptr; // dimensions of povDepth
const char* heightUniName = nullptr;
const char* shBiasUniName = nullptr;
const char* minVarianceUniName = nullptr;
// setting uniforms
for (int i = 0; i < shadowFP.fNumNonAmbLights; i++) {
SkString lightDirOrPosUniNameStr("lightDir");
lightDirOrPosUniNameStr.appendf("%d", i);
SkString lightColorUniNameStr("lightColor");
lightColorUniNameStr.appendf("%d", i);
SkString lightIntensityUniNameStr("lightIntensity");
lightIntensityUniNameStr.appendf("%d", i);
SkString depthMapWidthUniNameStr("dmapWidth");
depthMapWidthUniNameStr.appendf("%d", i);
SkString depthMapHeightUniNameStr("dmapHeight");
depthMapHeightUniNameStr.appendf("%d", i);
fLightDirOrPosUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
kVec3f_GrSLType,
kDefault_GrSLPrecision,
lightDirOrPosUniNameStr.c_str(),
&lightDirOrPosUniName[i]);
fLightColorUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
kVec3f_GrSLType,
kDefault_GrSLPrecision,
lightColorUniNameStr.c_str(),
&lightColorUniName[i]);
fDepthMapWidthUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
kInt_GrSLType,
kDefault_GrSLPrecision,
depthMapWidthUniNameStr.c_str(),
&depthMapWidthUniName[i]);
fDepthMapHeightUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
kInt_GrSLType,
kDefault_GrSLPrecision,
depthMapHeightUniNameStr.c_str(),
&depthMapHeightUniName[i]);
}
fBiasingConstantUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
kFloat_GrSLType,
kDefault_GrSLPrecision,
"shadowBias", &shBiasUniName);
fMinVarianceUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
kFloat_GrSLType,
kDefault_GrSLPrecision,
"minVariance", &minVarianceUniName);
fWidthUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
kInt_GrSLType,
kDefault_GrSLPrecision,
"width", &widthUniName);
fHeightUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
kInt_GrSLType,
kDefault_GrSLPrecision,
"height", &heightUniName);
fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
kVec3f_GrSLType, kDefault_GrSLPrecision,
"AmbientColor", &ambientColorUniName);
SkString povDepthSampler("_povDepth");
SkString povDepth("povDepth");
this->emitChild(0, nullptr, &povDepthSampler, args);
fragBuilder->codeAppendf("vec4 %s = %s;", povDepth.c_str(), povDepthSampler.c_str());
SkString diffuseColorSampler("_inDiffuseColor");
SkString diffuseColor("inDiffuseColor");
this->emitChild(1, nullptr, &diffuseColorSampler, args);
fragBuilder->codeAppendf("vec4 %s = %s;", diffuseColor.c_str(),
diffuseColorSampler.c_str());
SkString depthMaps[SkShadowShader::kMaxNonAmbientLights];
fragBuilder->codeAppendf("vec4 resultDiffuseColor = %s;", diffuseColor.c_str());
fragBuilder->codeAppend ("vec3 totalLightColor = vec3(0);");
// probability that a fragment is lit. For each light, we multiply this by the
// light's color to get its contribution to totalLightColor.
fragBuilder->codeAppend ("float lightProbability;");
// coordinates of current fragment in world space
fragBuilder->codeAppend ("vec3 worldCor;");
// Multiply by 255 to transform from sampler coordinates to world
// coordinates (since 1 channel is 0xFF)
// Note: vMatrixCoord_0_1_Stage0 is the texture sampler coordinates.
fragBuilder->codeAppendf("worldCor = vec3(vMatrixCoord_0_1_Stage0 * "
"vec2(%s, %s), %s.b * 255);",
widthUniName, heightUniName, povDepth.c_str());
// Applies the offset indexing that goes from our view space into the light's space.
for (int i = 0; i < shadowFP.fNumNonAmbLights; i++) {
SkString povCoord("povCoord");
povCoord.appendf("%d", i);
SkString offset("offset");
offset.appendf("%d", i);
fragBuilder->codeAppendf("vec2 %s;", offset.c_str());
if (shadowFP.fIsPointLight[i]) {
fragBuilder->codeAppendf("vec3 fragToLight%d = %s - worldCor;",
i, lightDirOrPosUniName[i]);
fragBuilder->codeAppendf("float dist%d = length(fragToLight%d);",
i, i);
fragBuilder->codeAppendf("%s = vec2(-fragToLight%d) * povDepth.b;",
offset.c_str(), i);
fragBuilder->codeAppendf("fragToLight%d = normalize(fragToLight%d);",
i, i);
}
if (shadowFP.fIsRadialLight[i]) {
fragBuilder->codeAppendf("vec2 %s = vec2(vMatrixCoord_0_1_Stage0.x, "
"1 - vMatrixCoord_0_1_Stage0.y);\n",
povCoord.c_str());
fragBuilder->codeAppendf("%s = (%s) * 2.0 - 1.0 + (vec2(%s)/vec2(%s,%s) - 0.5)"
"* vec2(-2.0, 2.0);\n",
povCoord.c_str(), povCoord.c_str(),
lightDirOrPosUniName[i],
widthUniName, heightUniName);
fragBuilder->codeAppendf("float theta = atan(%s.y, %s.x);",
povCoord.c_str(), povCoord.c_str());
fragBuilder->codeAppendf("float r = length(%s);", povCoord.c_str());
// map output of atan to [0, 1]
fragBuilder->codeAppendf("%s.x = (theta + 3.1415) / (2.0 * 3.1415);",
povCoord.c_str());
fragBuilder->codeAppendf("%s.y = 0.0;", povCoord.c_str());
} else {
// note that we flip the y-coord of the offset and then later add
// a value just to the y-coord of povCoord. This is to account for
// the shifted origins from switching from raster into GPU.
if (shadowFP.fIsPointLight[i]) {
// the 0.375s are precalculated transform values, given that the depth
// maps for pt lights are 4x the size (linearly) as diffuse maps.
// The vec2(0.375, -0.375) is used to transform us to
// the center of the map.
fragBuilder->codeAppendf("vec2 %s = ((vec2(%s, %s) *"
"vMatrixCoord_0_1_Stage0 +"
"vec2(0,%s - %s)"
"+ %s) / (vec2(%s, %s))) +"
"vec2(0.375, -0.375);",
povCoord.c_str(),
widthUniName, heightUniName,
depthMapHeightUniName[i], heightUniName,
offset.c_str(),
depthMapWidthUniName[i],
depthMapWidthUniName[i]);
} else {
fragBuilder->codeAppendf("%s = vec2(%s) * povDepth.b * "
"vec2(255.0, -255.0);",
offset.c_str(), lightDirOrPosUniName[i]);
fragBuilder->codeAppendf("vec2 %s = ((vec2(%s, %s) *"
"vMatrixCoord_0_1_Stage0 +"
"vec2(0,%s - %s)"
"+ %s) / vec2(%s, %s));",
povCoord.c_str(),
widthUniName, heightUniName,
depthMapHeightUniName[i], heightUniName,
offset.c_str(),
depthMapWidthUniName[i],
depthMapWidthUniName[i]);
}
}
fragBuilder->appendTextureLookup(&depthMaps[i], args.fTexSamplers[i],
povCoord.c_str(),
kVec2f_GrSLType);
}
// helper variables for calculating shadowing
// variance of depth at this fragment in the context of surrounding area
// (area size and weighting dependent on blur size and type)
fragBuilder->codeAppendf("float variance;");
// the difference in depth between the user POV and light POV.
fragBuilder->codeAppendf("float d;");
// add up light contributions from all lights to totalLightColor
for (int i = 0; i < numLights; i++) {
fragBuilder->codeAppendf("lightProbability = 1;");
if (shadowFP.fIsRadialLight[i]) {
fragBuilder->codeAppend("totalLightColor = vec3(0);");
fragBuilder->codeAppend("vec2 tc = vec2(povCoord0.x, 0.0);");
fragBuilder->codeAppend("float depth = texture(uTextureSampler0_Stage1,"
"povCoord0).b * 2.0;");
fragBuilder->codeAppendf("lightProbability = step(r, depth);");
// 2 is the maximum depth. If this is reached, probably we have
// not intersected anything. So values after this should be unshadowed.
fragBuilder->codeAppendf("if (%s.b != 0 || depth == 2) {"
"lightProbability = 1.0; }",
povDepth.c_str());
} else {
// 1/512 == .00195... is less than half a pixel; imperceptible
fragBuilder->codeAppendf("if (%s.b <= %s.b + .001953125) {",
povDepth.c_str(), depthMaps[i].c_str());
if (blurAlgorithm == SkShadowParams::kVariance_ShadowType) {
// We mess with depth and depth^2 in their given scales.
// (i.e. between 0 and 1)
fragBuilder->codeAppendf("vec2 moments%d = vec2(%s.b, %s.g);",
i, depthMaps[i].c_str(), depthMaps[i].c_str());
// variance biasing lessens light bleeding
fragBuilder->codeAppendf("variance = max(moments%d.y - "
"(moments%d.x * moments%d.x),"
"%s);", i, i, i,
minVarianceUniName);
fragBuilder->codeAppendf("d = (%s.b) - moments%d.x;",
povDepth.c_str(), i);
fragBuilder->codeAppendf("lightProbability = "
"(variance / (variance + d * d));");
SkString clamp("clamp");
clamp.appendf("%d", i);
// choosing between light artifacts or correct shape shadows
// linstep
fragBuilder->codeAppendf("float %s = clamp((lightProbability - %s) /"
"(1 - %s), 0, 1);",
clamp.c_str(), shBiasUniName, shBiasUniName);
fragBuilder->codeAppendf("lightProbability = %s;", clamp.c_str());
} else {
fragBuilder->codeAppendf("if (%s.b >= %s.b) {",
povDepth.c_str(), depthMaps[i].c_str());
fragBuilder->codeAppendf("lightProbability = 1;");
fragBuilder->codeAppendf("} else { lightProbability = 0; }");
}
// VSM: The curved shadows near plane edges are artifacts from blurring
// lightDir.z is equal to the lightDir dot the surface normal.
fragBuilder->codeAppendf("}");
}
if (shadowFP.isPointLight(i)) {
fragBuilder->codeAppendf("totalLightColor += max(fragToLight%d.z, 0) * %s /"
"(1 + dist%d) * lightProbability;",
i, lightColorUniName[i], i);
} else {
fragBuilder->codeAppendf("totalLightColor += %s.z * %s * lightProbability;",
lightDirOrPosUniName[i],
lightColorUniName[i]);
}
fragBuilder->codeAppendf("totalLightColor += %s;", ambientColorUniName);
fragBuilder->codeAppendf("%s = resultDiffuseColor * vec4(totalLightColor, 1);",
args.fOutputColor);
}
}
static void GenKey(const GrProcessor& proc, const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
const ShadowFP& shadowFP = proc.cast<ShadowFP>();
b->add32(shadowFP.fNumNonAmbLights);
int isPLR = 0;
for (int i = 0; i < SkShadowShader::kMaxNonAmbientLights; i++) {
isPLR = isPLR | ((shadowFP.fIsPointLight[i] ? 1 : 0) << i);
isPLR = isPLR | ((shadowFP.fIsRadialLight[i] ? 1 : 0) << (i+4));
}
b->add32(isPLR);
b->add32(shadowFP.fShadowParams.fType);
}
protected:
void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
const ShadowFP &shadowFP = proc.cast<ShadowFP>();
for (int i = 0; i < shadowFP.numLights(); i++) {
const SkVector3& lightDirOrPos = shadowFP.lightDirOrPos(i);
if (lightDirOrPos != fLightDirOrPos[i]) {
pdman.set3fv(fLightDirOrPosUni[i], 1, &lightDirOrPos.fX);
fLightDirOrPos[i] = lightDirOrPos;
}
const SkColor3f& lightColor = shadowFP.lightColor(i);
if (lightColor != fLightColor[i]) {
pdman.set3fv(fLightColorUni[i], 1, &lightColor.fX);
fLightColor[i] = lightColor;
}
int depthMapWidth = shadowFP.depthMapWidth(i);
if (depthMapWidth != fDepthMapWidth[i]) {
pdman.set1i(fDepthMapWidthUni[i], depthMapWidth);
fDepthMapWidth[i] = depthMapWidth;
}
int depthMapHeight = shadowFP.depthMapHeight(i);
if (depthMapHeight != fDepthMapHeight[i]) {
pdman.set1i(fDepthMapHeightUni[i], depthMapHeight);
fDepthMapHeight[i] = depthMapHeight;
}
}
SkScalar biasingConstant = shadowFP.shadowParams().fBiasingConstant;
if (biasingConstant != fBiasingConstant) {
pdman.set1f(fBiasingConstantUni, biasingConstant);
fBiasingConstant = biasingConstant;
}
SkScalar minVariance = shadowFP.shadowParams().fMinVariance;
if (minVariance != fMinVariance) {
// transform variance from pixel-scale to normalized scale
pdman.set1f(fMinVarianceUni, minVariance / 65536.0f);
fMinVariance = minVariance / 65536.0f;
}
int width = shadowFP.width();
if (width != fWidth) {
pdman.set1i(fWidthUni, width);
fWidth = width;
}
int height = shadowFP.height();
if (height != fHeight) {
pdman.set1i(fHeightUni, height);
fHeight = height;
}
const SkColor3f& ambientColor = shadowFP.ambientColor();
if (ambientColor != fAmbientColor) {
pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
fAmbientColor = ambientColor;
}
}
private:
SkVector3 fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
GrGLSLProgramDataManager::UniformHandle
fLightDirOrPosUni[SkShadowShader::kMaxNonAmbientLights];
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;
SkScalar fBiasingConstant;
GrGLSLProgramDataManager::UniformHandle fBiasingConstantUni;
SkScalar fMinVariance;
GrGLSLProgramDataManager::UniformHandle fMinVarianceUni;
SkColor3f fAmbientColor;
GrGLSLProgramDataManager::UniformHandle fAmbientColorUni;
};
void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
GLSLShadowFP::GenKey(*this, caps, b);
}
const char* name() const override { return "shadowFP"; }
int32_t numLights() const { return fNumNonAmbLights; }
const SkColor3f& ambientColor() const { return fAmbientColor; }
bool isPointLight(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fIsPointLight[i];
}
bool isRadialLight(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fIsRadialLight[i];
}
const SkVector3& lightDirOrPos(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fLightDirOrPos[i];
}
const SkVector3& lightColor(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fLightColor[i];
}
int depthMapWidth(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fDepthMapWidth[i];
}
int depthMapHeight(int i) const {
SkASSERT(i < fNumNonAmbLights);
return fDepthMapHeight[i];
}
int width() const {return fWidth; }
int height() const {return fHeight; }
const SkShadowParams& shadowParams() const {return fShadowParams; }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLShadowFP; }
bool onIsEqual(const GrFragmentProcessor& proc) const override {
const ShadowFP& shadowFP = proc.cast<ShadowFP>();
if (fAmbientColor != shadowFP.fAmbientColor ||
fNumNonAmbLights != shadowFP.fNumNonAmbLights) {
return false;
}
if (fWidth != shadowFP.fWidth || fHeight != shadowFP.fHeight) {
return false;
}
for (int i = 0; i < fNumNonAmbLights; i++) {
if (fLightDirOrPos[i] != shadowFP.fLightDirOrPos[i] ||
fLightColor[i] != shadowFP.fLightColor[i] ||
fIsPointLight[i] != shadowFP.fIsPointLight[i] ||
fIsRadialLight[i] != shadowFP.fIsRadialLight[i]) {
return false;
}
if (fDepthMapWidth[i] != shadowFP.fDepthMapWidth[i] ||
fDepthMapHeight[i] != shadowFP.fDepthMapHeight[i]) {
return false;
}
}
return true;
}
int fNumNonAmbLights;
bool fIsPointLight[SkShadowShader::kMaxNonAmbientLights];
bool fIsRadialLight[SkShadowShader::kMaxNonAmbientLights];
SkVector3 fLightDirOrPos[SkShadowShader::kMaxNonAmbientLights];
SkColor3f fLightColor[SkShadowShader::kMaxNonAmbientLights];
TextureSampler fDepthMapSampler[SkShadowShader::kMaxNonAmbientLights];
sk_sp<GrTexture> fTexture[SkShadowShader::kMaxNonAmbientLights];
int fDepthMapWidth[SkShadowShader::kMaxNonAmbientLights];
int fDepthMapHeight[SkShadowShader::kMaxNonAmbientLights];
int fHeight;
int fWidth;
SkShadowParams fShadowParams;
SkColor3f fAmbientColor;
};
////////////////////////////////////////////////////////////////////////////
sk_sp<GrFragmentProcessor> SkShadowShaderImpl::asFragmentProcessor(const AsFPArgs& fpargs) const {
sk_sp<GrFragmentProcessor> povDepthFP = fPovDepthShader->asFragmentProcessor(fpargs);
sk_sp<GrFragmentProcessor> diffuseFP = fDiffuseShader->asFragmentProcessor(fpargs);
sk_sp<GrFragmentProcessor> shadowfp = sk_make_sp<ShadowFP>(std::move(povDepthFP),
std::move(diffuseFP),
std::move(fLights),
fDiffuseWidth, fDiffuseHeight,
fShadowParams, fpargs.fContext);
return shadowfp;
}
#endif
////////////////////////////////////////////////////////////////////////////
bool SkShadowShaderImpl::isOpaque() const {
return fDiffuseShader->isOpaque();
}
SkShadowShaderImpl::ShadowShaderContext::ShadowShaderContext(
const SkShadowShaderImpl& shader, const ContextRec& rec,
SkShader::Context* povDepthContext,
SkShader::Context* diffuseContext,
void* heapAllocated)
: INHERITED(shader, rec)
, fPovDepthContext(povDepthContext)
, fDiffuseContext(diffuseContext)
, fHeapAllocated(heapAllocated) {
bool isOpaque = shader.isOpaque();
// update fFlags
uint32_t flags = 0;
if (isOpaque && (255 == this->getPaintAlpha())) {
flags |= kOpaqueAlpha_Flag;
}
fFlags = flags;
const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
fNonAmbLightCnt = lightShader.fLights->numLights();
fShadowMapPixels = new SkPixmap[fNonAmbLightCnt];
for (int i = 0; i < fNonAmbLightCnt; i++) {
if (lightShader.fLights->light(i).type() == SkLights::Light::kDirectional_LightType) {
lightShader.fLights->light(i).getShadowMap()->
peekPixels(&fShadowMapPixels[i]);
}
}
}
SkShadowShaderImpl::ShadowShaderContext::~ShadowShaderContext() {
delete[] fShadowMapPixels;
// The dependencies have been created outside of the context on memory that was allocated by
// the onCreateContext() method. Call the destructors and free the memory.
fPovDepthContext->~Context();
fDiffuseContext->~Context();
sk_free(fHeapAllocated);
}
static inline SkPMColor convert(SkColor3f color, U8CPU a) {
if (color.fX <= 0.0f) {
color.fX = 0.0f;
} else if (color.fX >= 255.0f) {
color.fX = 255.0f;
}
if (color.fY <= 0.0f) {
color.fY = 0.0f;
} else if (color.fY >= 255.0f) {
color.fY = 255.0f;
}
if (color.fZ <= 0.0f) {
color.fZ = 0.0f;
} else if (color.fZ >= 255.0f) {
color.fZ = 255.0f;
}
return SkPreMultiplyARGB(a, (int) color.fX, (int) color.fY, (int) color.fZ);
}
// larger is better (fewer times we have to loop), but we shouldn't
// take up too much stack-space (each one here costs 16 bytes)
#define BUFFER_MAX 16
void SkShadowShaderImpl::ShadowShaderContext::shadeSpan(int x, int y,
SkPMColor result[], int count) {
const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
SkPMColor diffuse[BUFFER_MAX];
SkPMColor povDepth[BUFFER_MAX];
do {
int n = SkTMin(count, BUFFER_MAX);
fDiffuseContext->shadeSpan(x, y, diffuse, n);
fPovDepthContext->shadeSpan(x, y, povDepth, n);
for (int i = 0; i < n; ++i) {
SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[i]);
SkColor povDepthColor = povDepth[i];
SkColor3f totalLight = lightShader.fLights->ambientLightColor();
// This is all done in linear unpremul color space (each component 0..255.0f though)
for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
const SkLights::Light& light = lightShader.fLights->light(l);
int pvDepth = SkColorGetB(povDepthColor); // depth stored in blue channel
if (light.type() == SkLights::Light::kDirectional_LightType) {
int xOffset = SkScalarRoundToInt(light.dir().fX * pvDepth);
int yOffset = SkScalarRoundToInt(light.dir().fY * pvDepth);
int shX = SkClampMax(x + i + xOffset, light.getShadowMap()->width() - 1);
int shY = SkClampMax(y + yOffset, light.getShadowMap()->height() - 1);
int shDepth = 0;
int shDepthsq = 0;
// pixmaps that point to things have nonzero heights
if (fShadowMapPixels[l].height() > 0) {
uint32_t pix = *fShadowMapPixels[l].addr32(shX, shY);
SkColor shColor(pix);
shDepth = SkColorGetB(shColor);
shDepthsq = SkColorGetG(shColor) * 256;
} else {
// Make lights w/o a shadow map receive the full light contribution
shDepth = pvDepth;
}
SkScalar lightProb = 1.0f;
if (pvDepth < shDepth) {
if (lightShader.fShadowParams.fType ==
SkShadowParams::ShadowType::kVariance_ShadowType) {
int variance = SkMaxScalar(shDepthsq - shDepth * shDepth,
lightShader.fShadowParams.fMinVariance);
int d = pvDepth - shDepth;
lightProb = (SkScalar) variance / ((SkScalar) (variance + d * d));
SkScalar bias = lightShader.fShadowParams.fBiasingConstant;
lightProb = SkMaxScalar((lightProb - bias) / (1.0f - bias), 0.0f);
} else {
lightProb = 0.0f;
}
}
// assume object normals are pointing straight up
totalLight.fX += light.dir().fZ * light.color().fX * lightProb;
totalLight.fY += light.dir().fZ * light.color().fY * lightProb;
totalLight.fZ += light.dir().fZ * light.color().fZ * lightProb;
} else {
// right now we only expect directional and point light types.
SkASSERT(light.type() == SkLights::Light::kPoint_LightType);
int height = lightShader.fDiffuseHeight;
SkVector3 fragToLight = SkVector3::Make(light.pos().fX - x - i,
light.pos().fY - (height - y),
light.pos().fZ - pvDepth);
SkScalar dist = fragToLight.length();
SkScalar normalizedZ = fragToLight.fZ / dist;
SkScalar distAttenuation = light.intensity() / (1.0f + dist);
// assume object normals are pointing straight up
totalLight.fX += normalizedZ * light.color().fX * distAttenuation;
totalLight.fY += normalizedZ * light.color().fY * distAttenuation;
totalLight.fZ += normalizedZ * light.color().fZ * distAttenuation;
}
}
SkColor3f totalColor = SkColor3f::Make(SkColorGetR(diffColor) * totalLight.fX,
SkColorGetG(diffColor) * totalLight.fY,
SkColorGetB(diffColor) * totalLight.fZ);
result[i] = convert(totalColor, SkColorGetA(diffColor));
}
result += n;
x += n;
count -= n;
} while (count > 0);
}
////////////////////////////////////////////////////////////////////////////
#ifndef SK_IGNORE_TO_STRING
void SkShadowShaderImpl::toString(SkString* str) const {
str->appendf("ShadowShader: ()");
}
#endif
sk_sp<SkFlattenable> SkShadowShaderImpl::CreateProc(SkReadBuffer& buf) {
// Discarding SkShader flattenable params
bool hasLocalMatrix = buf.readBool();
SkAssertResult(!hasLocalMatrix);
sk_sp<SkLights> lights = SkLights::MakeFromBuffer(buf);
SkShadowParams params;
params.fMinVariance = buf.readScalar();
params.fBiasingConstant = buf.readScalar();
params.fType = (SkShadowParams::ShadowType) buf.readInt();
params.fShadowRadius = buf.readScalar();
int diffuseWidth = buf.readInt();
int diffuseHeight = buf.readInt();
sk_sp<SkShader> povDepthShader(buf.readFlattenable<SkShader>());
sk_sp<SkShader> diffuseShader(buf.readFlattenable<SkShader>());
return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
std::move(diffuseShader),
std::move(lights),
diffuseWidth, diffuseHeight,
params);
}
void SkShadowShaderImpl::flatten(SkWriteBuffer& buf) const {
this->INHERITED::flatten(buf);
fLights->flatten(buf);
buf.writeScalar(fShadowParams.fMinVariance);
buf.writeScalar(fShadowParams.fBiasingConstant);
buf.writeInt(fShadowParams.fType);
buf.writeScalar(fShadowParams.fShadowRadius);
buf.writeInt(fDiffuseWidth);
buf.writeInt(fDiffuseHeight);
buf.writeFlattenable(fPovDepthShader.get());
buf.writeFlattenable(fDiffuseShader.get());
}
size_t SkShadowShaderImpl::onContextSize(const ContextRec& rec) const {
return sizeof(ShadowShaderContext);
}
SkShader::Context* SkShadowShaderImpl::onCreateContext(const ContextRec& rec,
void* storage) const {
size_t heapRequired = fPovDepthShader->contextSize(rec) +
fDiffuseShader->contextSize(rec);
void* heapAllocated = sk_malloc_throw(heapRequired);
void* povDepthContextStorage = heapAllocated;
SkShader::Context* povDepthContext =
fPovDepthShader->createContext(rec, povDepthContextStorage);
if (!povDepthContext) {
sk_free(heapAllocated);
return nullptr;
}
void* diffuseContextStorage = (char*)heapAllocated + fPovDepthShader->contextSize(rec);
SkShader::Context* diffuseContext = fDiffuseShader->createContext(rec, diffuseContextStorage);
if (!diffuseContext) {
sk_free(heapAllocated);
return nullptr;
}
return new (storage) ShadowShaderContext(*this, rec, povDepthContext, diffuseContext,
heapAllocated);
}
///////////////////////////////////////////////////////////////////////////////
sk_sp<SkShader> SkShadowShader::Make(sk_sp<SkShader> povDepthShader,
sk_sp<SkShader> diffuseShader,
sk_sp<SkLights> lights,
int diffuseWidth, int diffuseHeight,
const SkShadowParams& params) {
if (!povDepthShader || !diffuseShader) {
// TODO: Use paint's color in absence of a diffuseShader
// TODO: Use a default implementation of normalSource instead
return nullptr;
}
return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
std::move(diffuseShader),
std::move(lights),
diffuseWidth, diffuseHeight,
params);
}
///////////////////////////////////////////////////////////////////////////////
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
///////////////////////////////////////////////////////////////////////////////
#endif