Refugee from Dead Machine 11: Add SkCanvas::drawLitAtlas call

src/pipe/SkGPipeWrite.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 "SkAnnotation.h"
 #include "SkBitmapHeap.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkData.h"
 #include "SkDrawLooper.h"
 #include "SkGPipe.h"
 #include "SkGPipePriv.h"
 #include "SkImageFilter.h"
+#include "SkLight.h"
 #include "SkMaskFilter.h"
 #include "SkRSXform.h"
 #include "SkWriteBuffer.h"
 #include "SkPaint.h"
 #include "SkPatchUtils.h"
 #include "SkPathEffect.h"
 #include "SkPictureFlat.h"
 #include "SkPtrRecorder.h"
 #include "SkRasterizer.h"
 #include "SkRRect.h"
@@ skipping 257 matching lines @@
     void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
                           const SkPaint*) override;
     void onDrawSprite(const SkBitmap&, int left, int top, const SkPaint*) override;
     void onDrawVertices(VertexMode vmode, int vertexCount,
                         const SkPoint vertices[], const SkPoint texs[],
                         const SkColor colors[], SkXfermode* xmode,
                         const uint16_t indices[], int indexCount,
                         const SkPaint&) override;
     void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
                      int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) override;
+    void onDrawLitAtlas(const SkImage*, const SkRSXform[],
+                        const SkRect diffTex[], const SkRect normTex[], const SkColor[],
+                        int count, SkXfermode::Mode, const SkRect* cull,
+                        const SkPaint*, const SkLight lights[], int numLights) override;
     void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
     void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
     void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
     void onClipRegion(const SkRegion&, SkRegion::Op) override;
 
     void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
 
 private:
     void recordTranslate(const SkMatrix&);
     void recordScale(const SkMatrix&);
@@ skipping 842 matching lines @@
         fWriter.write(tex, count * sizeof(SkRect));
         if (colors) {
             fWriter.write(colors, count * sizeof(SkColor));
         }
         if (cull) {
             fWriter.writeRect(*cull);
         }
     }
 }
 
+
+void SkGPipeCanvas::onDrawLitAtlas(const SkImage* atlas, const SkRSXform xform[],
+                                   const SkRect diffTex[], const SkRect normTex[],
+                                   const SkColor colors[], int count,
+                                   SkXfermode::Mode mode, const SkRect* cull,
+                                   const SkPaint* paint,
+                                   const SkLight lights[], int numLights) {
+    NOTIFY_SETUP(this);
+    unsigned flags = 0;  // packs with the op, so needs no extra space
+
+    if (paint) {
+        flags |= kDrawAtlas_HasPaint_DrawOpFlag;
+        this->writePaint(*paint);
+    }
+
+    size_t size = 4;                        // image-slot
+    size += 4;                              // count
+    size += 4;                              // mode
+    size += 4;                              // num lights
+    size += count * sizeof(SkRSXform);      // xform
+    size += 2 * count * sizeof(SkRect);     // diffTex + normTex
+    if (colors) {
+        flags |= kDrawAtlas_HasColors_DrawOpFlag;
+        size += count * sizeof(SkColor);    // colors
+    }
+    if (cull) {
+        flags |= kDrawAtlas_HasCull_DrawOpFlag;
+        size += sizeof(SkRect);             // cull
+    }
+    size += numLights * sizeof(SkLight);    // lights
+    
+    if (this->needOpBytes(size)) {
+        this->writeOp(kDrawLitAtlas_DrawOp, flags, 0);
+        int32_t slot = fImageHeap->insert(atlas);
+        fWriter.write32(slot);
+        fWriter.write32(count);
+        fWriter.write32(mode);
+        fWriter.write(xform, count * sizeof(SkRSXform));
+        fWriter.write(diffTex, count * sizeof(SkRect));
+        fWriter.write(normTex, count * sizeof(SkRect));
+        if (colors) {
+            fWriter.write(colors, count * sizeof(SkColor));
+        }
+        if (cull) {
+            fWriter.writeRect(*cull);
+        }
+        fWriter.write32(numLights);
+        fWriter.write(lights, numLights * sizeof(SkLight));
+    }
+}
+
 void SkGPipeCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                                 const SkPoint texCoords[4], SkXfermode* xmode,
                                 const SkPaint& paint) {
     NOTIFY_SETUP(this);
     
     size_t size = SkPatchUtils::kNumCtrlPts * sizeof(SkPoint);
     unsigned flags = 0;
     if (colors) {
         flags |= kDrawVertices_HasColors_DrawOpFlag;
         size += SkPatchUtils::kNumCorners * sizeof(SkColor);
@@ skipping 319 matching lines @@
     int32_t slot = this->find(img);
     if (slot) {
         return slot;
     }
     // TODO: SkImage does not expose bytes per pixel, 4 is just a best guess.
     fBytesInCache += img->width() * img->height() * 4;
     *fArray.append() = SkRef(img);
     return fArray.count();  // slot is always index+1
 }