Revert "PDF: support perspective in simple shaders. (this version does not work well with tilling)"

src/pdf/SkPDFShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
@@ skipping 192 matching lines @@
                        "cvi "                 // t.s t T
                        "2 mod "               // t.s t (i mod 2)
                        "1 eq "                // t.s t true|false
                        "3 1 roll "            // true|false t.s t
                        "sub "                 // true|false 0.s
                        "exch "                // 0.s true|false
                        "{1 exch sub} if\n");  // 1 - 0.s|0.s
     }
 }
 
-/**
- *  Returns PS function code that would apply perspective to a x, y point.
- *  The function assumes that the stack has at least two elements,
- *  and that the top 2 elements are numeric values.
- *  After ececuting this code on a PS stack, the last 2 elements are updated
- *  while the rest of the stack is preserved intact.
- *  xy2xy is the inverse perspective matrix.
- */
-static SkString apply_perspective_to_coordinates(
-        const SkMatrix& inversePerspectiveMatrix) {
-    SkString code;
-    if (!inversePerspectiveMatrix.hasPerspective()) {
-        return code;
-    }
-
-    // Perspective matrix should be:
-    // 1   0  0
-    // 0   1  0
-    // p0 p1 p2
-
-    SkScalar p0 = inversePerspectiveMatrix[SkMatrix::kMPersp0];
-    SkScalar p1 = inversePerspectiveMatrix[SkMatrix::kMPersp1];
-    SkScalar p2 = inversePerspectiveMatrix[SkMatrix::kMPersp2];
-
-    // y = y / (p2 + p0 x + p1 y)
-    // x = x / (p2 + p0 x + p1 y)
-
-    // Input on stack: x y
-    code.append("dup ");                // x y y
-    code.appendScalar(p1);              // x y y p1
-    code.append(" mul "                 // x y y*p1
-                " 2 index ");           // x y y*p1 x
-    code.appendScalar(p0);              // x y y p1 x p0
-    code.append(" mul ");               // x y y*p1 x*p0
-    code.appendScalar(p2);              // x y y p1 x*p0 p2
-    code.append("add "                  // x y y*p1 x*p0+p2
-                "add "                  // x y y*p1+x*p0+p2
-                "1 index "              // x y y*p1+x*p0+p2 y
-                "1 index "              // x y y*p1+x*p0+p2 y y*p1+x*p0+p2
-                "div "                  // x y y*p1+x*p0+p2 y/(y*p1+x*p0+p2)
-                "4 1 roll "             // y/(y*p1+x*p0+p2) x y y*p1+x*p0+p2
-                "exch "                 // y/(y*p1+x*p0+p2) x y*p1+x*p0+p2 y
-                "pop "                  // y/(y*p1+x*p0+p2) x y*p1+x*p0+p2
-                "div "                  // y/(y*p1+x*p0+p2) x/(y*p1+x*p0+p2)
-                "exch\n");              // x/(y*p1+x*p0+p2) y/(y*p1+x*p0+p2)
-
-    return code;
-}
-
-static SkString linearCode(const SkShader::GradientInfo& info,
-                           const SkMatrix& perspectiveRemover) {
-    SkString function("{");
-
-    function.append(apply_perspective_to_coordinates(perspectiveRemover));
-
-    function.append("pop\n");  // Just ditch the y value.
+static SkString linearCode(const SkShader::GradientInfo& info) {
+    SkString function("{pop\n");  // Just ditch the y value.
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
     function.append("}");
     return function;
 }
 
-static SkString radialCode(const SkShader::GradientInfo& info,
-                           const SkMatrix& perspectiveRemover) {
+static SkString radialCode(const SkShader::GradientInfo& info) {
     SkString function("{");
-
-    function.append(apply_perspective_to_coordinates(perspectiveRemover));
-
     // Find the distance from the origin.
     function.append("dup "      // x y y
                     "mul "      // x y^2
                     "exch "     // y^2 x
                     "dup "      // y^2 x x
                     "mul "      // y^2 x^2
                     "add "      // y^2+x^2
                     "sqrt\n");  // sqrt(y^2+x^2)
 
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
     function.append("}");
     return function;
 }
 
 /* The math here is all based on the description in Two_Point_Radial_Gradient,
    with one simplification, the coordinate space has been scaled so that
    Dr = 1.  This means we don't need to scale the entire equation by 1/Dr^2.
  */
-static SkString twoPointRadialCode(const SkShader::GradientInfo& info,
-                                   const SkMatrix& perspectiveRemover) {
+static SkString twoPointRadialCode(const SkShader::GradientInfo& info) {
     SkScalar dx = info.fPoint[0].fX - info.fPoint[1].fX;
     SkScalar dy = info.fPoint[0].fY - info.fPoint[1].fY;
     SkScalar sr = info.fRadius[0];
     SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - SK_Scalar1;
     bool posRoot = info.fRadius[1] > info.fRadius[0];
 
     // We start with a stack of (x y), copy it and then consume one copy in
     // order to calculate b and the other to calculate c.
     SkString function("{");
-
-    function.append(apply_perspective_to_coordinates(perspectiveRemover));
-
     function.append("2 copy ");
 
     // Calculate -b and b^2.
     function.appendScalar(dy);
     function.append(" mul exch ");
     function.appendScalar(dx);
     function.append(" mul add ");
     function.appendScalar(sr);
     function.append(" sub 2 mul neg dup dup mul\n");
 
@@ skipping 17 matching lines @@
 
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
     function.append("}");
     return function;
 }
 
 /* Conical gradient shader, based on the Canvas spec for radial gradients
    See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient
  */
-static SkString twoPointConicalCode(const SkShader::GradientInfo& info,
-                                    const SkMatrix& perspectiveRemover) {
+static SkString twoPointConicalCode(const SkShader::GradientInfo& info) {
     SkScalar dx = info.fPoint[1].fX - info.fPoint[0].fX;
     SkScalar dy = info.fPoint[1].fY - info.fPoint[0].fY;
     SkScalar r0 = info.fRadius[0];
     SkScalar dr = info.fRadius[1] - info.fRadius[0];
     SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) -
                  SkScalarMul(dr, dr);
 
     // First compute t, if the pixel falls outside the cone, then we'll end
     // with 'false' on the stack, otherwise we'll push 'true' with t below it
 
     // We start with a stack of (x y), copy it and then consume one copy in
     // order to calculate b and the other to calculate c.
     SkString function("{");
-
-    function.append(apply_perspective_to_coordinates(perspectiveRemover));
-
     function.append("2 copy ");
 
     // Calculate b and b^2; b = -2 * (y * dy + x * dx + r0 * dr).
     function.appendScalar(dy);
     function.append(" mul exch ");
     function.appendScalar(dx);
     function.append(" mul add ");
     function.appendScalar(SkScalarMul(r0, dr));
     function.append(" add -2 mul dup dup mul\n");
 
@@ skipping 75 matching lines @@
     function.append("{");
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
 
     // otherwise, just write black
     function.append("} {0 0 0} ifelse }");
 
     return function;
 }
 
-static SkString sweepCode(const SkShader::GradientInfo& info,
-                          const SkMatrix& perspectiveRemover) {
+static SkString sweepCode(const SkShader::GradientInfo& info) {
     SkString function("{exch atan 360 div\n");
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
     function.append("}");
     return function;
 }
 
 class SkPDFShader::State {
 public:
     SkShader::GradientType fType;
@@ skipping 309 matching lines @@
             get_gradient_resource_dict(fColorShader.get(), alphaGs.get()));
 
     SkAutoTUnref<SkStream> colorStream(
             create_pattern_fill_content(0, bbox));
     setData(colorStream.get());
 
     populate_tiling_pattern_dict(this, bbox, fResourceDict.get(),
                                  SkMatrix::I());
 }
 
-// Finds affine and persp such that in = affine * persp.
-// but it returns the inverse of perspective matrix.
-static bool split_perspective(const SkMatrix in, SkMatrix* affine,
-                              SkMatrix* perspectiveInverse) {
-    const SkScalar p2 = in[SkMatrix::kMPersp2];
-
-    if (SkScalarNearlyZero(p2)) {
-        return false;
-    }
-
-    const SkScalar zero = SkIntToScalar(0);
-    const SkScalar one = SkIntToScalar(1);
-
-    const SkScalar sx = in[SkMatrix::kMScaleX];
-    const SkScalar kx = in[SkMatrix::kMSkewX];
-    const SkScalar tx = in[SkMatrix::kMTransX];
-    const SkScalar ky = in[SkMatrix::kMSkewY];
-    const SkScalar sy = in[SkMatrix::kMScaleY];
-    const SkScalar ty = in[SkMatrix::kMTransY];
-    const SkScalar p0 = in[SkMatrix::kMPersp0];
-    const SkScalar p1 = in[SkMatrix::kMPersp1];
-
-    // Perspective matrix would be:
-    // 1  0  0
-    // 0  1  0
-    // p0 p1 p2
-    // But we need the inverse of persp.
-    perspectiveInverse->setAll(one,          zero,       zero,
-                               zero,         one,        zero,
-                               -p0 / p2,     -p1/p2,     1/p2);
-
-    affine->setAll(sx - p0 * tx / p2,       kx - p1 * tx / p2,      tx / p2,
-                   ky - p0 * ty / p2,       sy - p1 * ty / p2,      ty / p2,
-                   zero,                    zero,                   one);
-
-    return true;
-}
-
 SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
         : SkPDFDict("Pattern"),
           fState(state) {
-    SkString (*codeFunction)(const SkShader::GradientInfo& info,
-                             const SkMatrix& perspectiveRemover) = NULL;
+    SkString (*codeFunction)(const SkShader::GradientInfo& info) = NULL;
     SkPoint transformPoints[2];
 
     // Depending on the type of the gradient, we want to transform the
     // coordinate space in different ways.
     const SkShader::GradientInfo* info = &fState.get()->fInfo;
     transformPoints[0] = info->fPoint[0];
     transformPoints[1] = info->fPoint[1];
     switch (fState.get()->fType) {
         case SkShader::kLinear_GradientType:
             codeFunction = &linearCode;
@@ skipping 31 matching lines @@
         default:
             return;
     }
 
     // Move any scaling (assuming a unit gradient) or translation
     // (and rotation for linear gradient), of the final gradient from
     // info->fPoints to the matrix (updating bbox appropriately).  Now
     // the gradient can be drawn on on the unit segment.
     SkMatrix mapperMatrix;
     unitToPointsMatrix(transformPoints, &mapperMatrix);
-
-    SkMatrix perspectiveInverseOnly = SkMatrix::I();
-
     SkMatrix finalMatrix = fState.get()->fCanvasTransform;
     finalMatrix.preConcat(fState.get()->fShaderTransform);
-
-    // Preserves as much as posible in the final matrix, and only removes
-    // the perspective. The inverse of the perspective is stored in
-    // perspectiveInverseOnly matrix and has 3 useful numbers
-    // (p0, p1, p2), while everything else is either 0 or 1.
-    // In this way the shader will handle it eficiently, with minimal code.
-    if (finalMatrix.hasPerspective()) {
-        if (!split_perspective(finalMatrix,
-                               &finalMatrix, &perspectiveInverseOnly)) {
-            return;
-        }
-    }
-
     finalMatrix.preConcat(mapperMatrix);
 
     SkRect bbox;
     bbox.set(fState.get()->fBBox);
     if (!inverseTransformBBox(finalMatrix, &bbox)) {
         return;
     }
 
     SkAutoTUnref<SkPDFArray> domain(new SkPDFArray);
     domain->reserve(4);
@@ skipping 10 matching lines @@
         SkShader::GradientInfo twoPointRadialInfo = *info;
         SkMatrix inverseMapperMatrix;
         if (!mapperMatrix.invert(&inverseMapperMatrix)) {
             return;
         }
         inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
         twoPointRadialInfo.fRadius[0] =
             inverseMapperMatrix.mapRadius(info->fRadius[0]);
         twoPointRadialInfo.fRadius[1] =
             inverseMapperMatrix.mapRadius(info->fRadius[1]);
-        functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
+        functionCode = codeFunction(twoPointRadialInfo);
     } else {
-        functionCode = codeFunction(*info, perspectiveInverseOnly);
+        functionCode = codeFunction(*info);
     }
 
     SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
     pdfShader->insertInt("ShadingType", 1);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
     pdfShader->insert("Domain", domain.get());
 
     SkPDFStream* function = makePSFunction(functionCode, domain.get());
     pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
     fResources.push(function);  // Pass ownership to resource list.
@@ skipping 390 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }