blob: 32e9b232ae85844464d9064858837b543401032d [file] [log] [blame]
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkEmbossMask.h"
#include "SkMath.h"
static inline int nonzero_to_one(int x) {
#if 0
return x != 0;
#else
return ((unsigned)(x | -x)) >> 31;
#endif
}
static inline int neq_to_one(int x, int max) {
#if 0
return x != max;
#else
SkASSERT(x >= 0 && x <= max);
return ((unsigned)(x - max)) >> 31;
#endif
}
static inline int neq_to_mask(int x, int max) {
#if 0
return -(x != max);
#else
SkASSERT(x >= 0 && x <= max);
return (x - max) >> 31;
#endif
}
static inline unsigned div255(unsigned x) {
SkASSERT(x <= (255*255));
return x * ((1 << 24) / 255) >> 24;
}
#define kDelta 32 // small enough to show off angle differences
#include "SkEmbossMask_Table.h"
#if defined(SK_BUILD_FOR_WIN32) && defined(SK_DEBUG)
#include <stdio.h>
void SkEmbossMask_BuildTable() {
// build it 0..127 x 0..127, so we use 2^15 - 1 in the numerator for our "fixed" table
FILE* file = ::fopen("SkEmbossMask_Table.h", "w");
SkASSERT(file);
::fprintf(file, "#include \"SkTypes.h\"\n\n");
::fprintf(file, "static const U16 gInvSqrtTable[128 * 128] = {\n");
for (int dx = 0; dx <= 255/2; dx++) {
for (int dy = 0; dy <= 255/2; dy++) {
if ((dy & 15) == 0)
::fprintf(file, "\t");
uint16_t value = SkToU16((1 << 15) / SkSqrt32(dx * dx + dy * dy + kDelta*kDelta/4));
::fprintf(file, "0x%04X", value);
if (dx * 128 + dy < 128*128-1) {
::fprintf(file, ", ");
}
if ((dy & 15) == 15) {
::fprintf(file, "\n");
}
}
}
::fprintf(file, "};\n#define kDeltaUsedToBuildTable\t%d\n", kDelta);
::fclose(file);
}
#endif
void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light) {
SkASSERT(kDelta == kDeltaUsedToBuildTable);
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->fImage;
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++) {
if (alpha[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
#if 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
#else
// can use full numer, but then we need to call SkFixedMul, since
// numer is 24 bits, and our table is 12 bits
// SkFixed dot = SkFixedMul(numer, gTable[]) >> 8
SkFixed dot = (unsigned)(numer >> 4) * gInvSqrtTable[(SkAbs32(nx) >> 1 << 7) | (SkAbs32(ny) >> 1)] >> 20;
#endif
mul = SkFastMin32(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 = SkClampMax(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);
// multiply[x] = 0xFF;
// additive[x] = 0;
// ((uint8_t*)alpha)[x] = alpha[x] * multiply[x] >> 8;
}
}
alpha += rowBytes;
multiply += rowBytes;
additive += rowBytes;
prev_row = rowBytes;
}
}