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
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
450