1 /* libs/graphics/effects/SkCamera.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 "SkCamera.h"
19
SkScalarDotDiv(int count,const SkScalar a[],int step_a,const SkScalar b[],int step_b,SkScalar denom)20 static SkScalar SkScalarDotDiv(int count, const SkScalar a[], int step_a,
21 const SkScalar b[], int step_b,
22 SkScalar denom) {
23 #ifdef SK_SCALAR_IS_FLOAT
24 float prod = 0;
25 for (int i = 0; i < count; i++) {
26 prod += a[0] * b[0];
27 a += step_a;
28 b += step_b;
29 }
30 return prod / denom;
31 #else
32 Sk64 prod, tmp;
33
34 prod.set(0);
35 for (int i = 0; i < count; i++) {
36 tmp.setMul(a[0], b[0]);
37 prod.add(tmp);
38 a += step_a;
39 b += step_b;
40 }
41 prod.div(denom, Sk64::kRound_DivOption);
42 return prod.get32();
43 #endif
44 }
45
SkScalarDot(int count,const SkScalar a[],int step_a,const SkScalar b[],int step_b)46 static SkScalar SkScalarDot(int count, const SkScalar a[], int step_a,
47 const SkScalar b[], int step_b) {
48 #ifdef SK_SCALAR_IS_FLOAT
49 float prod = 0;
50 for (int i = 0; i < count; i++) {
51 prod += a[0] * b[0];
52 a += step_a;
53 b += step_b;
54 }
55 return prod;
56 #else
57 Sk64 prod, tmp;
58
59 prod.set(0);
60 for (int i = 0; i < count; i++) {
61 tmp.setMul(a[0], b[0]);
62 prod.add(tmp);
63 a += step_a;
64 b += step_b;
65 }
66 return prod.getFixed();
67 #endif
68 }
69
70 ///////////////////////////////////////////////////////////////////////////////
71
normalize(SkUnit3D * unit) const72 SkUnitScalar SkPoint3D::normalize(SkUnit3D* unit) const {
73 #ifdef SK_SCALAR_IS_FLOAT
74 float mag = sk_float_sqrt(fX*fX + fY*fY + fZ*fZ);
75 if (mag) {
76 float scale = 1.0f / mag;
77 unit->fX = fX * scale;
78 unit->fY = fY * scale;
79 unit->fZ = fZ * scale;
80 } else {
81 unit->fX = unit->fY = unit->fZ = 0;
82 }
83 #else
84 Sk64 tmp1, tmp2;
85
86 tmp1.setMul(fX, fX);
87 tmp2.setMul(fY, fY);
88 tmp1.add(tmp2);
89 tmp2.setMul(fZ, fZ);
90 tmp1.add(tmp2);
91
92 SkFixed mag = tmp1.getSqrt();
93 if (mag) {
94 // what if mag < SK_Fixed1 ??? we will underflow the fixdiv
95 SkFixed scale = SkFixedDiv(SK_Fract1, mag);
96 unit->fX = SkFixedMul(fX, scale);
97 unit->fY = SkFixedMul(fY, scale);
98 unit->fZ = SkFixedMul(fZ, scale);
99 } else {
100 unit->fX = unit->fY = unit->fZ = 0;
101 }
102 #endif
103 return mag;
104 }
105
Dot(const SkUnit3D & a,const SkUnit3D & b)106 SkUnitScalar SkUnit3D::Dot(const SkUnit3D& a, const SkUnit3D& b) {
107 return SkUnitScalarMul(a.fX, b.fX) +
108 SkUnitScalarMul(a.fY, b.fY) +
109 SkUnitScalarMul(a.fZ, b.fZ);
110 }
111
Cross(const SkUnit3D & a,const SkUnit3D & b,SkUnit3D * cross)112 void SkUnit3D::Cross(const SkUnit3D& a, const SkUnit3D& b, SkUnit3D* cross) {
113 SkASSERT(cross);
114
115 // use x,y,z, in case &a == cross or &b == cross
116
117 SkScalar x = SkUnitScalarMul(a.fY, b.fZ) - SkUnitScalarMul(a.fZ, b.fY);
118 SkScalar y = SkUnitScalarMul(a.fZ, b.fX) - SkUnitScalarMul(a.fX, b.fY);
119 SkScalar z = SkUnitScalarMul(a.fX, b.fY) - SkUnitScalarMul(a.fY, b.fX);
120
121 cross->set(x, y, z);
122 }
123
124 ///////////////////////////////////////////////////////////////////////////////
125
SkPatch3D()126 SkPatch3D::SkPatch3D() {
127 this->reset();
128 }
129
reset()130 void SkPatch3D::reset() {
131 fOrigin.set(0, 0, 0);
132 fU.set(SK_Scalar1, 0, 0);
133 fV.set(0, -SK_Scalar1, 0);
134 }
135
transform(const SkMatrix3D & m,SkPatch3D * dst) const136 void SkPatch3D::transform(const SkMatrix3D& m, SkPatch3D* dst) const {
137 if (dst == NULL) {
138 dst = (SkPatch3D*)this;
139 }
140 m.mapVector(fU, &dst->fU);
141 m.mapVector(fV, &dst->fV);
142 m.mapPoint(fOrigin, &dst->fOrigin);
143 }
144
dotWith(SkScalar dx,SkScalar dy,SkScalar dz) const145 SkScalar SkPatch3D::dotWith(SkScalar dx, SkScalar dy, SkScalar dz) const {
146 SkScalar cx = SkScalarMul(fU.fY, fV.fZ) - SkScalarMul(fU.fZ, fV.fY);
147 SkScalar cy = SkScalarMul(fU.fZ, fV.fX) - SkScalarMul(fU.fX, fV.fY);
148 SkScalar cz = SkScalarMul(fU.fX, fV.fY) - SkScalarMul(fU.fY, fV.fX);
149
150 return SkScalarMul(cx, dx) + SkScalarMul(cy, dy) + SkScalarMul(cz, dz);
151 }
152
153 ///////////////////////////////////////////////////////////////////////////////
154
reset()155 void SkMatrix3D::reset() {
156 memset(fMat, 0, sizeof(fMat));
157 fMat[0][0] = fMat[1][1] = fMat[2][2] = SK_Scalar1;
158 }
159
setTranslate(SkScalar x,SkScalar y,SkScalar z)160 void SkMatrix3D::setTranslate(SkScalar x, SkScalar y, SkScalar z) {
161 memset(fMat, 0, sizeof(fMat));
162 fMat[0][0] = x;
163 fMat[1][1] = y;
164 fMat[2][2] = z;
165 }
166
setRotateX(SkScalar degX)167 void SkMatrix3D::setRotateX(SkScalar degX) {
168 SkScalar s, c;
169
170 s = SkScalarSinCos(SkDegreesToRadians(degX), &c);
171 this->setRow(0, SK_Scalar1, 0, 0);
172 this->setRow(1, 0, c, -s);
173 this->setRow(2, 0, s, c);
174 }
175
setRotateY(SkScalar degY)176 void SkMatrix3D::setRotateY(SkScalar degY) {
177 SkScalar s, c;
178
179 s = SkScalarSinCos(SkDegreesToRadians(degY), &c);
180 this->setRow(0, c, 0, -s);
181 this->setRow(1, 0, SK_Scalar1, 0);
182 this->setRow(2, s, 0, c);
183 }
184
setRotateZ(SkScalar degZ)185 void SkMatrix3D::setRotateZ(SkScalar degZ) {
186 SkScalar s, c;
187
188 s = SkScalarSinCos(SkDegreesToRadians(degZ), &c);
189 this->setRow(0, c, -s, 0);
190 this->setRow(1, s, c, 0);
191 this->setRow(2, 0, 0, SK_Scalar1);
192 }
193
preTranslate(SkScalar x,SkScalar y,SkScalar z)194 void SkMatrix3D::preTranslate(SkScalar x, SkScalar y, SkScalar z) {
195 SkScalar col[3] = { x, y, z};
196
197 for (int i = 0; i < 3; i++) {
198 fMat[i][3] += SkScalarDot(3, &fMat[i][0], 1, col, 1);
199 }
200 }
201
preRotateX(SkScalar degX)202 void SkMatrix3D::preRotateX(SkScalar degX) {
203 SkMatrix3D m;
204 m.setRotateX(degX);
205 this->setConcat(*this, m);
206 }
207
preRotateY(SkScalar degY)208 void SkMatrix3D::preRotateY(SkScalar degY) {
209 SkMatrix3D m;
210 m.setRotateY(degY);
211 this->setConcat(*this, m);
212 }
213
preRotateZ(SkScalar degZ)214 void SkMatrix3D::preRotateZ(SkScalar degZ) {
215 SkMatrix3D m;
216 m.setRotateZ(degZ);
217 this->setConcat(*this, m);
218 }
219
setConcat(const SkMatrix3D & a,const SkMatrix3D & b)220 void SkMatrix3D::setConcat(const SkMatrix3D& a, const SkMatrix3D& b) {
221 SkMatrix3D tmp;
222 SkMatrix3D* c = this;
223
224 if (this == &a || this == &b) {
225 c = &tmp;
226 }
227 for (int i = 0; i < 3; i++) {
228 for (int j = 0; j < 3; j++) {
229 c->fMat[i][j] = SkScalarDot(3, &a.fMat[i][0], 1, &b.fMat[0][j], 4);
230 }
231 c->fMat[i][3] = SkScalarDot(3, &a.fMat[i][0], 1,
232 &b.fMat[0][3], 4) + a.fMat[i][3];
233 }
234
235 if (c == &tmp) {
236 *this = tmp;
237 }
238 }
239
mapPoint(const SkPoint3D & src,SkPoint3D * dst) const240 void SkMatrix3D::mapPoint(const SkPoint3D& src, SkPoint3D* dst) const {
241 SkScalar x = SkScalarDot(3, &fMat[0][0], 1, &src.fX, 1) + fMat[0][3];
242 SkScalar y = SkScalarDot(3, &fMat[1][0], 1, &src.fX, 1) + fMat[1][3];
243 SkScalar z = SkScalarDot(3, &fMat[2][0], 1, &src.fX, 1) + fMat[2][3];
244 dst->set(x, y, z);
245 }
246
mapVector(const SkVector3D & src,SkVector3D * dst) const247 void SkMatrix3D::mapVector(const SkVector3D& src, SkVector3D* dst) const {
248 SkScalar x = SkScalarDot(3, &fMat[0][0], 1, &src.fX, 1);
249 SkScalar y = SkScalarDot(3, &fMat[1][0], 1, &src.fX, 1);
250 SkScalar z = SkScalarDot(3, &fMat[2][0], 1, &src.fX, 1);
251 dst->set(x, y, z);
252 }
253
254 ///////////////////////////////////////////////////////////////////////////////
255
SkCamera3D()256 SkCamera3D::SkCamera3D() {
257 this->reset();
258 }
259
reset()260 void SkCamera3D::reset() {
261 fLocation.set(0, 0, -SkIntToScalar(576)); // 8 inches backward
262 fAxis.set(0, 0, SK_Scalar1); // forward
263 fZenith.set(0, -SK_Scalar1, 0); // up
264
265 fObserver.set(0, 0, fLocation.fZ);
266
267 fNeedToUpdate = true;
268 }
269
update()270 void SkCamera3D::update() {
271 fNeedToUpdate = true;
272 }
273
doUpdate() const274 void SkCamera3D::doUpdate() const {
275 SkUnit3D axis, zenith, cross;
276
277 fAxis.normalize(&axis);
278
279 {
280 SkScalar dot = SkUnit3D::Dot(*(const SkUnit3D*)(const void*)&fZenith, axis);
281
282 zenith.fX = fZenith.fX - SkUnitScalarMul(dot, axis.fX);
283 zenith.fY = fZenith.fY - SkUnitScalarMul(dot, axis.fY);
284 zenith.fZ = fZenith.fZ - SkUnitScalarMul(dot, axis.fZ);
285
286 (void)((SkPoint3D*)(void*)&zenith)->normalize(&zenith);
287 }
288
289 SkUnit3D::Cross(axis, zenith, &cross);
290
291 {
292 SkMatrix* orien = &fOrientation;
293 SkScalar x = fObserver.fX;
294 SkScalar y = fObserver.fY;
295 SkScalar z = fObserver.fZ;
296
297 orien->set(SkMatrix::kMScaleX, SkUnitScalarMul(x, axis.fX) - SkUnitScalarMul(z, cross.fX));
298 orien->set(SkMatrix::kMSkewX, SkUnitScalarMul(x, axis.fY) - SkUnitScalarMul(z, cross.fY));
299 orien->set(SkMatrix::kMTransX, SkUnitScalarMul(x, axis.fZ) - SkUnitScalarMul(z, cross.fZ));
300 orien->set(SkMatrix::kMSkewY, SkUnitScalarMul(y, axis.fX) - SkUnitScalarMul(z, zenith.fX));
301 orien->set(SkMatrix::kMScaleY, SkUnitScalarMul(y, axis.fY) - SkUnitScalarMul(z, zenith.fY));
302 orien->set(SkMatrix::kMTransY, SkUnitScalarMul(y, axis.fZ) - SkUnitScalarMul(z, zenith.fZ));
303 orien->set(SkMatrix::kMPersp0, axis.fX);
304 orien->set(SkMatrix::kMPersp1, axis.fY);
305 orien->set(SkMatrix::kMPersp2, axis.fZ);
306 }
307 }
308
patchToMatrix(const SkPatch3D & quilt,SkMatrix * matrix) const309 void SkCamera3D::patchToMatrix(const SkPatch3D& quilt, SkMatrix* matrix) const {
310 if (fNeedToUpdate) {
311 this->doUpdate();
312 fNeedToUpdate = false;
313 }
314
315 const SkScalar* mapPtr = (const SkScalar*)(const void*)&fOrientation;
316 const SkScalar* patchPtr;
317 SkPoint3D diff;
318 SkScalar dot;
319
320 diff.fX = quilt.fOrigin.fX - fLocation.fX;
321 diff.fY = quilt.fOrigin.fY - fLocation.fY;
322 diff.fZ = quilt.fOrigin.fZ - fLocation.fZ;
323
324 dot = SkUnit3D::Dot(*(const SkUnit3D*)(const void*)&diff,
325 *(const SkUnit3D*)(((const SkScalar*)(const void*)&fOrientation) + 6));
326
327 patchPtr = (const SkScalar*)&quilt;
328 matrix->set(SkMatrix::kMScaleX, SkScalarDotDiv(3, patchPtr, 1, mapPtr, 1, dot));
329 matrix->set(SkMatrix::kMSkewY, SkScalarDotDiv(3, patchPtr, 1, mapPtr+3, 1, dot));
330 matrix->set(SkMatrix::kMPersp0, SkScalarDotDiv(3, patchPtr, 1, mapPtr+6, 1, dot));
331
332 patchPtr += 3;
333 matrix->set(SkMatrix::kMSkewX, SkScalarDotDiv(3, patchPtr, 1, mapPtr, 1, dot));
334 matrix->set(SkMatrix::kMScaleY, SkScalarDotDiv(3, patchPtr, 1, mapPtr+3, 1, dot));
335 matrix->set(SkMatrix::kMPersp1, SkScalarDotDiv(3, patchPtr, 1, mapPtr+6, 1, dot));
336
337 patchPtr = (const SkScalar*)(const void*)&diff;
338 matrix->set(SkMatrix::kMTransX, SkScalarDotDiv(3, patchPtr, 1, mapPtr, 1, dot));
339 matrix->set(SkMatrix::kMTransY, SkScalarDotDiv(3, patchPtr, 1, mapPtr+3, 1, dot));
340 matrix->set(SkMatrix::kMPersp2, SK_UnitScalar1);
341 }
342
343 ///////////////////////////////////////////////////////////////////////////////
344
Sk3DView()345 Sk3DView::Sk3DView() {
346 fInitialRec.fMatrix.reset();
347 fRec = &fInitialRec;
348 }
349
~Sk3DView()350 Sk3DView::~Sk3DView() {
351 Rec* rec = fRec;
352 while (rec != &fInitialRec) {
353 Rec* next = rec->fNext;
354 SkDELETE(rec);
355 rec = next;
356 }
357 }
358
save()359 void Sk3DView::save() {
360 Rec* rec = SkNEW(Rec);
361 rec->fNext = fRec;
362 rec->fMatrix = fRec->fMatrix;
363 fRec = rec;
364 }
365
restore()366 void Sk3DView::restore() {
367 SkASSERT(fRec != &fInitialRec);
368 Rec* next = fRec->fNext;
369 SkDELETE(fRec);
370 fRec = next;
371 }
372
373 #ifdef ANDROID
setCameraLocation(SkScalar x,SkScalar y,SkScalar z)374 void Sk3DView::setCameraLocation(SkScalar x, SkScalar y, SkScalar z) {
375 // the camera location is passed in inches, set in pt
376 SkScalar lz = z * SkFloatToScalar(72.0f);
377 fCamera.fLocation.set(x * SkFloatToScalar(72.0f), y * SkFloatToScalar(72.0f), lz);
378 fCamera.fObserver.set(0, 0, lz);
379 fCamera.update();
380
381 }
382 #endif
383
translate(SkScalar x,SkScalar y,SkScalar z)384 void Sk3DView::translate(SkScalar x, SkScalar y, SkScalar z) {
385 fRec->fMatrix.preTranslate(x, y, z);
386 }
387
rotateX(SkScalar deg)388 void Sk3DView::rotateX(SkScalar deg) {
389 fRec->fMatrix.preRotateX(deg);
390 }
391
rotateY(SkScalar deg)392 void Sk3DView::rotateY(SkScalar deg) {
393 fRec->fMatrix.preRotateY(deg);
394 }
395
rotateZ(SkScalar deg)396 void Sk3DView::rotateZ(SkScalar deg) {
397 fRec->fMatrix.preRotateZ(deg);
398 }
399
dotWithNormal(SkScalar x,SkScalar y,SkScalar z) const400 SkScalar Sk3DView::dotWithNormal(SkScalar x, SkScalar y, SkScalar z) const {
401 SkPatch3D patch;
402 patch.transform(fRec->fMatrix);
403 return patch.dotWith(x, y, z);
404 }
405
getMatrix(SkMatrix * matrix) const406 void Sk3DView::getMatrix(SkMatrix* matrix) const {
407 if (matrix != NULL) {
408 SkPatch3D patch;
409 patch.transform(fRec->fMatrix);
410 fCamera.patchToMatrix(patch, matrix);
411 }
412 }
413
414 #include "SkCanvas.h"
415
applyToCanvas(SkCanvas * canvas) const416 void Sk3DView::applyToCanvas(SkCanvas* canvas) const {
417 SkMatrix matrix;
418
419 this->getMatrix(&matrix);
420 canvas->concat(matrix);
421 }
422
423