OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkFloatBits.h" | 8 #include "SkFloatBits.h" |
9 #include "SkMatrix.h" | 9 #include "SkMatrix.h" |
10 #include "SkNx.h" | 10 #include "SkNx.h" |
(...skipping 1079 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1090 } | 1090 } |
1091 } else { | 1091 } else { |
1092 SkMatrix tmp = *this; | 1092 SkMatrix tmp = *this; |
1093 | 1093 |
1094 tmp.fMat[kMTransX] = tmp.fMat[kMTransY] = 0; | 1094 tmp.fMat[kMTransX] = tmp.fMat[kMTransY] = 0; |
1095 tmp.clearTypeMask(kTranslate_Mask); | 1095 tmp.clearTypeMask(kTranslate_Mask); |
1096 tmp.mapPoints(dst, src, count); | 1096 tmp.mapPoints(dst, src, count); |
1097 } | 1097 } |
1098 } | 1098 } |
1099 | 1099 |
1100 void SkMatrix::mapRectScaleTranslate(SkRect* dst, const SkRect& src) const { | 1100 SkRect SkMatrix::mapRectScaleTranslate(SkRect src) const { |
1101 SkASSERT(dst); | |
1102 SkASSERT(this->isScaleTranslate()); | 1101 SkASSERT(this->isScaleTranslate()); |
1103 | 1102 |
1104 SkScalar sx = fMat[kMScaleX]; | 1103 SkScalar sx = fMat[kMScaleX]; |
1105 SkScalar sy = fMat[kMScaleY]; | 1104 SkScalar sy = fMat[kMScaleY]; |
1106 SkScalar tx = fMat[kMTransX]; | 1105 SkScalar tx = fMat[kMTransX]; |
1107 SkScalar ty = fMat[kMTransY]; | 1106 SkScalar ty = fMat[kMTransY]; |
1108 Sk4f scale(sx, sy, sx, sy); | 1107 Sk4f scale(sx, sy, sx, sy); |
1109 Sk4f trans(tx, ty, tx, ty); | 1108 Sk4f trans(tx, ty, tx, ty); |
1110 | 1109 |
1111 Sk4f ltrb = Sk4f::Load(&src.fLeft) * scale + trans; | 1110 Sk4f ltrb = Sk4f::Load(&src.fLeft) * scale + trans; |
1112 // need to sort so we're not inverted | 1111 // need to sort so we're not inverted |
1113 Sk4f rblt(ltrb[2], ltrb[3], ltrb[0], ltrb[1]); | 1112 Sk4f rblt(ltrb[2], ltrb[3], ltrb[0], ltrb[1]); |
1114 Sk4f min = Sk4f::Min(ltrb, rblt); | 1113 Sk4f min = Sk4f::Min(ltrb, rblt); |
1115 Sk4f max = Sk4f::Max(ltrb, rblt); | 1114 Sk4f max = Sk4f::Max(ltrb, rblt); |
1116 // We can extract either pair [0,1] or [2,3] from min and max and be correct
, but on | 1115 // We can extract either pair [0,1] or [2,3] from min and max and be correct
. |
1117 // ARM this sequence generates the fastest (a single instruction). | 1116 // However, the current ABI for returning multiple floats is to use only 2 s
lots in each |
1118 Sk4f(min[2], min[3], max[0], max[1]).store(&dst->fLeft); | 1117 // vector register. Thus we take [0..1] from min and max, as that perfectly
matches the ABI. |
| 1118 SkRect dst; |
| 1119 Sk4f(min[0], min[1], max[0], max[1]).store(&dst.fLeft); |
| 1120 return dst; |
1119 } | 1121 } |
1120 | 1122 |
1121 bool SkMatrix::mapRect(SkRect* dst, const SkRect& src) const { | 1123 bool SkMatrix::mapRect(SkRect* dst, const SkRect& src) const { |
1122 SkASSERT(dst); | 1124 SkASSERT(dst); |
1123 | 1125 |
1124 if (this->isScaleTranslate()) { | 1126 if (this->isScaleTranslate()) { |
1125 this->mapRectScaleTranslate(dst, src); | 1127 *dst = this->mapRectScaleTranslate(src); |
1126 return true; | 1128 return true; |
1127 } else { | 1129 } else { |
1128 SkPoint quad[4]; | 1130 SkPoint quad[4]; |
1129 | 1131 |
1130 src.toQuad(quad); | 1132 src.toQuad(quad); |
1131 this->mapPoints(quad, quad, 4); | 1133 this->mapPoints(quad, quad, 4); |
1132 dst->set(quad, 4); | 1134 dst->set(quad, 4); |
1133 return false; | 1135 return false; |
1134 } | 1136 } |
1135 } | 1137 } |
(...skipping 750 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1886 const SkScalar m10 = -m01; | 1888 const SkScalar m10 = -m01; |
1887 const SkScalar m11 = m00; | 1889 const SkScalar m11 = m00; |
1888 const SkScalar m12 = fTy; | 1890 const SkScalar m12 = fTy; |
1889 | 1891 |
1890 quad[0].set(m02, m12); | 1892 quad[0].set(m02, m12); |
1891 quad[1].set(m00 * width + m02, m10 * width + m12); | 1893 quad[1].set(m00 * width + m02, m10 * width + m12); |
1892 quad[2].set(m00 * width + m01 * height + m02, m10 * width + m11 * height + m
12); | 1894 quad[2].set(m00 * width + m01 * height + m02, m10 * width + m11 * height + m
12); |
1893 quad[3].set(m01 * height + m02, m11 * height + m12); | 1895 quad[3].set(m01 * height + m02, m11 * height + m12); |
1894 #endif | 1896 #endif |
1895 } | 1897 } |
OLD | NEW |