xref: /third_party/skia/src/core/SkMatrix.cpp

547 bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit align) {
553     if (dst.isEmpty()) {
558         SkScalar    tx, sx = dst.width() / src.width();
559         SkScalar    ty, sy = dst.height() / src.height();
571         tx = dst.fLeft - src.fLeft * sx;
572         ty = dst.fTop - src.fTop * sy;
577                 diff = dst.width() - src.width() * sy;
579                 diff = dst.height() - src.height() * sy;
779 void SkMatrix::mapPoints(SkPoint dst[], const SkPoint src[], int count) const {
780     SkASSERT((dst && src && count > 0) || 0 == count);
782     SkASSERT(src == dst || &dst[count] <= &src[0] || &src[count] <= &dst[0]);
783     this->getMapPtsProc()(*this, dst, src, count);
791 void SkMatrix::ComputeInv(SkScalar dst[9], const SkScalar src[9], double invDet, bool isPersp) {
792     SkASSERT(src != dst);
793     SkASSERT(src && dst);
796         dst[kMScaleX] = scross_dscale(src[kMScaleY], src[kMPersp2], src[kMTransY], src[kMPersp1], invDet);
797         dst[kMSkewX]  = scross_dscale(src[kMTransX], src[kMPersp1], src[kMSkewX],  src[kMPersp2], invDet);
798         dst[kMTransX] = scross_dscale(src[kMSkewX],  src[kMTransY], src[kMTransX], src[kMScaleY], invDet);
800         dst[kMSkewY]  = scross_dscale(src[kMTransY], src[kMPersp0], src[kMSkewY],  src[kMPersp2], invDet);
801         dst[kMScaleY] = scross_dscale(src[kMScaleX], src[kMPersp2], src[kMTransX], src[kMPersp0], invDet);
802         dst[kMTransY] = scross_dscale(src[kMTransX], src[kMSkewY],  src[kMScaleX], src[kMTransY], invDet);
804         dst[kMPersp0] = scross_dscale(src[kMSkewY],  src[kMPersp1], src[kMScaleY], src[kMPersp0], invDet);
805         dst[kMPersp1] = scross_dscale(src[kMSkewX],  src[kMPersp0], src[kMScaleX], src[kMPersp1], invDet);
806         dst[kMPersp2] = scross_dscale(src[kMScaleX], src[kMScaleY], src[kMSkewX],  src[kMSkewY],  invDet);
808         dst[kMScaleX] = SkDoubleToScalar(src[kMScaleY] * invDet);
809         dst[kMSkewX]  = SkDoubleToScalar(-src[kMSkewX] * invDet);
810         dst[kMTransX] = dcross_dscale(src[kMSkewX], src[kMTransY], src[kMScaleY], src[kMTransX], invDet);
812         dst[kMSkewY]  = SkDoubleToScalar(-src[kMSkewY] * invDet);
813         dst[kMScaleY] = SkDoubleToScalar(src[kMScaleX] * invDet);
814         dst[kMTransY] = dcross_dscale(src[kMSkewY], src[kMTransX], src[kMScaleX], src[kMTransY], invDet);
816         dst[kMPersp0] = 0;
817         dst[kMPersp1] = 0;
818         dst[kMPersp2] = 1;
896 void SkMatrix::Identity_pts(const SkMatrix& m, SkPoint dst[], const SkPoint src[], int count) {
899     if (dst != src && count > 0) {
900         memcpy(dst, src, count * sizeof(SkPoint));
904 void SkMatrix::Trans_pts(const SkMatrix& m, SkPoint dst[], const SkPoint src[], int count) {
910             dst->fX = src->fX + tx;
911             dst->fY = src->fY + ty;
913             dst += 1;
918             (Sk4s::Load(src) + trans4).store(dst);
920             dst += 2;
924             (Sk4s::Load(src+0) + trans4).store(dst+0);
925             (Sk4s::Load(src+2) + trans4).store(dst+2);
927             dst += 4;
932 void SkMatrix::Scale_pts(const SkMatrix& m, SkPoint dst[], const SkPoint src[], int count) {
940             dst->fX = src->fX * sx + tx;
941             dst->fY = src->fY * sy + ty;
943             dst += 1;
949             (Sk4s::Load(src) * scale4 + trans4).store(dst);
951             dst += 2;
955             (Sk4s::Load(src+0) * scale4 + trans4).store(dst+0);
956             (Sk4s::Load(src+2) * scale4 + trans4).store(dst+2);
958             dst += 4;
963 void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
984             dst->fY = y * z;
985             dst->fX = x * z;
986             dst += 1;
991 void SkMatrix::Affine_vpts(const SkMatrix& m, SkPoint dst[], const SkPoint src[], int count) {
1001             dst->set(src->fX * sx + src->fY * kx + tx,
1004             dst += 1;
1013             (src4 * scale4 + swz4 * skew4 + trans4).store(dst);
1015             dst += 2;
1034 void SkMatrixPriv::MapHomogeneousPointsWithStride(const SkMatrix& mx, SkPoint3 dst[],
1037     SkASSERT((dst && src && count > 0) || 0 == count);
1039     SkASSERT(src == dst || &dst[count] <= &src[0] || &src[count] <= &dst[0]);
1043             if (src != dst) {
1045                     memcpy(dst, src, count * sizeof(SkPoint3));
1048                         *dst = *src;
1049                         dst = reinterpret_cast<SkPoint3*>(reinterpret_cast<char*>(dst) + dstStride);
1068             dst->set(x, y, w);
1069             dst = reinterpret_cast<SkPoint3*>(reinterpret_cast<char*>(dst) + dstStride);
1074 void SkMatrix::mapHomogeneousPoints(SkPoint3 dst[], const SkPoint3 src[], int count) const {
1075     SkMatrixPriv::MapHomogeneousPointsWithStride(*this, dst, sizeof(SkPoint3), src,
1079 void SkMatrix::mapHomogeneousPoints(SkPoint3 dst[], const SkPoint src[], int count) const {
1082             dst[i] = { src[i].fX, src[i].fY, 1 };
1086             dst[i] = {
1094             dst[i] = {
1105 void SkMatrix::mapVectors(SkPoint dst[], const SkPoint src[], int count) const {
1116             dst[i].set(tmp.fX - origin.fX, tmp.fY - origin.fY);
1123         tmp.mapPoints(dst, src, count);
1136 void SkMatrix::mapRectScaleTranslate(SkRect* dst, const SkRect& src) const {
1137     SkASSERT(dst);
1146     sort_as_rect(Sk4f::Load(&src.fLeft) * scale + trans).store(&dst->fLeft);
1149 bool SkMatrix::mapRect(SkRect* dst, const SkRect& src, SkApplyPerspectiveClip pc) const {
1150     SkASSERT(dst);
1156         sort_as_rect(Sk4f::Load(&src.fLeft) + trans).store(&dst->fLeft);
1160         this->mapRectScaleTranslate(dst, src);
1166         *dst = path.getBounds();
1173         dst->setBoundsNoCheck(quad, 4);
1311 bool SkMatrix::Poly2Proc(const SkPoint srcPt[], SkMatrix* dst) {
1312     dst->fMat[kMScaleX] = srcPt[1].fY - srcPt[0].fY;
1313     dst->fMat[kMSkewY]  = srcPt[0].fX - srcPt[1].fX;
1314     dst->fMat[kMPersp0] = 0;
1316     dst->fMat[kMSkewX]  = srcPt[1].fX - srcPt[0].fX;
1317     dst->fMat[kMScaleY] = srcPt[1].fY - srcPt[0].fY;
1318     dst->fMat[kMPersp1] = 0;
1320     dst->fMat[kMTransX] = srcPt[0].fX;
1321     dst->fMat[kMTransY] = srcPt[0].fY;
1322     dst->fMat[kMPersp2] = 1;
1323     dst->setTypeMask(kUnknown_Mask);
1327 bool SkMatrix::Poly3Proc(const SkPoint srcPt[], SkMatrix* dst) {
1328     dst->fMat[kMScaleX] = srcPt[2].fX - srcPt[0].fX;
1329     dst->fMat[kMSkewY]  = srcPt[2].fY - srcPt[0].fY;
1330     dst->fMat[kMPersp0] = 0;
1332     dst->fMat[kMSkewX]  = srcPt[1].fX - srcPt[0].fX;
1333     dst->fMat[kMScaleY] = srcPt[1].fY - srcPt[0].fY;
1334     dst->fMat[kMPersp1] = 0;
1336     dst->fMat[kMTransX] = srcPt[0].fX;
1337     dst->fMat[kMTransY] = srcPt[0].fY;
1338     dst->fMat[kMPersp2] = 1;
1339     dst->setTypeMask(kUnknown_Mask);
1343 bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst) {
1384     dst->fMat[kMScaleX] = a2 * srcPt[3].fX + srcPt[3].fX - srcPt[0].fX;
1385     dst->fMat[kMSkewY]  = a2 * srcPt[3].fY + srcPt[3].fY - srcPt[0].fY;
1386     dst->fMat[kMPersp0] = a2;
1388     dst->fMat[kMSkewX]  = a1 * srcPt[1].fX + srcPt[1].fX - srcPt[0].fX;
1389     dst->fMat[kMScaleY] = a1 * srcPt[1].fY + srcPt[1].fY - srcPt[0].fY;
1390     dst->fMat[kMPersp1] = a1;
1392     dst->fMat[kMTransX] = srcPt[0].fX;
1393     dst->fMat[kMTransY] = srcPt[0].fY;
1394     dst->fMat[kMPersp2] = 1;
1395     dst->setTypeMask(kUnknown_Mask);
1403 bool SkMatrix::setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count) {
1414         this->setTranslate(dst[0].fX - src[0].fX, dst[0].fY - src[0].fY);
1431     if (!proc(dst, &tempMap)) {
1675     SkRect dst;
1681         mat.mapRect(&dst, src);
1695         dst.fLeft *= scale;
1696         dst.fTop *= scale;
1697         dst.fRight *= scale;
1698         dst.fBottom *= scale;
1702     dst.round(&idst);

Indexes created Thu Nov 07 10:32:03 CST 2024