robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 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 | #include "GrSWMaskHelper.h" |
krajcevski | 5c2fca0 | 2014-06-10 17:25:28 -0700 | [diff] [blame] | 9 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 10 | #include "GrDrawState.h" |
robertphillips@google.com | 9528bdb | 2013-09-18 22:33:57 +0000 | [diff] [blame] | 11 | #include "GrDrawTargetCaps.h" |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 12 | #include "GrGpu.h" |
| 13 | |
krajcevski | 5c2fca0 | 2014-06-10 17:25:28 -0700 | [diff] [blame] | 14 | #include "SkData.h" |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 15 | #include "SkDistanceFieldGen.h" |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 16 | #include "SkStrokeRec.h" |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 17 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 18 | // TODO: try to remove this #include |
| 19 | #include "GrContext.h" |
| 20 | |
| 21 | namespace { |
krajcevski | 5c2fca0 | 2014-06-10 17:25:28 -0700 | [diff] [blame] | 22 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 23 | /* |
| 24 | * Convert a boolean operation into a transfer mode code |
| 25 | */ |
| 26 | SkXfermode::Mode op_to_mode(SkRegion::Op op) { |
| 27 | |
| 28 | static const SkXfermode::Mode modeMap[] = { |
| 29 | SkXfermode::kDstOut_Mode, // kDifference_Op |
reed@google.com | 8d3cd7a | 2013-01-30 21:36:11 +0000 | [diff] [blame] | 30 | SkXfermode::kModulate_Mode, // kIntersect_Op |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 31 | SkXfermode::kSrcOver_Mode, // kUnion_Op |
| 32 | SkXfermode::kXor_Mode, // kXOR_Op |
| 33 | SkXfermode::kClear_Mode, // kReverseDifference_Op |
| 34 | SkXfermode::kSrc_Mode, // kReplace_Op |
| 35 | }; |
| 36 | |
| 37 | return modeMap[op]; |
| 38 | } |
| 39 | |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 40 | static inline GrPixelConfig fmt_to_config(SkTextureCompressor::Format fmt) { |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 41 | |
krajcevski | 95b1b3d | 2014-08-07 12:58:38 -0700 | [diff] [blame] | 42 | GrPixelConfig config; |
| 43 | switch (fmt) { |
| 44 | case SkTextureCompressor::kLATC_Format: |
| 45 | config = kLATC_GrPixelConfig; |
| 46 | break; |
| 47 | |
| 48 | case SkTextureCompressor::kR11_EAC_Format: |
| 49 | config = kR11_EAC_GrPixelConfig; |
| 50 | break; |
| 51 | |
| 52 | case SkTextureCompressor::kASTC_12x12_Format: |
| 53 | config = kASTC_12x12_GrPixelConfig; |
| 54 | break; |
| 55 | |
| 56 | case SkTextureCompressor::kETC1_Format: |
| 57 | config = kETC1_GrPixelConfig; |
| 58 | break; |
| 59 | |
| 60 | default: |
| 61 | SkDEBUGFAIL("No GrPixelConfig for compression format!"); |
| 62 | // Best guess |
| 63 | config = kAlpha_8_GrPixelConfig; |
| 64 | break; |
| 65 | } |
| 66 | |
| 67 | return config; |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 68 | } |
| 69 | |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 70 | static bool choose_compressed_fmt(const GrDrawTargetCaps* caps, |
| 71 | SkTextureCompressor::Format *fmt) { |
| 72 | if (NULL == fmt) { |
| 73 | return false; |
| 74 | } |
| 75 | |
| 76 | // We can't use scratch textures without the ability to update |
| 77 | // compressed textures... |
| 78 | if (!(caps->compressedTexSubImageSupport())) { |
| 79 | return false; |
| 80 | } |
| 81 | |
| 82 | // Figure out what our preferred texture type is. If ASTC is available, that always |
| 83 | // gives the biggest win. Otherwise, in terms of compression speed and accuracy, |
| 84 | // LATC has a slight edge over R11 EAC. |
| 85 | if (caps->isConfigTexturable(kASTC_12x12_GrPixelConfig)) { |
| 86 | *fmt = SkTextureCompressor::kASTC_12x12_Format; |
| 87 | return true; |
| 88 | } else if (caps->isConfigTexturable(kLATC_GrPixelConfig)) { |
| 89 | *fmt = SkTextureCompressor::kLATC_Format; |
| 90 | return true; |
| 91 | } else if (caps->isConfigTexturable(kR11_EAC_GrPixelConfig)) { |
| 92 | *fmt = SkTextureCompressor::kR11_EAC_Format; |
| 93 | return true; |
| 94 | } |
| 95 | |
| 96 | return false; |
| 97 | } |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 98 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | /** |
| 102 | * Draw a single rect element of the clip stack into the accumulation bitmap |
| 103 | */ |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 104 | void GrSWMaskHelper::draw(const SkRect& rect, SkRegion::Op op, |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 105 | bool antiAlias, uint8_t alpha) { |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 106 | SkPaint paint; |
| 107 | |
| 108 | SkXfermode* mode = SkXfermode::Create(op_to_mode(op)); |
| 109 | |
krajcevski | 71614ac | 2014-08-13 10:36:18 -0700 | [diff] [blame] | 110 | SkASSERT(kNone_CompressionMode == fCompressionMode); |
| 111 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 112 | paint.setXfermode(mode); |
| 113 | paint.setAntiAlias(antiAlias); |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 114 | paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 115 | |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 116 | fDraw.drawRect(rect, paint); |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 117 | |
| 118 | SkSafeUnref(mode); |
| 119 | } |
| 120 | |
| 121 | /** |
| 122 | * Draw a single path element of the clip stack into the accumulation bitmap |
| 123 | */ |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 124 | void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegion::Op op, |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 125 | bool antiAlias, uint8_t alpha) { |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 126 | |
| 127 | SkPaint paint; |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 128 | if (stroke.isHairlineStyle()) { |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 129 | paint.setStyle(SkPaint::kStroke_Style); |
| 130 | paint.setStrokeWidth(SK_Scalar1); |
| 131 | } else { |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 132 | if (stroke.isFillStyle()) { |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 133 | paint.setStyle(SkPaint::kFill_Style); |
| 134 | } else { |
| 135 | paint.setStyle(SkPaint::kStroke_Style); |
| 136 | paint.setStrokeJoin(stroke.getJoin()); |
| 137 | paint.setStrokeCap(stroke.getCap()); |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 138 | paint.setStrokeWidth(stroke.getWidth()); |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 139 | } |
| 140 | } |
reed@google.com | 84e922b | 2013-11-04 20:57:36 +0000 | [diff] [blame] | 141 | paint.setAntiAlias(antiAlias); |
reed@google.com | 84e922b | 2013-11-04 20:57:36 +0000 | [diff] [blame] | 142 | |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 143 | SkTBlitterAllocator allocator; |
| 144 | SkBlitter* blitter = NULL; |
| 145 | if (kBlitter_CompressionMode == fCompressionMode) { |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 146 | SkASSERT(fCompressedBuffer.get()); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 147 | blitter = SkTextureCompressor::CreateBlitterForFormat( |
| 148 | fBM.width(), fBM.height(), fCompressedBuffer.get(), &allocator, fCompressedFormat); |
| 149 | } |
| 150 | |
reed@google.com | 126f7f5 | 2013-11-07 16:06:53 +0000 | [diff] [blame] | 151 | if (SkRegion::kReplace_Op == op && 0xFF == alpha) { |
| 152 | SkASSERT(0xFF == paint.getAlpha()); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 153 | fDraw.drawPathCoverage(path, paint, blitter); |
reed@google.com | 126f7f5 | 2013-11-07 16:06:53 +0000 | [diff] [blame] | 154 | } else { |
| 155 | paint.setXfermodeMode(op_to_mode(op)); |
| 156 | paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 157 | fDraw.drawPath(path, paint, blitter); |
reed@google.com | 126f7f5 | 2013-11-07 16:06:53 +0000 | [diff] [blame] | 158 | } |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 159 | } |
| 160 | |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 161 | bool GrSWMaskHelper::init(const SkIRect& resultBounds, |
krajcevski | 71614ac | 2014-08-13 10:36:18 -0700 | [diff] [blame] | 162 | const SkMatrix* matrix, |
| 163 | bool allowCompression) { |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 164 | if (matrix) { |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 165 | fMatrix = *matrix; |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 166 | } else { |
| 167 | fMatrix.setIdentity(); |
| 168 | } |
| 169 | |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 170 | // Now translate so the bound's UL corner is at the origin |
| 171 | fMatrix.postTranslate(-resultBounds.fLeft * SK_Scalar1, |
| 172 | -resultBounds.fTop * SK_Scalar1); |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 173 | SkIRect bounds = SkIRect::MakeWH(resultBounds.width(), |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 174 | resultBounds.height()); |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 175 | |
krajcevski | 71614ac | 2014-08-13 10:36:18 -0700 | [diff] [blame] | 176 | if (allowCompression && |
| 177 | fContext->getOptions().fDrawPathToCompressedTexture && |
krajcevski | 9c6d4d7 | 2014-08-12 07:26:25 -0700 | [diff] [blame] | 178 | choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) { |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 179 | fCompressionMode = kCompress_CompressionMode; |
| 180 | } |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 181 | |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 182 | // Make sure that the width is a multiple of the desired block dimensions |
| 183 | // to allow for specialized SIMD instructions that compress multiple blocks at a time. |
| 184 | int cmpWidth = bounds.fRight; |
| 185 | int cmpHeight = bounds.fBottom; |
| 186 | if (kCompress_CompressionMode == fCompressionMode) { |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 187 | int dimX, dimY; |
| 188 | SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 189 | cmpWidth = dimX * ((cmpWidth + (dimX - 1)) / dimX); |
| 190 | cmpHeight = dimY * ((cmpHeight + (dimY - 1)) / dimY); |
| 191 | |
| 192 | // Can we create a blitter? |
| 193 | if (SkTextureCompressor::ExistsBlitterForFormat(fCompressedFormat)) { |
| 194 | int cmpSz = SkTextureCompressor::GetCompressedDataSize( |
| 195 | fCompressedFormat, cmpWidth, cmpHeight); |
| 196 | |
| 197 | SkASSERT(cmpSz > 0); |
| 198 | SkASSERT(NULL == fCompressedBuffer.get()); |
| 199 | fCompressedBuffer.reset(cmpSz); |
| 200 | fCompressionMode = kBlitter_CompressionMode; |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | // If we don't have a custom blitter, then we either need a bitmap to compress |
| 205 | // from or a bitmap that we're going to use as a texture. In any case, we should |
| 206 | // allocate the pixels for a bitmap |
| 207 | const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(cmpWidth, cmpHeight); |
| 208 | if (kBlitter_CompressionMode != fCompressionMode) { |
reed | 8482504 | 2014-09-02 12:50:45 -0700 | [diff] [blame] | 209 | if (!fBM.tryAllocPixels(bmImageInfo)) { |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 210 | return false; |
| 211 | } |
| 212 | |
| 213 | sk_bzero(fBM.getPixels(), fBM.getSafeSize()); |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 214 | } else { |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 215 | // Otherwise, we just need to remember how big the buffer is... |
| 216 | fBM.setInfo(bmImageInfo); |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 217 | } |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 218 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 219 | sk_bzero(&fDraw, sizeof(fDraw)); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 220 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 221 | fRasterClip.setRect(bounds); |
| 222 | fDraw.fRC = &fRasterClip; |
| 223 | fDraw.fClip = &fRasterClip.bwRgn(); |
| 224 | fDraw.fMatrix = &fMatrix; |
| 225 | fDraw.fBitmap = &fBM; |
| 226 | return true; |
| 227 | } |
| 228 | |
| 229 | /** |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 230 | * Get a texture (from the texture cache) of the correct size & format. |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 231 | */ |
bsalomon | e305973 | 2014-10-14 11:47:22 -0700 | [diff] [blame] | 232 | GrTexture* GrSWMaskHelper::createTexture() { |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame^] | 233 | GrSurfaceDesc desc; |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 234 | desc.fWidth = fBM.width(); |
| 235 | desc.fHeight = fBM.height(); |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 236 | desc.fConfig = kAlpha_8_GrPixelConfig; |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 237 | |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 238 | if (kNone_CompressionMode != fCompressionMode) { |
krajcevski | b577c55 | 2014-07-16 13:26:43 -0700 | [diff] [blame] | 239 | |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 240 | #ifdef SK_DEBUG |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 241 | int dimX, dimY; |
| 242 | SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY); |
| 243 | SkASSERT((desc.fWidth % dimX) == 0); |
| 244 | SkASSERT((desc.fHeight % dimY) == 0); |
krajcevski | 25a67bc | 2014-07-29 11:44:26 -0700 | [diff] [blame] | 245 | #endif |
| 246 | |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 247 | desc.fConfig = fmt_to_config(fCompressedFormat); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 248 | SkASSERT(fContext->getGpu()->caps()->isConfigTexturable(desc.fConfig)); |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 249 | } |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 250 | |
bsalomon | e305973 | 2014-10-14 11:47:22 -0700 | [diff] [blame] | 251 | return fContext->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch); |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 252 | } |
| 253 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame^] | 254 | void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrSurfaceDesc& desc, |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 255 | const void *data, int rowbytes) { |
| 256 | // If we aren't reusing scratch textures we don't need to flush before |
| 257 | // writing since no one else will be using 'texture' |
| 258 | bool reuseScratch = fContext->getGpu()->caps()->reuseScratchTextures(); |
krajcevski | 5c2fca0 | 2014-06-10 17:25:28 -0700 | [diff] [blame] | 259 | |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 260 | // Since we're uploading to it, and it's compressed, 'texture' shouldn't |
| 261 | // have a render target. |
| 262 | SkASSERT(NULL == texture->asRenderTarget()); |
| 263 | |
| 264 | texture->writePixels(0, 0, desc.fWidth, desc.fHeight, |
| 265 | desc.fConfig, data, rowbytes, |
| 266 | reuseScratch ? 0 : GrContext::kDontFlush_PixelOpsFlag); |
krajcevski | 5c2fca0 | 2014-06-10 17:25:28 -0700 | [diff] [blame] | 267 | } |
| 268 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame^] | 269 | void GrSWMaskHelper::compressTextureData(GrTexture *texture, const GrSurfaceDesc& desc) { |
krajcevski | b577c55 | 2014-07-16 13:26:43 -0700 | [diff] [blame] | 270 | |
| 271 | SkASSERT(GrPixelConfigIsCompressed(desc.fConfig)); |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 272 | SkASSERT(fmt_to_config(fCompressedFormat) == desc.fConfig); |
krajcevski | b577c55 | 2014-07-16 13:26:43 -0700 | [diff] [blame] | 273 | |
krajcevski | b3abe90 | 2014-07-30 13:08:11 -0700 | [diff] [blame] | 274 | SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fBM, fCompressedFormat)); |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 275 | SkASSERT(cmpData); |
krajcevski | b577c55 | 2014-07-16 13:26:43 -0700 | [diff] [blame] | 276 | |
| 277 | this->sendTextureData(texture, desc, cmpData->data(), 0); |
| 278 | } |
| 279 | |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 280 | /** |
| 281 | * Move the result of the software mask generation back to the gpu |
| 282 | */ |
robertphillips@google.com | d92cf2e | 2013-07-19 18:13:02 +0000 | [diff] [blame] | 283 | void GrSWMaskHelper::toTexture(GrTexture *texture) { |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 284 | SkAutoLockPixels alp(fBM); |
| 285 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame^] | 286 | GrSurfaceDesc desc; |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 287 | desc.fWidth = fBM.width(); |
| 288 | desc.fHeight = fBM.height(); |
| 289 | desc.fConfig = texture->config(); |
| 290 | |
| 291 | // First see if we should compress this texture before uploading. |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 292 | switch (fCompressionMode) { |
| 293 | case kNone_CompressionMode: |
| 294 | this->sendTextureData(texture, desc, fBM.getPixels(), fBM.rowBytes()); |
| 295 | break; |
| 296 | |
| 297 | case kCompress_CompressionMode: |
| 298 | this->compressTextureData(texture, desc); |
| 299 | break; |
| 300 | |
| 301 | case kBlitter_CompressionMode: |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 302 | SkASSERT(fCompressedBuffer.get()); |
krajcevski | b8ccc2f | 2014-08-07 08:15:14 -0700 | [diff] [blame] | 303 | this->sendTextureData(texture, desc, fCompressedBuffer.get(), 0); |
| 304 | break; |
krajcevski | fb4f5cb | 2014-06-12 09:20:38 -0700 | [diff] [blame] | 305 | } |
robertphillips@google.com | 58b2021 | 2012-06-27 20:44:52 +0000 | [diff] [blame] | 306 | } |
| 307 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 308 | /** |
| 309 | * Convert mask generation results to a signed distance field |
| 310 | */ |
| 311 | void GrSWMaskHelper::toSDF(unsigned char* sdf) { |
| 312 | SkAutoLockPixels alp(fBM); |
| 313 | |
| 314 | SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fBM.getPixels(), |
| 315 | fBM.width(), fBM.height(), fBM.rowBytes()); |
| 316 | } |
| 317 | |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 318 | //////////////////////////////////////////////////////////////////////////////// |
| 319 | /** |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 320 | * Software rasterizes path to A8 mask (possibly using the context's matrix) |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 321 | * and uploads the result to a scratch texture. Returns the resulting |
| 322 | * texture on success; NULL on failure. |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 323 | */ |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 324 | GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context, |
| 325 | const SkPath& path, |
sugoi@google.com | 5f74cf8 | 2012-12-17 21:16:45 +0000 | [diff] [blame] | 326 | const SkStrokeRec& stroke, |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 327 | const SkIRect& resultBounds, |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 328 | bool antiAlias, |
bsalomon@google.com | b9086a0 | 2012-11-01 18:02:54 +0000 | [diff] [blame] | 329 | SkMatrix* matrix) { |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 330 | GrSWMaskHelper helper(context); |
| 331 | |
reed@google.com | 84e922b | 2013-11-04 20:57:36 +0000 | [diff] [blame] | 332 | if (!helper.init(resultBounds, matrix)) { |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 333 | return NULL; |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 334 | } |
| 335 | |
sugoi@google.com | 12b4e27 | 2012-12-06 20:13:11 +0000 | [diff] [blame] | 336 | helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF); |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 337 | |
bsalomon | e305973 | 2014-10-14 11:47:22 -0700 | [diff] [blame] | 338 | GrTexture* texture(helper.createTexture()); |
| 339 | if (!texture) { |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 340 | return NULL; |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 341 | } |
| 342 | |
bsalomon | e305973 | 2014-10-14 11:47:22 -0700 | [diff] [blame] | 343 | helper.toTexture(texture); |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 344 | |
bsalomon | e305973 | 2014-10-14 11:47:22 -0700 | [diff] [blame] | 345 | return texture; |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 346 | } |
| 347 | |
| 348 | void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture, |
| 349 | GrDrawTarget* target, |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 350 | const SkIRect& rect) { |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 351 | GrDrawState* drawState = target->drawState(); |
| 352 | |
bsalomon@google.com | 137f134 | 2013-05-29 21:27:53 +0000 | [diff] [blame] | 353 | GrDrawState::AutoViewMatrixRestore avmr; |
| 354 | if (!avmr.setIdentity(drawState)) { |
bsalomon@google.com | e3d3216 | 2012-07-20 13:37:06 +0000 | [diff] [blame] | 355 | return; |
| 356 | } |
bsalomon@google.com | eb6879f | 2013-06-13 19:34:18 +0000 | [diff] [blame] | 357 | GrDrawState::AutoRestoreEffects are(drawState); |
robertphillips@google.com | 5dfb672 | 2012-07-09 16:32:28 +0000 | [diff] [blame] | 358 | |
commit-bot@chromium.org | fd03d4a | 2013-07-17 21:39:42 +0000 | [diff] [blame] | 359 | SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft, |
| 360 | SK_Scalar1 * rect.fTop, |
| 361 | SK_Scalar1 * rect.fRight, |
| 362 | SK_Scalar1 * rect.fBottom); |
bsalomon@google.com | c781888 | 2013-03-20 19:19:53 +0000 | [diff] [blame] | 363 | |
| 364 | // We want to use device coords to compute the texture coordinates. We set our matrix to be |
| 365 | // equal to the view matrix followed by a translation so that the top-left of the device bounds |
| 366 | // maps to 0,0, and then a scaling matrix to normalized coords. We apply this matrix to the |
| 367 | // vertex positions rather than local coords. |
| 368 | SkMatrix maskMatrix; |
| 369 | maskMatrix.setIDiv(texture->width(), texture->height()); |
| 370 | maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop)); |
| 371 | maskMatrix.preConcat(drawState->getViewMatrix()); |
| 372 | |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 373 | drawState->addCoverageProcessor( |
bsalomon@google.com | c781888 | 2013-03-20 19:19:53 +0000 | [diff] [blame] | 374 | GrSimpleTextureEffect::Create(texture, |
| 375 | maskMatrix, |
humper@google.com | b86add1 | 2013-07-25 18:49:07 +0000 | [diff] [blame] | 376 | GrTextureParams::kNone_FilterMode, |
bsalomon@google.com | 77af680 | 2013-10-02 13:04:56 +0000 | [diff] [blame] | 377 | kPosition_GrCoordSet))->unref(); |
bsalomon@google.com | c781888 | 2013-03-20 19:19:53 +0000 | [diff] [blame] | 378 | |
| 379 | target->drawSimpleRect(dstRect); |
robertphillips@google.com | 366f1c6 | 2012-06-29 21:38:47 +0000 | [diff] [blame] | 380 | } |