add localmatrix-shader

src/core/SkShader.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcShader.h"
 #include "SkEmptyShader.h"
 #include "SkReadBuffer.h"
@@ skipping 57 matching lines @@
 }
 
 SkShader::Context* SkShader::onCreateContext(const ContextRec& rec, void*) const {
     return NULL;
 }
 
 size_t SkShader::contextSize() const {
     return 0;
 }
 
+SkShader* SkShader::refLocalMatrixShader(SkMatrix*) const {
+    return false;
+}
+
 SkShader::Context::Context(const SkShader& shader, const ContextRec& rec)
     : fShader(shader), fCTM(*rec.fMatrix)
 {
     // Because the context parameters must be valid at this point, we know that the matrix is
     // invertible.
     SkAssertResult(fShader.computeTotalInverse(rec, &fTotalInverse));
     fTotalInverseClass = (uint8_t)ComputeMatrixClass(fTotalInverse);
 
     fPaintAlpha = rec.fPaint->getAlpha();
 }
@@ skipping 249 matching lines @@
 #include "SkEmptyShader.h"
 
 void SkEmptyShader::toString(SkString* str) const {
     str->append("SkEmptyShader: (");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif
+
+//////////////////////////////////////////////////////////////////////////////////
+
+class SkLocalMatrixShader : public SkShader {

[scroggo, 2014/05/07 14:15:41]

Would it make sense to put this in its own file?

[reed1, 2014/05/07 20:37:31]

If it get big enough, yes. When I begin, it was pretty darn tiny, but we'll see.

+public:
+    SkLocalMatrixShader(SkShader* proxy, const SkMatrix& localMatrix)
+        : fProxyShader(SkRef(proxy))
+        , fProxyLocalMatrix(localMatrix)
+    {}
+    
+    virtual size_t contextSize() const SK_OVERRIDE {
+        return fProxyShader->contextSize();
+    }
+
+    virtual SkShader* refLocalMatrixShader(SkMatrix* localMatrix) const SK_OVERRIDE {
+        if (localMatrix) {
+            *localMatrix = fProxyLocalMatrix;
+        }
+        return SkRef(fProxyShader.get());
+    }
+
+    SK_TO_STRING_OVERRIDE()
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixShader)
+    
+protected:
+    SkLocalMatrixShader(SkReadBuffer&);
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
+    virtual Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE;
+    
+private:
+    SkAutoTUnref<SkShader> fProxyShader;
+    SkMatrix  fProxyLocalMatrix;
+    
+    typedef SkShader INHERITED;
+};
+
+SkLocalMatrixShader::SkLocalMatrixShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+    buffer.readMatrix(&fProxyLocalMatrix);
+    fProxyShader.reset(buffer.readFlattenable<SkShader>());
+    if (NULL == fProxyShader.get()) {
+        sk_throw();
+    }
+}
+
+void SkLocalMatrixShader::flatten(SkWriteBuffer& buffer) const {
+    this->INHERITED::flatten(buffer);
+    buffer.writeMatrix(fProxyLocalMatrix);
+    buffer.writeFlattenable(fProxyShader.get());
+}
+
+SkShader::Context* SkLocalMatrixShader::onCreateContext(const ContextRec& rec,

[scroggo, 2014/05/07 14:15:41]

Doesn't this class need to also override asNewEffect (and pass in the local
matrix) so the GPU can handle it as well?

Running your Sample and switching to using the GPU draws nothing where your new
shader is used.

This should also forward on calls to asABitmap and asAGradient (and the new ones
that I'm adding in a separate CL, but I'll add those in that CL) so PDF (and
ultimately, Android, once I convert them to inspecting our shaders) will draw it
correctly.

[reed1, 2014/05/07 20:37:31]

Indeed, I need to forward all of those guys. Maybe its own subclass just for
proxying...

+                                                        void* storage) const {
+    ContextRec newRec(rec);
+    SkMatrix tmp;
+    if (rec.fLocalMatrix) {
+        tmp.setConcat(*rec.fLocalMatrix, fProxyLocalMatrix);

[scroggo, 2014/05/07 14:15:41]

This ordering seems backwards to me. It appears to be reversed from that of
SkShader::computeTotalInverse and SkPictureShader::refBitmapShader, where we
multiply getLocalMatrix * rec.fLocalMatrix.

[reed1, 2014/05/07 20:37:31]

Good catch. Done.

+        newRec.fLocalMatrix = &tmp;
+    } else {
+        newRec.fLocalMatrix = &fProxyLocalMatrix;
+    }
+    return fProxyShader->createContext(newRec, storage);
+}
+
+#ifndef SK_IGNORE_TO_STRING
+void SkLocalMatrixShader::toString(SkString* str) const {
+    str->append("SkLocalMatrixShader: (");
+
+    fProxyShader->toString(str);
+    
+    this->INHERITED::toString(str);
+    
+    str->append(")");
+}
+#endif
+
+SkShader* SkShader::CreateLocalMatrixShader(SkShader* proxy, const SkMatrix& localMatrix) {
+    if (localMatrix.isIdentity()) {
+        return SkRef(proxy);
+    }
+    
+    const SkMatrix* lm = &localMatrix;
+
+    SkMatrix otherLocalMatrix;
+    SkAutoTUnref<SkShader> otherProxy(proxy->refLocalMatrixShader(&otherLocalMatrix));
+    if (otherProxy.get()) {
+        otherLocalMatrix.postConcat(localMatrix);
+        lm = &otherLocalMatrix;
+        proxy = otherProxy.get();
+    }
+
+    return SkNEW_ARGS(SkLocalMatrixShader, (proxy, *lm));
+}
+