SkDrawShadowMetrics Namespace Reference

Functions
static SkScalar	compute_z (SkScalar x, SkScalar y, const SkPoint3 &params)
bool	GetSpotShadowTransform (const SkPoint3 &lightPos, SkScalar lightRadius, const SkMatrix &ctm, const SkPoint3 &zPlaneParams, const SkRect &pathBounds, bool directional, SkMatrix *shadowTransform, SkScalar *radius)
void	GetLocalBounds (const SkPath &path, const SkDrawShadowRec &rec, const SkMatrix &ctm, SkRect *bounds)
static float	divide_and_pin (float numer, float denom, float min, float max)
SkScalar	AmbientBlurRadius (SkScalar height)
SkScalar	AmbientRecipAlpha (SkScalar height)
SkScalar	SpotBlurRadius (SkScalar occluderZ, SkScalar lightZ, SkScalar lightRadius)
void	GetSpotParams (SkScalar occluderZ, SkScalar lightX, SkScalar lightY, SkScalar lightZ, SkScalar lightRadius, SkScalar *blurRadius, SkScalar *scale, SkVector *translate)
void	GetDirectionalParams (SkScalar occluderZ, SkScalar lightX, SkScalar lightY, SkScalar lightZ, SkScalar lightRadius, SkScalar *blurRadius, SkScalar *scale, SkVector *translate)

Variables
static constexpr auto	kAmbientHeightFactor = 1.0f / 128.0f
static constexpr auto	kAmbientGeomFactor = 64.0f
static constexpr auto	kMaxAmbientRadius = 300*kAmbientHeightFactor*kAmbientGeomFactor

Function Documentation

AmbientBlurRadius()

SkScalar SkDrawShadowMetrics::AmbientBlurRadius ( SkScalar  height )

inline

Definition at line 51 of file SkDrawShadowInfo.h.

                                                   {
    return std::min(height*kAmbientHeightFactor*kAmbientGeomFactor, kMaxAmbientRadius);
}

AmbientRecipAlpha()

SkScalar SkDrawShadowMetrics::AmbientRecipAlpha ( SkScalar  height )

inline

Definition at line 55 of file SkDrawShadowInfo.h.

                                                   {
    return 1.0f + std::max(height*kAmbientHeightFactor, 0.0f);
}

compute_z()

static SkScalar SkDrawShadowMetrics::compute_z ( SkScalar  x, SkScalar  y, const SkPoint3 &  params  )

static

Definition at line 18 of file SkDrawShadowInfo.cpp.

                                                                          {
    return x*params.fX + y*params.fY + params.fZ;
}

divide_and_pin()

static float SkDrawShadowMetrics::divide_and_pin ( float  numer, float  denom, float  min, float  max  )

inlinestatic

Definition at line 44 of file SkDrawShadowInfo.h.

                                                                                   {
    float result = SkTPin(sk_ieee_float_divide(numer, denom), min, max);
    // ensure that SkTPin handled non-finites correctly
    SkASSERT(result >= min && result <= max);
    return result;
}

GetDirectionalParams()

void SkDrawShadowMetrics::GetDirectionalParams ( SkScalar  occluderZ, SkScalar  lightX, SkScalar  lightY, SkScalar  lightZ, SkScalar  lightRadius, SkScalar *  blurRadius, SkScalar *  scale, SkVector *  translate  )

inline

Definition at line 72 of file SkDrawShadowInfo.h.

                                                                                             {
    *blurRadius = lightRadius*occluderZ;
    *scale = 1;
    // Max z-ratio is "max expected elevation"/"min allowable z"
    constexpr SkScalar kMaxZRatio = 64/SK_ScalarNearlyZero;
    SkScalar zRatio = divide_and_pin(occluderZ, lightZ, 0.0f, kMaxZRatio);
    *translate = SkVector::Make(-zRatio * lightX, -zRatio * lightY);
}

GetLocalBounds()

void SkDrawShadowMetrics::GetLocalBounds	(	const SkPath &	path,
		const SkDrawShadowRec &	rec,
		const SkMatrix &	ctm,
		SkRect *	bounds
	)

Definition at line 124 of file SkDrawShadowInfo.cpp.

                                    {
    SkRect ambientBounds = path.getBounds();
    SkScalar occluderZ;
    if (SkScalarNearlyZero(rec.fZPlaneParams.fX) && SkScalarNearlyZero(rec.fZPlaneParams.fY)) {
        occluderZ = rec.fZPlaneParams.fZ;
    } else {
        occluderZ = compute_z(ambientBounds.fLeft, ambientBounds.fTop, rec.fZPlaneParams);
        occluderZ = std::max(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fTop,
                                                rec.fZPlaneParams));
        occluderZ = std::max(occluderZ, compute_z(ambientBounds.fLeft, ambientBounds.fBottom,
                                                rec.fZPlaneParams));
        occluderZ = std::max(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fBottom,
                                                rec.fZPlaneParams));
    }
    SkScalar ambientBlur;
    SkScalar spotBlur;
    SkScalar spotScale;
    SkPoint spotOffset;
    if (ctm.hasPerspective()) {
        // transform ambient and spot bounds into device space
        ctm.mapRect(&ambientBounds);
 
        // get ambient blur (in device space)
        ambientBlur = SkDrawShadowMetrics::AmbientBlurRadius(occluderZ);
 
        // get spot params (in device space)
        if (SkToBool(rec.fFlags & SkShadowFlags::kDirectionalLight_ShadowFlag)) {
            SkDrawShadowMetrics::GetDirectionalParams(occluderZ, rec.fLightPos.fX, rec.fLightPos.fY,
                                                      rec.fLightPos.fZ, rec.fLightRadius,
                                                      &spotBlur, &spotScale, &spotOffset);
        } else {
            SkPoint devLightPos = SkPoint::Make(rec.fLightPos.fX, rec.fLightPos.fY);
            ctm.mapPoints(&devLightPos, 1);
            SkDrawShadowMetrics::GetSpotParams(occluderZ, devLightPos.fX, devLightPos.fY,
                                               rec.fLightPos.fZ, rec.fLightRadius,
                                               &spotBlur, &spotScale, &spotOffset);
        }
    } else {
        SkScalar devToSrcScale = SkScalarInvert(ctm.getMinScale());
 
        // get ambient blur (in local space)
        SkScalar devSpaceAmbientBlur = SkDrawShadowMetrics::AmbientBlurRadius(occluderZ);
        ambientBlur = devSpaceAmbientBlur*devToSrcScale;
 
        // get spot params (in local space)
        if (SkToBool(rec.fFlags & SkShadowFlags::kDirectionalLight_ShadowFlag)) {
            SkDrawShadowMetrics::GetDirectionalParams(occluderZ, rec.fLightPos.fX, rec.fLightPos.fY,
                                                      rec.fLightPos.fZ, rec.fLightRadius,
                                                      &spotBlur, &spotScale, &spotOffset);
            // light dir is in device space, so need to map spot offset back into local space
            SkMatrix inverse;
            if (ctm.invert(&inverse)) {
                inverse.mapVectors(&spotOffset, 1);
            }
        } else {
            SkDrawShadowMetrics::GetSpotParams(occluderZ, rec.fLightPos.fX, rec.fLightPos.fY,
                                               rec.fLightPos.fZ, rec.fLightRadius,
                                               &spotBlur, &spotScale, &spotOffset);
        }
 
        // convert spot blur to local space
        spotBlur *= devToSrcScale;
    }
 
    // in both cases, adjust ambient and spot bounds
    SkRect spotBounds = ambientBounds;
    ambientBounds.outset(ambientBlur, ambientBlur);
    spotBounds.fLeft *= spotScale;
    spotBounds.fTop *= spotScale;
    spotBounds.fRight *= spotScale;
    spotBounds.fBottom *= spotScale;
    spotBounds.offset(spotOffset.fX, spotOffset.fY);
    spotBounds.outset(spotBlur, spotBlur);
 
    // merge bounds
    *bounds = ambientBounds;
    bounds->join(spotBounds);
    // outset a bit to account for floating point error
    bounds->outset(1, 1);
 
    // if perspective, transform back to src space
    if (ctm.hasPerspective()) {
        // TODO: create tighter mapping from dev rect back to src rect
        SkMatrix inverse;
        if (ctm.invert(&inverse)) {
            inverse.mapRect(bounds);
        }
    }
}

GetSpotParams()

void SkDrawShadowMetrics::GetSpotParams ( SkScalar  occluderZ, SkScalar  lightX, SkScalar  lightY, SkScalar  lightZ, SkScalar  lightRadius, SkScalar *  blurRadius, SkScalar *  scale, SkVector *  translate  )

inline

Definition at line 63 of file SkDrawShadowInfo.h.

                                                                                      {
    SkScalar zRatio = divide_and_pin(occluderZ, lightZ - occluderZ, 0.0f, 0.95f);
    *blurRadius = lightRadius*zRatio;
    *scale = divide_and_pin(lightZ, lightZ - occluderZ, 1.0f, 1.95f);
    *translate = SkVector::Make(-zRatio * lightX, -zRatio * lightY);
}

GetSpotShadowTransform()

bool SkDrawShadowMetrics::GetSpotShadowTransform	(	const SkPoint3 &	lightPos,
		SkScalar	lightRadius,
		const SkMatrix &	ctm,
		const SkPoint3 &	zPlaneParams,
		const SkRect &	pathBounds,
		bool	directional,
		SkMatrix *	shadowTransform,
		SkScalar *	radius
	)

Definition at line 22 of file SkDrawShadowInfo.cpp.

                                                                         {
    auto heightFunc = [zPlaneParams] (SkScalar x, SkScalar y) {
        return zPlaneParams.fX*x + zPlaneParams.fY*y + zPlaneParams.fZ;
    };
    SkScalar occluderHeight = heightFunc(pathBounds.centerX(), pathBounds.centerY());
 
    // TODO: have directional lights support tilt via the zPlaneParams
    if (!ctm.hasPerspective() || directional) {
        SkScalar scale;
        SkVector translate;
        if (directional) {
            SkDrawShadowMetrics::GetDirectionalParams(occluderHeight, lightPos.fX, lightPos.fY,
                                                      lightPos.fZ, lightRadius, radius,
                                                      &scale, &translate);
        } else {
            SkDrawShadowMetrics::GetSpotParams(occluderHeight, lightPos.fX, lightPos.fY,
                                               lightPos.fZ, lightRadius, radius,
                                               &scale, &translate);
        }
        shadowTransform->setScaleTranslate(scale, scale, translate.fX, translate.fY);
        shadowTransform->preConcat(ctm);
    } else {
        if (SkScalarNearlyZero(pathBounds.width()) || SkScalarNearlyZero(pathBounds.height())) {
            return false;
        }
 
        // get rotated quad in 3D
        SkPoint pts[4];
        ctm.mapRectToQuad(pts, pathBounds);
 
        SkPoint3 pts3D[4];
        SkScalar z = heightFunc(pathBounds.fLeft, pathBounds.fTop);
        pts3D[0].set(pts[0].fX, pts[0].fY, z);
        z = heightFunc(pathBounds.fRight, pathBounds.fTop);
        pts3D[1].set(pts[1].fX, pts[1].fY, z);
        z = heightFunc(pathBounds.fRight, pathBounds.fBottom);
        pts3D[2].set(pts[2].fX, pts[2].fY, z);
        z = heightFunc(pathBounds.fLeft, pathBounds.fBottom);
        pts3D[3].set(pts[3].fX, pts[3].fY, z);
 
        // project from light through corners to z=0 plane
        for (int i = 0; i < 4; ++i) {
            SkScalar dz = lightPos.fZ - pts3D[i].fZ;
            // light shouldn't be below or at a corner's z-location
            if (dz <= SK_ScalarNearlyZero) {
                return false;
            }
            SkScalar zRatio = pts3D[i].fZ / dz;
            pts3D[i].fX -= (lightPos.fX - pts3D[i].fX)*zRatio;
            pts3D[i].fY -= (lightPos.fY - pts3D[i].fY)*zRatio;
            pts3D[i].fZ = SK_Scalar1;
        }
 
        // Generate matrix that projects from [-1,1]x[-1,1] square to projected quad
        SkPoint3 h0, h1, h2;
        // Compute homogenous crossing point between top and bottom edges (gives new x-axis).
        h0 = (pts3D[1].cross(pts3D[0])).cross(pts3D[2].cross(pts3D[3]));
        // Compute homogenous crossing point between left and right edges (gives new y-axis).
        h1 = (pts3D[0].cross(pts3D[3])).cross(pts3D[1].cross(pts3D[2]));
        // Compute homogenous crossing point between diagonals (gives new origin).
        h2 = (pts3D[0].cross(pts3D[2])).cross(pts3D[1].cross(pts3D[3]));
        // If h2 is a vector (z=0 in 2D homogeneous space), that means that at least
        // two of the quad corners are coincident and we don't have a realistic projection
        if (SkScalarNearlyZero(h2.fZ)) {
            return false;
        }
        // In some cases the crossing points are in the wrong direction
        // to map (-1,-1) to pts3D[0], so we need to correct for that.
        // Want h0 to be to the right of the left edge.
        SkVector3 v = pts3D[3] - pts3D[0];
        SkVector3 w = h0 - pts3D[0];
        SkScalar perpDot = v.fX*w.fY - v.fY*w.fX;
        if (perpDot > 0) {
            h0 = -h0;
        }
        // Want h1 to be above the bottom edge.
        v = pts3D[1] - pts3D[0];
        perpDot = v.fX*w.fY - v.fY*w.fX;
        if (perpDot < 0) {
            h1 = -h1;
        }
        shadowTransform->setAll(h0.fX / h2.fZ, h1.fX / h2.fZ, h2.fX / h2.fZ,
                               h0.fY / h2.fZ, h1.fY / h2.fZ, h2.fY / h2.fZ,
                               h0.fZ / h2.fZ, h1.fZ / h2.fZ, 1);
        // generate matrix that transforms from bounds to [-1,1]x[-1,1] square
        SkMatrix toHomogeneous;
        SkScalar xScale = 2/(pathBounds.fRight - pathBounds.fLeft);
        SkScalar yScale = 2/(pathBounds.fBottom - pathBounds.fTop);
        toHomogeneous.setAll(xScale, 0, -xScale*pathBounds.fLeft - 1,
                             0, yScale, -yScale*pathBounds.fTop - 1,
                             0, 0, 1);
        shadowTransform->preConcat(toHomogeneous);
 
        *radius = SkDrawShadowMetrics::SpotBlurRadius(occluderHeight, lightPos.fZ, lightRadius);
    }
 
    return true;
}

SpotBlurRadius()

SkScalar SkDrawShadowMetrics::SpotBlurRadius ( SkScalar  occluderZ, SkScalar  lightZ, SkScalar  lightRadius  )

inline

Definition at line 59 of file SkDrawShadowInfo.h.

                                                                                          {
    return lightRadius*divide_and_pin(occluderZ, lightZ - occluderZ, 0.0f, 0.95f);
}

Variable Documentation

kAmbientGeomFactor

constexpr auto SkDrawShadowMetrics::kAmbientGeomFactor = 64.0f

staticconstexpr

Definition at line 38 of file SkDrawShadowInfo.h.

kAmbientHeightFactor

constexpr auto SkDrawShadowMetrics::kAmbientHeightFactor = 1.0f / 128.0f

staticconstexpr

Definition at line 37 of file SkDrawShadowInfo.h.

kMaxAmbientRadius

constexpr auto SkDrawShadowMetrics::kMaxAmbientRadius = 300*kAmbientHeightFactor*kAmbientGeomFactor

staticconstexpr

Definition at line 42 of file SkDrawShadowInfo.h.