SkEmbossMask Class Reference

#include <SkEmbossMask.h>

Static Public Member Functions
static void	Emboss (SkMaskBuilder *mask, const SkEmbossMaskFilter::Light &)

Detailed Description

Definition at line 16 of file SkEmbossMask.h.

Member Function Documentation

Emboss()

void SkEmbossMask::Emboss ( SkMaskBuilder *  mask, const SkEmbossMaskFilter::Light &  light  )

static

Definition at line 55 of file SkEmbossMask.cpp.

                                                                                   {
    SkASSERT(mask->fFormat == SkMask::k3D_Format);
 
    int     specular = light.fSpecular;
    int     ambient = light.fAmbient;
    SkFixed lx = SkScalarToFixed(light.fDirection[0]);
    SkFixed ly = SkScalarToFixed(light.fDirection[1]);
    SkFixed lz = SkScalarToFixed(light.fDirection[2]);
    SkFixed lz_dot_nz = lz * kDelta;
    int     lz_dot8 = lz >> 8;
 
    size_t      planeSize = mask->computeImageSize();
    uint8_t*    alpha = mask->image();
    uint8_t*    multiply = (uint8_t*)alpha + planeSize;
    uint8_t*    additive = multiply + planeSize;
 
    int rowBytes = mask->fRowBytes;
    int maxy = mask->fBounds.height() - 1;
    int maxx = mask->fBounds.width() - 1;
 
    int prev_row = 0;
    for (int y = 0; y <= maxy; y++) {
        int next_row = neq_to_mask(y, maxy) & rowBytes;
 
        for (int x = 0; x <= maxx; x++) {
            int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
            int ny = alpha[x + next_row] - alpha[x - prev_row];
 
            SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
            int     mul = ambient;
            int     add = 0;
 
            if (numer > 0) {  // preflight when numer/denom will be <= 0
                int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
                SkFixed dot = numer / denom;
                dot >>= 8;  // now dot is 2^8 instead of 2^16
                mul = std::min(mul + dot, 255);
 
                // now for the reflection
 
                //  R = 2 (Light * Normal) Normal - Light
                //  hilite = R * Eye(0, 0, 1)
 
                int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
                if (hilite > 0) {
                    // pin hilite to 255, since our fast math is also a little sloppy
                    hilite = std::min(hilite, 255);
 
                    // specular is 4.4
                    // would really like to compute the fractional part of this
                    // and then possibly cache a 256 table for a given specular
                    // value in the light, and just pass that in to this function.
                    add = hilite;
                    for (int i = specular >> 4; i > 0; --i) {
                        add = div255(add * hilite);
                    }
                }
            }
            multiply[x] = SkToU8(mul);
            additive[x] = SkToU8(add);
        }
        alpha += rowBytes;
        multiply += rowBytes;
        additive += rowBytes;
        prev_row = rowBytes;
    }
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/effects/SkEmbossMask.h
• third_party/skia/src/effects/SkEmbossMask.cpp