1 /* libs/graphics/effects/SkEmbossMask.cpp
2 **
3 ** Copyright 2006, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #include "SkEmbossMask.h"
19
nonzero_to_one(int x)20 static inline int nonzero_to_one(int x)
21 {
22 #if 0
23 return x != 0;
24 #else
25 return ((unsigned)(x | -x)) >> 31;
26 #endif
27 }
28
neq_to_one(int x,int max)29 static inline int neq_to_one(int x, int max)
30 {
31 #if 0
32 return x != max;
33 #else
34 SkASSERT(x >= 0 && x <= max);
35 return ((unsigned)(x - max)) >> 31;
36 #endif
37 }
38
neq_to_mask(int x,int max)39 static inline int neq_to_mask(int x, int max)
40 {
41 #if 0
42 return -(x != max);
43 #else
44 SkASSERT(x >= 0 && x <= max);
45 return (x - max) >> 31;
46 #endif
47 }
48
div255(unsigned x)49 static inline unsigned div255(unsigned x)
50 {
51 SkASSERT(x <= (255*255));
52 return x * ((1 << 24) / 255) >> 24;
53 }
54
55 #define kDelta 32 // small enough to show off angle differences
56
57 #include "SkEmbossMask_Table.h"
58
59 #if defined(SK_BUILD_FOR_WIN32) && defined(SK_DEBUG)
60
61 #include <stdio.h>
62
SkEmbossMask_BuildTable()63 void SkEmbossMask_BuildTable()
64 {
65 // build it 0..127 x 0..127, so we use 2^15 - 1 in the numerator for our "fixed" table
66
67 FILE* file = ::fopen("SkEmbossMask_Table.h", "w");
68 SkASSERT(file);
69 ::fprintf(file, "#include \"SkTypes.h\"\n\n");
70 ::fprintf(file, "static const U16 gInvSqrtTable[128 * 128] = {\n");
71 for (int dx = 0; dx <= 255/2; dx++)
72 {
73 for (int dy = 0; dy <= 255/2; dy++)
74 {
75 if ((dy & 15) == 0)
76 ::fprintf(file, "\t");
77
78 uint16_t value = SkToU16((1 << 15) / SkSqrt32(dx * dx + dy * dy + kDelta*kDelta/4));
79
80 ::fprintf(file, "0x%04X", value);
81 if (dx * 128 + dy < 128*128-1)
82 ::fprintf(file, ", ");
83 if ((dy & 15) == 15)
84 ::fprintf(file, "\n");
85 }
86 }
87 ::fprintf(file, "};\n#define kDeltaUsedToBuildTable\t%d\n", kDelta);
88 ::fclose(file);
89 }
90
91 #endif
92
Emboss(SkMask * mask,const SkEmbossMaskFilter::Light & light)93 void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
94 {
95 SkASSERT(kDelta == kDeltaUsedToBuildTable);
96
97 SkASSERT(mask->fFormat == SkMask::k3D_Format);
98
99 int specular = light.fSpecular;
100 int ambient = light.fAmbient;
101 SkFixed lx = SkScalarToFixed(light.fDirection[0]);
102 SkFixed ly = SkScalarToFixed(light.fDirection[1]);
103 SkFixed lz = SkScalarToFixed(light.fDirection[2]);
104 SkFixed lz_dot_nz = lz * kDelta;
105 int lz_dot8 = lz >> 8;
106
107 size_t planeSize = mask->computeImageSize();
108 uint8_t* alpha = mask->fImage;
109 uint8_t* multiply = (uint8_t*)alpha + planeSize;
110 uint8_t* additive = multiply + planeSize;
111
112 int rowBytes = mask->fRowBytes;
113 int maxy = mask->fBounds.height() - 1;
114 int maxx = mask->fBounds.width() - 1;
115
116 int prev_row = 0;
117 for (int y = 0; y <= maxy; y++)
118 {
119 int next_row = neq_to_mask(y, maxy) & rowBytes;
120
121 for (int x = 0; x <= maxx; x++)
122 {
123 if (alpha[x])
124 {
125 int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
126 int ny = alpha[x + next_row] - alpha[x - prev_row];
127
128 SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
129 int mul = ambient;
130 int add = 0;
131
132 if (numer > 0) // preflight when numer/denom will be <= 0
133 {
134 #if 0
135 int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
136 SkFixed dot = numer / denom;
137 dot >>= 8; // now dot is 2^8 instead of 2^16
138 #else
139 // can use full numer, but then we need to call SkFixedMul, since
140 // numer is 24 bits, and our table is 12 bits
141
142 // SkFixed dot = SkFixedMul(numer, gTable[]) >> 8
143 SkFixed dot = (unsigned)(numer >> 4) * gInvSqrtTable[(SkAbs32(nx) >> 1 << 7) | (SkAbs32(ny) >> 1)] >> 20;
144 #endif
145 mul = SkFastMin32(mul + dot, 255);
146
147 // now for the reflection
148
149 // R = 2 (Light * Normal) Normal - Light
150 // hilite = R * Eye(0, 0, 1)
151
152 int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
153 if (hilite > 0)
154 {
155 // pin hilite to 255, since our fast math is also a little sloppy
156 hilite = SkClampMax(hilite, 255);
157
158 // specular is 4.4
159 // would really like to compute the fractional part of this
160 // and then possibly cache a 256 table for a given specular
161 // value in the light, and just pass that in to this function.
162 add = hilite;
163 for (int i = specular >> 4; i > 0; --i)
164 add = div255(add * hilite);
165 }
166 }
167 multiply[x] = SkToU8(mul);
168 additive[x] = SkToU8(add);
169
170 // multiply[x] = 0xFF;
171 // additive[x] = 0;
172 // ((uint8_t*)alpha)[x] = alpha[x] * multiply[x] >> 8;
173 }
174 }
175 alpha += rowBytes;
176 multiply += rowBytes;
177 additive += rowBytes;
178 prev_row = rowBytes;
179 }
180 }
181
182
183