Creating functions for uploading a mipmapped texture.

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrBatchFontCache.h"
 #include "GrBatchFlushState.h"
@@ skipping 468 matching lines @@
 
     return true;
 }
 
 void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                                             SkDrawFilter* drawFilter, const SkIRect& clipRect,
                                             GrRenderTarget* rt, const GrClip& clip) {
-    // The color here is the GrPaint color, and it is used to determine whether we 
+    // The color here is the GrPaint color, and it is used to determine whether we
     // have to regenerate LCD text blobs.
     // We use this color vs the SkPaint color because it has the colorfilter applied.
     cacheBlob->fPaintColor = color;
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
@@ skipping 217 matching lines @@
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         SkPoint offset;
         this->internalDrawDFText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                  byteLength, x, y, clipRect, textRatio, &fallbackTxt, &fallbackPos,
                                  &offset, skPaint);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(blob, 0, rt, clip, paint.getColor(), skPaint, viewMatrix, 
+            this->fallbackDrawPosText(blob, 0, rt, clip, paint.getColor(), skPaint, viewMatrix,
                                       fallbackTxt, fallbackPos, 2, offset, clipRect);
         }
     } else {
         blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
 
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                   byteLength, x, y, clipRect);
         SkGlyphCache::AttachCache(cache);
@@ skipping 18 matching lines @@
         SkPaint dfPaint;
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
 
         SkTDArray<char> fallbackTxt;
         SkTDArray<SkScalar> fallbackPos;
         this->internalDrawDFPosText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset, clipRect,
                                     textRatio, &fallbackTxt, &fallbackPos);
         if (fallbackTxt.count()) {
-            this->fallbackDrawPosText(blob, 0, rt, clip, paint.getColor(), skPaint, viewMatrix, 
-                                      fallbackTxt, fallbackPos, scalarsPerPosition, offset, 
+            this->fallbackDrawPosText(blob, 0, rt, clip, paint.getColor(), skPaint, viewMatrix,
+                                      fallbackTxt, fallbackPos, scalarsPerPosition, offset,
                                       clipRect);
         }
     } else {
         blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
         this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
                                      byteLength, pos, scalarsPerPosition, offset, clipRect);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 void GrAtlasTextContext::onDrawText(GrDrawContext* dc, GrRenderTarget* rt,
-                                    const GrClip& clip, 
+                                    const GrClip& clip,
                                     const GrPaint& paint, const SkPaint& skPaint,
                                     const SkMatrix& viewMatrix,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
     SkAutoTUnref<GrAtlasTextBlob> blob(
         this->createDrawTextBlob(rt, clip, paint, skPaint, viewMatrix,
                                  text, byteLength, x, y, regionClipBounds));
     this->flush(blob, dc, rt, skPaint, paint, clip, regionClipBounds);
 }
 
@@ skipping 1250 matching lines @@
     GrBatchFontCache* fFontCache;
 
     // Distance field properties
     SkAutoTUnref<const DistanceAdjustTable> fDistanceAdjustTable;
     SkColor fFilteredColor;
 
     typedef GrVertexBatch INHERITED;
 };
 
 void GrAtlasTextContext::flushRunAsPaths(GrDrawContext* dc, GrRenderTarget* rt,
-                                         const SkTextBlob::RunIterator& it, 
+                                         const SkTextBlob::RunIterator& it,
                                          const GrClip& clip, const SkPaint& skPaint,
                                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                                          const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     SkPaint runPaint = skPaint;
 
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
     const SkPoint& offset = it.offset();
 
     it.applyFontToPaint(&runPaint);
 
@@ skipping 179 matching lines @@
         gTextContext = GrAtlasTextContext::Create(context, gSurfaceProps);
     }
 
     // create dummy render target
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = 1024;
     desc.fHeight = 1024;
     desc.fConfig = kRGBA_8888_GrPixelConfig;
     desc.fSampleCnt = 0;
+    desc.fIsMipMapped = false;
     SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, true, nullptr, 0));
     SkASSERT(texture);
     SkASSERT(nullptr != texture->asRenderTarget());
     GrRenderTarget* rt = texture->asRenderTarget();
 
     // Setup dummy SkPaint / GrPaint
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPaint skPaint;
     skPaint.setColor(color);
@@ skipping 19 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif