1 /* 2 * Copyright 2012 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 GrSWMaskHelper_DEFINED 9 #define GrSWMaskHelper_DEFINED 10 11 #include "GrColor.h" 12 #include "GrPipelineBuilder.h" 13 #include "SkBitmap.h" 14 #include "SkDraw.h" 15 #include "SkMatrix.h" 16 #include "SkRasterClip.h" 17 #include "SkRegion.h" 18 #include "SkTextureCompressor.h" 19 #include "SkTypes.h" 20 21 class GrClip; 22 class GrContext; 23 class GrTexture; 24 class SkPath; 25 class SkStrokeRec; 26 class GrDrawTarget; 27 28 /** 29 * The GrSWMaskHelper helps generate clip masks using the software rendering 30 * path. It is intended to be used as: 31 * 32 * GrSWMaskHelper helper(context); 33 * helper.init(...); 34 * 35 * draw one or more paths/rects specifying the required boolean ops 36 * 37 * toTexture(); // to get it from the internal bitmap to the GPU 38 * 39 * The result of this process will be the final mask (on the GPU) in the 40 * upper left hand corner of the texture. 41 */ 42 class GrSWMaskHelper : SkNoncopyable { 43 public: GrSWMaskHelper(GrContext * context)44 GrSWMaskHelper(GrContext* context) 45 : fContext(context) 46 , fCompressionMode(kNone_CompressionMode) { 47 } 48 49 // set up the internal state in preparation for draws. Since many masks 50 // may be accumulated in the helper during creation, "resultBounds" 51 // allows the caller to specify the region of interest - to limit the 52 // amount of work. allowCompression should be set to false if you plan on using 53 // your own texture to draw into, and not a scratch texture via getTexture(). 54 bool init(const SkIRect& resultBounds, const SkMatrix* matrix, bool allowCompression = true); 55 56 // Draw a single rect into the accumulation bitmap using the specified op 57 void draw(const SkRect& rect, SkRegion::Op op, 58 bool antiAlias, uint8_t alpha); 59 60 // Draw a single path into the accumuation bitmap using the specified op 61 void draw(const SkPath& path, const SkStrokeRec& stroke, SkRegion::Op op, 62 bool antiAlias, uint8_t alpha); 63 64 // Move the mask generation results from the internal bitmap to the gpu. 65 void toTexture(GrTexture* texture); 66 67 // Convert mask generation results to a signed distance field 68 void toSDF(unsigned char* sdf); 69 70 // Reset the internal bitmap clear(uint8_t alpha)71 void clear(uint8_t alpha) { 72 fPixels.erase(SkColorSetARGB(alpha, 0xFF, 0xFF, 0xFF)); 73 } 74 75 // Canonical usage utility that draws a single path and uploads it 76 // to the GPU. The result is returned. 77 static GrTexture* DrawPathMaskToTexture(GrContext* context, 78 const SkPath& path, 79 const SkStrokeRec& stroke, 80 const SkIRect& resultBounds, 81 bool antiAlias, 82 const SkMatrix* matrix); 83 84 // This utility routine is used to add a path's mask to some other draw. 85 // The ClipMaskManager uses it to accumulate clip masks while the 86 // GrSoftwarePathRenderer uses it to fulfill a drawPath call. 87 // It draws with "texture" as a path mask into "target" using "rect" as 88 // geometry and the current drawState. The current drawState is altered to 89 // accommodate the mask. 90 // Note that this method assumes that the GrPaint::kTotalStages slot in 91 // the draw state can be used to hold the mask texture stage. 92 // This method is really only intended to be used with the 93 // output of DrawPathMaskToTexture. 94 static void DrawToTargetWithPathMask(GrTexture* texture, 95 GrDrawTarget* target, 96 GrPipelineBuilder* pipelineBuilder, 97 GrColor, 98 const SkMatrix& viewMatrix, 99 const SkIRect& rect); 100 101 private: 102 // Helper function to get a scratch texture suitable for capturing the 103 // result (i.e., right size & format) 104 GrTexture* createTexture(); 105 106 GrContext* fContext; 107 SkMatrix fMatrix; 108 SkAutoPixmapStorage fPixels; 109 SkDraw fDraw; 110 SkRasterClip fRasterClip; 111 112 // This enum says whether or not we should compress the mask: 113 // kNone_CompressionMode: compression is not supported on this device. 114 // kCompress_CompressionMode: compress the bitmap before it gets sent to the gpu 115 // kBlitter_CompressionMode: write to the bitmap using a special compressed blitter. 116 enum CompressionMode { 117 kNone_CompressionMode, 118 kCompress_CompressionMode, 119 kBlitter_CompressionMode, 120 } fCompressionMode; 121 122 // This is the buffer into which we store our compressed data. This buffer is 123 // only allocated (non-null) if fCompressionMode is kBlitter_CompressionMode 124 SkAutoMalloc fCompressedBuffer; 125 126 // This is the desired format within which to compress the 127 // texture. This value is only valid if fCompressionMode is not kNone_CompressionMode. 128 SkTextureCompressor::Format fCompressedFormat; 129 130 // Actually sends the texture data to the GPU. This is called from 131 // toTexture with the data filled in depending on the texture config. 132 void sendTextureData(GrTexture *texture, const GrSurfaceDesc& desc, 133 const void *data, size_t rowbytes); 134 135 // Compresses the bitmap stored in fBM and sends the compressed data 136 // to the GPU to be stored in 'texture' using sendTextureData. 137 void compressTextureData(GrTexture *texture, const GrSurfaceDesc& desc); 138 139 typedef SkNoncopyable INHERITED; 140 }; 141 142 #endif // GrSWMaskHelper_DEFINED 143