Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 17 | #include <math.h> |
| 18 | #include <stdlib.h> |
Romain Guy | 3e16833 | 2010-06-22 13:29:14 -0700 | [diff] [blame] | 19 | #include <string.h> |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 20 | |
| 21 | #include <utils/Log.h> |
| 22 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 23 | #include <SkMatrix.h> |
| 24 | |
Romain Guy | 85bf02f | 2010-06-22 13:11:24 -0700 | [diff] [blame] | 25 | #include "Matrix.h" |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 26 | |
| 27 | namespace android { |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 28 | namespace uirenderer { |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 29 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 30 | /////////////////////////////////////////////////////////////////////////////// |
| 31 | // Defines |
| 32 | /////////////////////////////////////////////////////////////////////////////// |
| 33 | |
| 34 | static const float EPSILON = 0.0000001f; |
| 35 | |
| 36 | /////////////////////////////////////////////////////////////////////////////// |
| 37 | // Matrix |
| 38 | /////////////////////////////////////////////////////////////////////////////// |
| 39 | |
Romain Guy | c74f45a | 2013-02-26 19:10:14 -0800 | [diff] [blame] | 40 | const Matrix4& Matrix4::identity() { |
| 41 | static Matrix4 sIdentity; |
| 42 | return sIdentity; |
| 43 | } |
| 44 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 45 | void Matrix4::loadIdentity() { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 46 | data[kScaleX] = 1.0f; |
| 47 | data[kSkewY] = 0.0f; |
| 48 | data[2] = 0.0f; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 49 | data[kPerspective0] = 0.0f; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 50 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 51 | data[kSkewX] = 0.0f; |
| 52 | data[kScaleY] = 1.0f; |
| 53 | data[6] = 0.0f; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 54 | data[kPerspective1] = 0.0f; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 55 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 56 | data[8] = 0.0f; |
| 57 | data[9] = 0.0f; |
| 58 | data[kScaleZ] = 1.0f; |
| 59 | data[11] = 0.0f; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 60 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 61 | data[kTranslateX] = 0.0f; |
| 62 | data[kTranslateY] = 0.0f; |
| 63 | data[kTranslateZ] = 0.0f; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 64 | data[kPerspective2] = 1.0f; |
| 65 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 66 | mType = kTypeIdentity | kTypeRectToRect; |
| 67 | } |
| 68 | |
| 69 | static bool isZero(float f) { |
| 70 | return fabs(f) <= EPSILON; |
| 71 | } |
| 72 | |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 73 | uint8_t Matrix4::getType() const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 74 | if (mType & kTypeUnknown) { |
| 75 | mType = kTypeIdentity; |
| 76 | |
| 77 | if (data[kPerspective0] != 0.0f || data[kPerspective1] != 0.0f || |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 78 | data[kPerspective2] != 1.0f) { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 79 | mType |= kTypePerspective; |
| 80 | } |
| 81 | |
| 82 | if (data[kTranslateX] != 0.0f || data[kTranslateY] != 0.0f) { |
| 83 | mType |= kTypeTranslate; |
| 84 | } |
| 85 | |
| 86 | float m00 = data[kScaleX]; |
| 87 | float m01 = data[kSkewX]; |
| 88 | float m10 = data[kSkewY]; |
| 89 | float m11 = data[kScaleY]; |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 90 | float m32 = data[kTranslateZ]; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 91 | |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 92 | if (m01 != 0.0f || m10 != 0.0f || m32 != 0.0f) { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 93 | mType |= kTypeAffine; |
| 94 | } |
| 95 | |
| 96 | if (m00 != 1.0f || m11 != 1.0f) { |
| 97 | mType |= kTypeScale; |
| 98 | } |
| 99 | |
| 100 | // The following section determines whether the matrix will preserve |
| 101 | // rectangles. For instance, a rectangle transformed by a pure |
| 102 | // translation matrix will result in a rectangle. A rectangle |
| 103 | // transformed by a 45 degrees rotation matrix is not a rectangle. |
| 104 | // If the matrix has a perspective component then we already know |
| 105 | // it doesn't preserve rectangles. |
| 106 | if (!(mType & kTypePerspective)) { |
| 107 | if ((isZero(m00) && isZero(m11) && !isZero(m01) && !isZero(m10)) || |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 108 | (isZero(m01) && isZero(m10) && !isZero(m00) && !isZero(m11))) { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 109 | mType |= kTypeRectToRect; |
| 110 | } |
| 111 | } |
| 112 | } |
| 113 | return mType; |
| 114 | } |
| 115 | |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 116 | uint8_t Matrix4::getGeometryType() const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 117 | return getType() & sGeometryMask; |
| 118 | } |
| 119 | |
| 120 | bool Matrix4::rectToRect() const { |
| 121 | return getType() & kTypeRectToRect; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 122 | } |
| 123 | |
Chris Craik | d965bc5 | 2013-09-16 14:47:13 -0700 | [diff] [blame] | 124 | bool Matrix4::positiveScale() const { |
Chris Craik | 996fe65 | 2013-09-20 17:13:18 -0700 | [diff] [blame] | 125 | return (data[kScaleX] > 0.0f && data[kScaleY] > 0.0f); |
Chris Craik | d965bc5 | 2013-09-16 14:47:13 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 128 | bool Matrix4::changesBounds() const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 129 | return getType() & (kTypeScale | kTypeAffine | kTypePerspective); |
Romain Guy | e8cb9c14 | 2010-10-04 14:14:11 -0700 | [diff] [blame] | 130 | } |
| 131 | |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 132 | bool Matrix4::isPureTranslate() const { |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 133 | // NOTE: temporary hack to workaround ignoreTransform behavior with Z values |
| 134 | // TODO: separate this into isPure2dTranslate vs isPure3dTranslate |
| 135 | return getGeometryType() <= kTypeTranslate && (data[kTranslateZ] == 0.0f); |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 136 | } |
| 137 | |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 138 | bool Matrix4::isSimple() const { |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 139 | return getGeometryType() <= (kTypeScale | kTypeTranslate) && (data[kTranslateZ] == 0.0f); |
Romain Guy | 181d0a6 | 2011-06-09 18:52:38 -0700 | [diff] [blame] | 140 | } |
| 141 | |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 142 | bool Matrix4::isIdentity() const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 143 | return getGeometryType() == kTypeIdentity; |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 144 | } |
| 145 | |
Romain Guy | a3dc55f | 2012-09-28 13:55:44 -0700 | [diff] [blame] | 146 | bool Matrix4::isPerspective() const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 147 | return getType() & kTypePerspective; |
Romain Guy | a3dc55f | 2012-09-28 13:55:44 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 150 | void Matrix4::load(const float* v) { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 151 | memcpy(data, v, sizeof(data)); |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 152 | mType = kTypeUnknown; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 155 | void Matrix4::load(const SkMatrix& v) { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 156 | memset(data, 0, sizeof(data)); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 157 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 158 | data[kScaleX] = v[SkMatrix::kMScaleX]; |
| 159 | data[kSkewX] = v[SkMatrix::kMSkewX]; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 160 | data[kTranslateX] = v[SkMatrix::kMTransX]; |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 161 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 162 | data[kSkewY] = v[SkMatrix::kMSkewY]; |
| 163 | data[kScaleY] = v[SkMatrix::kMScaleY]; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 164 | data[kTranslateY] = v[SkMatrix::kMTransY]; |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 165 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 166 | data[kPerspective0] = v[SkMatrix::kMPersp0]; |
| 167 | data[kPerspective1] = v[SkMatrix::kMPersp1]; |
| 168 | data[kPerspective2] = v[SkMatrix::kMPersp2]; |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 169 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 170 | data[kScaleZ] = 1.0f; |
| 171 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 172 | // NOTE: The flags are compatible between SkMatrix and this class. |
| 173 | // However, SkMatrix::getType() does not return the flag |
| 174 | // kRectStaysRect. The return value is masked with 0xF |
| 175 | // so we need the extra rectStaysRect() check |
| 176 | mType = v.getType(); |
| 177 | if (v.rectStaysRect()) { |
| 178 | mType |= kTypeRectToRect; |
| 179 | } |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | void Matrix4::copyTo(SkMatrix& v) const { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 183 | v.reset(); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 184 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 185 | v.set(SkMatrix::kMScaleX, data[kScaleX]); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 186 | v.set(SkMatrix::kMSkewX, data[kSkewX]); |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 187 | v.set(SkMatrix::kMTransX, data[kTranslateX]); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 188 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 189 | v.set(SkMatrix::kMSkewY, data[kSkewY]); |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 190 | v.set(SkMatrix::kMScaleY, data[kScaleY]); |
| 191 | v.set(SkMatrix::kMTransY, data[kTranslateY]); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 192 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 193 | v.set(SkMatrix::kMPersp0, data[kPerspective0]); |
| 194 | v.set(SkMatrix::kMPersp1, data[kPerspective1]); |
| 195 | v.set(SkMatrix::kMPersp2, data[kPerspective2]); |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 198 | void Matrix4::loadInverse(const Matrix4& v) { |
Romain Guy | e4998e1e | 2015-01-15 11:53:44 -0800 | [diff] [blame] | 199 | // Fast case for common translation matrices |
| 200 | if (v.isPureTranslate()) { |
| 201 | // Reset the matrix |
| 202 | // Unnamed fields are never written to except by |
| 203 | // loadIdentity(), they don't need to be reset |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 204 | data[kScaleX] = 1.0f; |
| 205 | data[kSkewX] = 0.0f; |
Romain Guy | e4998e1e | 2015-01-15 11:53:44 -0800 | [diff] [blame] | 206 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 207 | data[kScaleY] = 1.0f; |
| 208 | data[kSkewY] = 0.0f; |
Romain Guy | e4998e1e | 2015-01-15 11:53:44 -0800 | [diff] [blame] | 209 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 210 | data[kScaleZ] = 1.0f; |
Romain Guy | e4998e1e | 2015-01-15 11:53:44 -0800 | [diff] [blame] | 211 | |
| 212 | data[kPerspective0] = 0.0f; |
| 213 | data[kPerspective1] = 0.0f; |
| 214 | data[kPerspective2] = 1.0f; |
| 215 | |
| 216 | // No need to deal with kTranslateZ because isPureTranslate() |
| 217 | // only returns true when the kTranslateZ component is 0 |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 218 | data[kTranslateX] = -v.data[kTranslateX]; |
| 219 | data[kTranslateY] = -v.data[kTranslateY]; |
| 220 | data[kTranslateZ] = 0.0f; |
Romain Guy | e4998e1e | 2015-01-15 11:53:44 -0800 | [diff] [blame] | 221 | |
| 222 | // A "pure translate" matrix can be identity or translation |
| 223 | mType = v.getType(); |
| 224 | return; |
| 225 | } |
| 226 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 227 | double scale = 1.0 / (v.data[kScaleX] * ((double)v.data[kScaleY] * v.data[kPerspective2] - |
| 228 | (double)v.data[kTranslateY] * v.data[kPerspective1]) + |
| 229 | v.data[kSkewX] * ((double)v.data[kTranslateY] * v.data[kPerspective0] - |
| 230 | (double)v.data[kSkewY] * v.data[kPerspective2]) + |
| 231 | v.data[kTranslateX] * ((double)v.data[kSkewY] * v.data[kPerspective1] - |
| 232 | (double)v.data[kScaleY] * v.data[kPerspective0])); |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 233 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 234 | data[kScaleX] = (v.data[kScaleY] * v.data[kPerspective2] - |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 235 | v.data[kTranslateY] * v.data[kPerspective1]) * |
| 236 | scale; |
| 237 | data[kSkewX] = |
| 238 | (v.data[kTranslateX] * v.data[kPerspective1] - v.data[kSkewX] * v.data[kPerspective2]) * |
| 239 | scale; |
| 240 | data[kTranslateX] = |
| 241 | (v.data[kSkewX] * v.data[kTranslateY] - v.data[kTranslateX] * v.data[kScaleY]) * scale; |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 242 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 243 | data[kSkewY] = |
| 244 | (v.data[kTranslateY] * v.data[kPerspective0] - v.data[kSkewY] * v.data[kPerspective2]) * |
| 245 | scale; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 246 | data[kScaleY] = (v.data[kScaleX] * v.data[kPerspective2] - |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 247 | v.data[kTranslateX] * v.data[kPerspective0]) * |
| 248 | scale; |
| 249 | data[kTranslateY] = |
| 250 | (v.data[kTranslateX] * v.data[kSkewY] - v.data[kScaleX] * v.data[kTranslateY]) * scale; |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 251 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 252 | data[kPerspective0] = |
| 253 | (v.data[kSkewY] * v.data[kPerspective1] - v.data[kScaleY] * v.data[kPerspective0]) * |
| 254 | scale; |
| 255 | data[kPerspective1] = |
| 256 | (v.data[kSkewX] * v.data[kPerspective0] - v.data[kScaleX] * v.data[kPerspective1]) * |
| 257 | scale; |
| 258 | data[kPerspective2] = |
| 259 | (v.data[kScaleX] * v.data[kScaleY] - v.data[kSkewX] * v.data[kSkewY]) * scale; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 260 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 261 | mType = kTypeUnknown; |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 264 | void Matrix4::copyTo(float* v) const { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 265 | memcpy(v, data, sizeof(data)); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 266 | } |
| 267 | |
Romain Guy | 624234f | 2013-03-05 16:43:31 -0800 | [diff] [blame] | 268 | float Matrix4::getTranslateX() const { |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 269 | return data[kTranslateX]; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 270 | } |
| 271 | |
Romain Guy | 624234f | 2013-03-05 16:43:31 -0800 | [diff] [blame] | 272 | float Matrix4::getTranslateY() const { |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 273 | return data[kTranslateY]; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 274 | } |
| 275 | |
Romain Guy | ddb80be | 2010-09-20 19:04:33 -0700 | [diff] [blame] | 276 | void Matrix4::multiply(float v) { |
| 277 | for (int i = 0; i < 16; i++) { |
| 278 | data[i] *= v; |
| 279 | } |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 280 | mType = kTypeUnknown; |
Romain Guy | ddb80be | 2010-09-20 19:04:33 -0700 | [diff] [blame] | 281 | } |
| 282 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 283 | void Matrix4::loadTranslate(float x, float y, float z) { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 284 | loadIdentity(); |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 285 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 286 | data[kTranslateX] = x; |
| 287 | data[kTranslateY] = y; |
| 288 | data[kTranslateZ] = z; |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 289 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 290 | mType = kTypeTranslate | kTypeRectToRect; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | void Matrix4::loadScale(float sx, float sy, float sz) { |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 294 | loadIdentity(); |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 295 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 296 | data[kScaleX] = sx; |
| 297 | data[kScaleY] = sy; |
| 298 | data[kScaleZ] = sz; |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 299 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 300 | mType = kTypeScale | kTypeRectToRect; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 301 | } |
| 302 | |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 303 | void Matrix4::loadSkew(float sx, float sy) { |
| 304 | loadIdentity(); |
| 305 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 306 | data[kScaleX] = 1.0f; |
| 307 | data[kSkewX] = sx; |
| 308 | data[kTranslateX] = 0.0f; |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 309 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 310 | data[kSkewY] = sy; |
| 311 | data[kScaleY] = 1.0f; |
| 312 | data[kTranslateY] = 0.0f; |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 313 | |
| 314 | data[kPerspective0] = 0.0f; |
| 315 | data[kPerspective1] = 0.0f; |
| 316 | data[kPerspective2] = 1.0f; |
| 317 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 318 | mType = kTypeUnknown; |
| 319 | } |
| 320 | |
| 321 | void Matrix4::loadRotate(float angle) { |
| 322 | angle *= float(M_PI / 180.0f); |
| 323 | float c = cosf(angle); |
| 324 | float s = sinf(angle); |
| 325 | |
| 326 | loadIdentity(); |
| 327 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 328 | data[kScaleX] = c; |
| 329 | data[kSkewX] = -s; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 330 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 331 | data[kSkewY] = s; |
| 332 | data[kScaleY] = c; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 333 | |
| 334 | mType = kTypeUnknown; |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 335 | } |
| 336 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 337 | void Matrix4::loadRotate(float angle, float x, float y, float z) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 338 | data[kPerspective0] = 0.0f; |
| 339 | data[kPerspective1] = 0.0f; |
| 340 | data[11] = 0.0f; |
| 341 | data[kTranslateX] = 0.0f; |
| 342 | data[kTranslateY] = 0.0f; |
| 343 | data[kTranslateZ] = 0.0f; |
| 344 | data[kPerspective2] = 1.0f; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 345 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 346 | angle *= float(M_PI / 180.0f); |
| 347 | float c = cosf(angle); |
| 348 | float s = sinf(angle); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 349 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 350 | const float length = sqrtf(x * x + y * y + z * z); |
Romain Guy | 889f8d1 | 2010-07-29 14:37:42 -0700 | [diff] [blame] | 351 | float recipLen = 1.0f / length; |
| 352 | x *= recipLen; |
| 353 | y *= recipLen; |
| 354 | z *= recipLen; |
| 355 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 356 | const float nc = 1.0f - c; |
| 357 | const float xy = x * y; |
| 358 | const float yz = y * z; |
| 359 | const float zx = z * x; |
| 360 | const float xs = x * s; |
| 361 | const float ys = y * s; |
| 362 | const float zs = z * s; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 363 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 364 | data[kScaleX] = x * x * nc + c; |
| 365 | data[kSkewX] = xy * nc - zs; |
| 366 | data[8] = zx * nc + ys; |
| 367 | data[kSkewY] = xy * nc + zs; |
| 368 | data[kScaleY] = y * y * nc + c; |
| 369 | data[9] = yz * nc - xs; |
| 370 | data[2] = zx * nc - ys; |
| 371 | data[6] = yz * nc + xs; |
| 372 | data[kScaleZ] = z * z * nc + c; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 373 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 374 | mType = kTypeUnknown; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 378 | for (int i = 0; i < 4; i++) { |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 379 | float x = 0; |
| 380 | float y = 0; |
| 381 | float z = 0; |
| 382 | float w = 0; |
| 383 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 384 | for (int j = 0; j < 4; j++) { |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 385 | const float e = v.get(i, j); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 386 | x += u.get(j, 0) * e; |
| 387 | y += u.get(j, 1) * e; |
| 388 | z += u.get(j, 2) * e; |
| 389 | w += u.get(j, 3) * e; |
| 390 | } |
| 391 | |
| 392 | set(i, 0, x); |
| 393 | set(i, 1, y); |
| 394 | set(i, 2, z); |
| 395 | set(i, 3, w); |
| 396 | } |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 397 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 398 | mType = kTypeUnknown; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 399 | } |
| 400 | |
| 401 | void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) { |
| 402 | loadIdentity(); |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 403 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 404 | data[kScaleX] = 2.0f / (right - left); |
| 405 | data[kScaleY] = 2.0f / (top - bottom); |
| 406 | data[kScaleZ] = -2.0f / (far - near); |
| 407 | data[kTranslateX] = -(right + left) / (right - left); |
| 408 | data[kTranslateY] = -(top + bottom) / (top - bottom); |
| 409 | data[kTranslateZ] = -(far + near) / (far - near); |
Romain Guy | 302a9df | 2011-08-16 13:55:02 -0700 | [diff] [blame] | 410 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 411 | mType = kTypeTranslate | kTypeScale | kTypeRectToRect; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 412 | } |
| 413 | |
Chris Craik | b79a3e3 | 2014-03-11 12:20:17 -0700 | [diff] [blame] | 414 | float Matrix4::mapZ(const Vector3& orig) const { |
| 415 | // duplicates logic for mapPoint3d's z coordinate |
| 416 | return orig.x * data[2] + orig.y * data[6] + orig.z * data[kScaleZ] + data[kTranslateZ]; |
| 417 | } |
| 418 | |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 419 | void Matrix4::mapPoint3d(Vector3& vec) const { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 420 | // TODO: optimize simple case |
Chris Craik | b79a3e3 | 2014-03-11 12:20:17 -0700 | [diff] [blame] | 421 | const Vector3 orig(vec); |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 422 | vec.x = orig.x * data[kScaleX] + orig.y * data[kSkewX] + orig.z * data[8] + data[kTranslateX]; |
| 423 | vec.y = orig.x * data[kSkewY] + orig.y * data[kScaleY] + orig.z * data[9] + data[kTranslateY]; |
| 424 | vec.z = orig.x * data[2] + orig.y * data[6] + orig.z * data[kScaleZ] + data[kTranslateZ]; |
| 425 | } |
| 426 | |
Chih-Hung Hsieh | cef190d | 2016-05-19 15:25:50 -0700 | [diff] [blame] | 427 | #define MUL_ADD_STORE(a, b, c) ((a) = (a) * (b) + (c)) |
Romain Guy | 0ba681b | 2010-08-12 15:37:00 -0700 | [diff] [blame] | 428 | |
| 429 | void Matrix4::mapPoint(float& x, float& y) const { |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 430 | if (isSimple()) { |
Romain Guy | 0ba681b | 2010-08-12 15:37:00 -0700 | [diff] [blame] | 431 | MUL_ADD_STORE(x, data[kScaleX], data[kTranslateX]); |
| 432 | MUL_ADD_STORE(y, data[kScaleY], data[kTranslateY]); |
| 433 | return; |
| 434 | } |
| 435 | |
| 436 | float dx = x * data[kScaleX] + y * data[kSkewX] + data[kTranslateX]; |
| 437 | float dy = x * data[kSkewY] + y * data[kScaleY] + data[kTranslateY]; |
| 438 | float dz = x * data[kPerspective0] + y * data[kPerspective1] + data[kPerspective2]; |
| 439 | if (dz) dz = 1.0f / dz; |
| 440 | |
| 441 | x = dx * dz; |
| 442 | y = dy * dz; |
| 443 | } |
| 444 | |
Chris Craik | 034a10b | 2016-03-09 16:03:21 -0800 | [diff] [blame] | 445 | /** |
| 446 | * Set the contents of the rect to be the bounding rect around each of the corners, mapped by the |
| 447 | * matrix. |
| 448 | * |
| 449 | * NOTE: an empty rect to an arbitrary matrix isn't guaranteed to have an empty output, since that's |
| 450 | * important for conservative bounds estimation (e.g. rotate45Matrix.mapRect of Rect(0, 10) should |
| 451 | * result in non-empty. |
| 452 | */ |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 453 | void Matrix4::mapRect(Rect& r) const { |
Chris Craik | 034a10b | 2016-03-09 16:03:21 -0800 | [diff] [blame] | 454 | if (isIdentity()) return; |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 455 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 456 | if (isSimple()) { |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 457 | MUL_ADD_STORE(r.left, data[kScaleX], data[kTranslateX]); |
| 458 | MUL_ADD_STORE(r.right, data[kScaleX], data[kTranslateX]); |
| 459 | MUL_ADD_STORE(r.top, data[kScaleY], data[kTranslateY]); |
| 460 | MUL_ADD_STORE(r.bottom, data[kScaleY], data[kTranslateY]); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 461 | |
| 462 | if (r.left > r.right) { |
| 463 | float x = r.left; |
| 464 | r.left = r.right; |
| 465 | r.right = x; |
| 466 | } |
| 467 | |
| 468 | if (r.top > r.bottom) { |
| 469 | float y = r.top; |
| 470 | r.top = r.bottom; |
| 471 | r.bottom = y; |
| 472 | } |
| 473 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 474 | return; |
| 475 | } |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 476 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 477 | float vertices[] = {r.left, r.top, r.right, r.top, r.right, r.bottom, r.left, r.bottom}; |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 478 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 479 | float x, y, z; |
| 480 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 481 | for (int i = 0; i < 8; i += 2) { |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 482 | float px = vertices[i]; |
| 483 | float py = vertices[i + 1]; |
| 484 | |
| 485 | x = px * data[kScaleX] + py * data[kSkewX] + data[kTranslateX]; |
| 486 | y = px * data[kSkewY] + py * data[kScaleY] + data[kTranslateY]; |
| 487 | z = px * data[kPerspective0] + py * data[kPerspective1] + data[kPerspective2]; |
| 488 | if (z) z = 1.0f / z; |
| 489 | |
| 490 | vertices[i] = x * z; |
| 491 | vertices[i + 1] = y * z; |
| 492 | } |
| 493 | |
| 494 | r.left = r.right = vertices[0]; |
| 495 | r.top = r.bottom = vertices[1]; |
| 496 | |
| 497 | for (int i = 2; i < 8; i += 2) { |
| 498 | x = vertices[i]; |
| 499 | y = vertices[i + 1]; |
| 500 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 501 | if (x < r.left) |
| 502 | r.left = x; |
| 503 | else if (x > r.right) |
| 504 | r.right = x; |
| 505 | if (y < r.top) |
| 506 | r.top = y; |
| 507 | else if (y > r.bottom) |
| 508 | r.bottom = y; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 509 | } |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 510 | } |
| 511 | |
Romain Guy | 3b75382 | 2013-03-05 10:27:35 -0800 | [diff] [blame] | 512 | void Matrix4::decomposeScale(float& sx, float& sy) const { |
| 513 | float len; |
| 514 | len = data[mat4::kScaleX] * data[mat4::kScaleX] + data[mat4::kSkewX] * data[mat4::kSkewX]; |
| 515 | sx = copysignf(sqrtf(len), data[mat4::kScaleX]); |
| 516 | len = data[mat4::kScaleY] * data[mat4::kScaleY] + data[mat4::kSkewY] * data[mat4::kSkewY]; |
| 517 | sy = copysignf(sqrtf(len), data[mat4::kScaleY]); |
| 518 | } |
| 519 | |
Chris Craik | e4aa95e | 2014-05-08 13:57:05 -0700 | [diff] [blame] | 520 | void Matrix4::dump(const char* label) const { |
| 521 | ALOGD("%s[simple=%d, type=0x%x", label ? label : "Matrix4", isSimple(), getType()); |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 522 | ALOGD(" %f %f %f %f", data[kScaleX], data[kSkewX], data[8], data[kTranslateX]); |
| 523 | ALOGD(" %f %f %f %f", data[kSkewY], data[kScaleY], data[9], data[kTranslateY]); |
| 524 | ALOGD(" %f %f %f %f", data[2], data[6], data[kScaleZ], data[kTranslateZ]); |
| 525 | ALOGD(" %f %f %f %f", data[kPerspective0], data[kPerspective1], data[11], data[kPerspective2]); |
| 526 | ALOGD("]"); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 527 | } |
| 528 | |
Chris Blume | 7b8a808 | 2018-11-30 15:51:58 -0800 | [diff] [blame] | 529 | } // namespace uirenderer |
| 530 | } // namespace android |