Line data    Source code

       1             : /*
       2             :  * Copyright 2016 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             : #ifndef SkLinearBitmapPipeline_matrix_DEFINED
       9             : #define SkLinearBitmapPipeline_matrix_DEFINED
      10             : 
      11             : #include "SkLinearBitmapPipeline_core.h"
      12             : 
      13             : namespace {
      14             : class TranslateMatrixStrategy {
      15             : public:
      16           0 :     TranslateMatrixStrategy(SkVector offset)
      17           0 :         : fXOffset{X(offset)}
      18           0 :         , fYOffset{Y(offset)} { }
      19             : 
      20           0 :     void processPoints(Sk4s* xs, Sk4s* ys) const {
      21           0 :         *xs = *xs + fXOffset;
      22           0 :         *ys = *ys + fYOffset;
      23           0 :     }
      24             : 
      25             :     template <typename Next>
      26           0 :     bool maybeProcessSpan(Span span, Next* next) const {
      27             :         SkPoint start; SkScalar length; int count;
      28           0 :         std::tie(start, length, count) = span;
      29           0 :         next->pointSpan(Span{start + SkPoint{fXOffset, fYOffset}, length, count});
      30           0 :         return true;
      31             :     }
      32             : 
      33             : private:
      34             :     const SkScalar fXOffset, fYOffset;
      35             : };
      36             : 
      37             : class ScaleMatrixStrategy {
      38             : public:
      39           0 :     ScaleMatrixStrategy(SkVector offset, SkVector scale)
      40           0 :         : fXOffset{X(offset)}, fYOffset{Y(offset)}
      41           0 :         ,  fXScale{X(scale)},   fYScale{Y(scale)} { }
      42           0 :     void processPoints(Sk4s* xs, Sk4s* ys) const {
      43           0 :         *xs = *xs * fXScale + fXOffset;
      44           0 :         *ys = *ys * fYScale + fYOffset;
      45           0 :     }
      46             : 
      47             :     template <typename Next>
      48           0 :     bool maybeProcessSpan(Span span, Next* next) const {
      49             :         SkPoint start; SkScalar length; int count;
      50           0 :         std::tie(start, length, count) = span;
      51             :         SkPoint newStart =
      52           0 :             SkPoint{X(start) * fXScale + fXOffset, Y(start) * fYScale + fYOffset};
      53           0 :         SkScalar newLength = length * fXScale;
      54           0 :         next->pointSpan(Span{newStart, newLength, count});
      55           0 :         return true;
      56             :     }
      57             : 
      58             : private:
      59             :     const SkScalar fXOffset, fYOffset;
      60             :     const SkScalar fXScale,  fYScale;
      61             : };
      62             : 
      63             : class AffineMatrixStrategy {
      64             : public:
      65           0 :     AffineMatrixStrategy(SkVector offset, SkVector scale, SkVector skew)
      66           0 :         : fXOffset{X(offset)}, fYOffset{Y(offset)}
      67           0 :         , fXScale{X(scale)},   fYScale{Y(scale)}
      68           0 :         , fXSkew{X(skew)},     fYSkew{Y(skew)} { }
      69           0 :     void processPoints(Sk4s* xs, Sk4s* ys) const {
      70           0 :         Sk4s newXs = fXScale * *xs +  fXSkew * *ys + fXOffset;
      71           0 :         Sk4s newYs =  fYSkew * *xs + fYScale * *ys + fYOffset;
      72             : 
      73           0 :         *xs = newXs;
      74           0 :         *ys = newYs;
      75           0 :     }
      76             : 
      77             :     template <typename Next>
      78           0 :     bool maybeProcessSpan(Span span, Next* next) const {
      79           0 :         return false;
      80             :     }
      81             : 
      82             : private:
      83             :     const SkScalar fXOffset, fYOffset;
      84             :     const SkScalar fXScale,  fYScale;
      85             :     const SkScalar fXSkew,   fYSkew;
      86             : };
      87             : 
      88             : class PerspectiveMatrixStrategy {
      89             : public:
      90           0 :     PerspectiveMatrixStrategy(SkVector offset, SkVector scale, SkVector skew,
      91             :                               SkVector zSkew, SkScalar zOffset)
      92           0 :         : fXOffset{X(offset)}, fYOffset{Y(offset)}, fZOffset{zOffset}
      93           0 :         , fXScale{X(scale)},   fYScale{Y(scale)}
      94           0 :         , fXSkew{X(skew)},     fYSkew{Y(skew)}, fZXSkew{X(zSkew)}, fZYSkew{Y(zSkew)} { }
      95           0 :     void processPoints(Sk4s* xs, Sk4s* ys) const {
      96           0 :         Sk4s newXs = fXScale * *xs +  fXSkew * *ys + fXOffset;
      97           0 :         Sk4s newYs =  fYSkew * *xs + fYScale * *ys + fYOffset;
      98           0 :         Sk4s newZs =  fZXSkew * *xs + fZYSkew * *ys + fZOffset;
      99             : 
     100           0 :         *xs = newXs / newZs;
     101           0 :         *ys = newYs / newZs;
     102           0 :     }
     103             : 
     104             :     template <typename Next>
     105           0 :     bool maybeProcessSpan(Span span, Next* next) const {
     106           0 :         return false;
     107             :     }
     108             : 
     109             : private:
     110             :     const SkScalar fXOffset, fYOffset, fZOffset;
     111             :     const SkScalar fXScale,  fYScale;
     112             :     const SkScalar fXSkew,   fYSkew,   fZXSkew, fZYSkew;
     113             : };
     114             : 
     115             : 
     116             : }  // namespace
     117             : 
     118             : #endif  // SkLinearBitmapPipeline_matrix_DEFINED