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