1 | /* |
2 | * Copyright 2020 Google Inc. |
3 | * |
4 | * Use of this source code is governed by a BSD-style license that can be |
5 | * found in the LICENSE file. |
6 | */ |
7 | |
8 | #include "modules/skottie/src/Camera.h" |
9 | |
10 | #include "modules/skottie/src/SkottieJson.h" |
11 | #include "modules/skottie/src/SkottiePriv.h" |
12 | #include "modules/sksg/include/SkSGTransform.h" |
13 | |
14 | namespace skottie { |
15 | namespace internal { |
16 | |
17 | namespace { |
18 | |
19 | SkM44 ComputeCameraMatrix(const SkV3& position, |
20 | const SkV3& poi, |
21 | const SkV3& rotation, |
22 | const SkSize& viewport_size, |
23 | float zoom) { |
24 | |
25 | // Initial camera vector. |
26 | const auto cam_t = SkM44::Rotate({0, 0, 1}, SkDegreesToRadians(-rotation.z)) |
27 | * SkM44::Rotate({0, 1, 0}, SkDegreesToRadians( rotation.y)) |
28 | * SkM44::Rotate({1, 0, 0}, SkDegreesToRadians( rotation.x)) |
29 | * Sk3LookAt({ position.x, position.y, -position.z }, |
30 | { poi.x, poi.y, poi.z }, |
31 | { 0, 1, 0 }) |
32 | * SkM44::Scale(1, 1, -1); |
33 | |
34 | // View parameters: |
35 | // |
36 | // * size -> composition size (TODO: AE seems to base it on width only?) |
37 | // * distance -> "zoom" camera attribute |
38 | // |
39 | const auto view_size = std::max(viewport_size.width(), viewport_size.height()), |
40 | view_distance = zoom, |
41 | view_angle = std::atan(sk_ieee_float_divide(view_size * 0.5f, view_distance)); |
42 | |
43 | const auto persp_t = SkM44::Scale(view_size * 0.5f, view_size * 0.5f, 1) |
44 | * Sk3Perspective(0, view_distance, 2 * view_angle); |
45 | |
46 | return SkM44::Translate(viewport_size.width() * 0.5f, |
47 | viewport_size.height() * 0.5f, |
48 | 0) |
49 | * persp_t * cam_t; |
50 | } |
51 | |
52 | } // namespace |
53 | |
54 | CameraAdaper::CameraAdaper(const skjson::ObjectValue& jlayer, |
55 | const skjson::ObjectValue& jtransform, |
56 | const AnimationBuilder& abuilder, |
57 | const SkSize& viewport_size) |
58 | : INHERITED(jtransform, abuilder) |
59 | , fViewportSize(viewport_size) |
60 | // The presence of an anchor point property ('a') differentiates |
61 | // one-node vs. two-node cameras. |
62 | , fType(jtransform["a" ].is<skjson::NullValue>() ? CameraType::kOneNode |
63 | : CameraType::kTwoNode) { |
64 | // 'pe' (perspective?) corresponds to AE's "zoom" camera property. |
65 | this->bind(abuilder, jlayer["pe" ], fZoom); |
66 | } |
67 | |
68 | CameraAdaper::~CameraAdaper() = default; |
69 | |
70 | SkM44 CameraAdaper::totalMatrix() const { |
71 | // Camera parameters: |
72 | // |
73 | // * location -> position attribute |
74 | // * point of interest -> anchor point attribute (two-node camera only) |
75 | // * orientation -> rotation attribute |
76 | // |
77 | const auto position = this->position(); |
78 | |
79 | return ComputeCameraMatrix(position, |
80 | this->poi(position), |
81 | this->rotation(), |
82 | fViewportSize, |
83 | fZoom); |
84 | } |
85 | |
86 | SkV3 CameraAdaper::poi(const SkV3& pos) const { |
87 | // AE supports two camera types: |
88 | // |
89 | // - one-node camera: does not auto-orient, and starts off perpendicular |
90 | // to the z = 0 plane, facing "forward" (decreasing z). |
91 | // |
92 | // - two-node camera: has a point of interest (encoded as the anchor point), |
93 | // and auto-orients to point in its direction. |
94 | |
95 | if (fType == CameraType::kOneNode) { |
96 | return { pos.x, pos.y, -pos.z - 1}; |
97 | } |
98 | |
99 | const auto ap = this->anchor_point(); |
100 | |
101 | return { ap.x, ap.y, -ap.z }; |
102 | } |
103 | |
104 | sk_sp<sksg::Transform> CameraAdaper::DefaultCameraTransform(const SkSize& viewport_size) { |
105 | const auto center = SkVector::Make(viewport_size.width() * 0.5f, |
106 | viewport_size.height() * 0.5f); |
107 | |
108 | static constexpr float kDefaultAEZoom = 879.13f; |
109 | |
110 | const SkV3 pos = { center.fX, center.fY, -kDefaultAEZoom }, |
111 | poi = { pos.x, pos.y, -pos.z - 1 }, |
112 | rot = { 0, 0, 0 }; |
113 | |
114 | return sksg::Matrix<SkM44>::Make( |
115 | ComputeCameraMatrix(pos, poi, rot, viewport_size, kDefaultAEZoom)); |
116 | } |
117 | |
118 | sk_sp<sksg::Transform> AnimationBuilder::attachCamera(const skjson::ObjectValue& jlayer, |
119 | const skjson::ObjectValue& jtransform, |
120 | sk_sp<sksg::Transform> parent, |
121 | const SkSize& viewport_size) const { |
122 | auto adapter = sk_make_sp<CameraAdaper>(jlayer, jtransform, *this, viewport_size); |
123 | |
124 | if (adapter->isStatic()) { |
125 | adapter->seek(0); |
126 | } else { |
127 | fCurrentAnimatorScope->push_back(adapter); |
128 | } |
129 | |
130 | return sksg::Transform::MakeConcat(adapter->node(), std::move(parent)); |
131 | } |
132 | |
133 | } // namespace internal |
134 | } // namespace skottie |
135 | |