int SkPictureRecord::find(SkTDArray<const SkFlatBitmap* >& bitmaps, const SkBitmap& bitmap) { SkFlatBitmap* flat = SkFlatBitmap::Flatten(&fHeap, bitmap, fBitmapIndex, &fRCSet); int index = SkTSearch<SkFlatData>((const SkFlatData**) bitmaps.begin(), bitmaps.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare); if (index >= 0) { (void)fHeap.unalloc(flat); return bitmaps[index]->index(); } index = ~index; *bitmaps.insert(index) = flat; return fBitmapIndex++; }
void SkFontData::loadXml( SkTDArray<FontInitRec> &info ) { SkTDArray<FontFamily*> families; getFamilies( families ); info.reset(); for( int i = 0 ; i < families.count() ; ++i ) { FontFamily * family = families[i]; for( int j = 0 ; j < family->fFontFileArray.count() ; ++j ) { const char * filename = family->fFontFileArray[j]->fFileName; #ifndef DEPRECATED_CODE HyLogif( "DEPRECATED_CODE" ); if( haveSystemFont( filename ) ) continue; #endif FontInitRec fontInfoRecord; fontInfoRecord.fFileName = filename; if( j == 0 ) { if( family->fNames.count() == 0 ) fontInfoRecord.fNames = ( char ** )gFBNames; // fallback. else { SkTDArray<const char*> names = family->fNames; const char ** nameList = ( const char ** )calloc( ( names.count() + 1 ), sizeof( char * ) ); if( nameList == NULL ) { break; } for( int n = 0 ; n < names.count() ; ++n ) { nameList[n] = names[n]; } nameList[names.count()] = NULL; fontInfoRecord.fNames = nameList; } } else { fontInfoRecord.fNames = NULL; } *info.append() = fontInfoRecord; } } families.deleteAll(); }
void SkTileGrid::search(const SkIRect& query, SkTDArray<void*>* results) { SkIRect adjustedQuery = query; // The inset is to counteract the outset that was applied in 'insert' // The outset/inset is to optimize for lookups of size // 'tileInterval + 2 * margin' that are aligned with the tile grid. adjustedQuery.inset(fInfo.fMargin.width(), fInfo.fMargin.height()); adjustedQuery.offset(fInfo.fOffset); adjustedQuery.sort(); // in case the inset inverted the rectangle // Convert the query rectangle from device coordinates to tile coordinates // by rounding outwards to the nearest tile boundary so that the resulting tile // region includes the query rectangle. (using truncating division to "floor") int tileStartX = adjustedQuery.left() / fInfo.fTileInterval.width(); int tileEndX = (adjustedQuery.right() + fInfo.fTileInterval.width() - 1) / fInfo.fTileInterval.width(); int tileStartY = adjustedQuery.top() / fInfo.fTileInterval.height(); int tileEndY = (adjustedQuery.bottom() + fInfo.fTileInterval.height() - 1) / fInfo.fTileInterval.height(); tileStartX = SkPin32(tileStartX, 0, fXTileCount - 1); tileEndX = SkPin32(tileEndX, tileStartX+1, fXTileCount); tileStartY = SkPin32(tileStartY, 0, fYTileCount - 1); tileEndY = SkPin32(tileEndY, tileStartY+1, fYTileCount); int queryTileCount = (tileEndX - tileStartX) * (tileEndY - tileStartY); SkASSERT(queryTileCount); if (queryTileCount == 1) { *results = this->tile(tileStartX, tileStartY); } else { results->reset(); SkTDArray<int> curPositions; curPositions.setCount(queryTileCount); // Note: Reserving space for 1024 tile pointers on the stack. If the // malloc becomes a bottleneck, we may consider increasing that number. // Typical large web page, say 2k x 16k, would require 512 tiles of // size 256 x 256 pixels. SkAutoSTArray<1024, SkTDArray<void *>*> storage(queryTileCount); SkTDArray<void *>** tileRange = storage.get(); int tile = 0; for (int x = tileStartX; x < tileEndX; ++x) { for (int y = tileStartY; y < tileEndY; ++y) { tileRange[tile] = &this->tile(x, y); curPositions[tile] = tileRange[tile]->count() ? 0 : kTileFinished; ++tile; } } void *nextElement; while(NULL != (nextElement = fNextDatumFunction(tileRange, curPositions))) { results->push(nextElement); } } }
static void test(skiatest::Reporter* reporter, const SkDCubic* cubics, const char* name, int firstTest, size_t testCount) { for (size_t index = firstTest; index < testCount; ++index) { const SkDCubic& cubic = cubics[index]; double precision = cubic.calcPrecision(); SkTDArray<SkDQuad> quads; CubicToQuads(cubic, precision, quads); if (quads.count() != 1) { SkDebugf("%s [%d] cubic to quadratics failed count=%d\n", name, static_cast<int>(index), quads.count()); } REPORTER_ASSERT(reporter, quads.count() == 1); } }
int SkPictureRecord::find(SkTDArray<const SkFlatMatrix* >& matrices, const SkMatrix* matrix) { if (matrix == NULL) return 0; SkFlatMatrix* flat = SkFlatMatrix::Flatten(&fHeap, *matrix, fMatrixIndex); int index = SkTSearch<SkFlatData>((const SkFlatData**) matrices.begin(), matrices.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare); if (index >= 0) { (void)fHeap.unalloc(flat); return matrices[index]->index(); } index = ~index; *matrices.insert(index) = flat; return fMatrixIndex++; }
// register a configuration variable after its value has been set by the parser. // we maintain a vector of these things instead of just a single one because the // user might set the value after initialization time and we need to have // all the pointers lying around, not just one. void SkRTConfRegistry::registerConf(SkRTConfBase *conf) { SkTDArray<SkRTConfBase *> *confArray; if (fConfs.find(conf->getName(), &confArray)) { if (!conf->equals(confArray->getAt(0))) { SkDebugf("WARNING: Skia config \"%s\" was registered more than once in incompatible ways.\n", conf->getName()); } else { confArray->append(1, &conf); } } else { confArray = new SkTDArray<SkRTConfBase *>; confArray->append(1, &conf); fConfs.set(conf->getName(),confArray); } }
// FIXME : add this as a member of SkPath void Simplify(const SkPath& path, SkPath* result) { #if DEBUG_SORT || DEBUG_SWAP_TOP gDebugSortCount = gDebugSortCountDefault; #endif // returns 1 for evenodd, -1 for winding, regardless of inverse-ness result->reset(); result->setFillType(SkPath::kEvenOdd_FillType); SkPathWriter simple(*result); // turn path into list of segments SkTArray<SkOpContour> contours; SkOpEdgeBuilder builder(path, contours); builder.finish(); SkTDArray<SkOpContour*> contourList; MakeContourList(contours, contourList, false, false); SkOpContour** currentPtr = contourList.begin(); if (!currentPtr) { return; } SkOpContour** listEnd = contourList.end(); // find all intersections between segments do { SkOpContour** nextPtr = currentPtr; SkOpContour* current = *currentPtr++; if (current->containsCubics()) { AddSelfIntersectTs(current); } SkOpContour* next; do { next = *nextPtr++; } while (AddIntersectTs(current, next) && nextPtr != listEnd); } while (currentPtr != listEnd); // eat through coincident edges CoincidenceCheck(&contourList, 0); FixOtherTIndex(&contourList); SortSegments(&contourList); #if DEBUG_ACTIVE_SPANS DebugShowActiveSpans(contourList); #endif // construct closed contours if (builder.xorMask() == kWinding_PathOpsMask ? bridgeWinding(contourList, &simple) : !bridgeXor(contourList, &simple)) { // if some edges could not be resolved, assemble remaining fragments SkPath temp; temp.setFillType(SkPath::kEvenOdd_FillType); SkPathWriter assembled(temp); Assemble(simple, &assembled); *result = *assembled.nativePath(); } }
bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params, void* eng, SkScriptValue* value) { if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false) return false; if (params.count() != 1) return false; SkScriptValue* scriptValue = params.begin(); SkDisplayTypes type = scriptValue->fType; SkScalar scalar = scriptValue->fOperand.fScalar; value->fType = SkType_Int; value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false && SkScalarAbs(scalar) != SK_ScalarInfinity : type == SkType_Int; return true; }
static void add_name(const char name[], FamilyRec* family) { SkAutoAsciiToLC tolc(name); name = tolc.lc(); NameFamilyPair* list = gNameList.begin(); int count = gNameList.count(); int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0])); if (index < 0) { list = gNameList.insert(~index); list->construct(name, family); } }
static void add_subdict( const SkTDArray<SkPDFObject*>& resourceList, SkPDFResourceDict::SkPDFResourceType type, SkPDFDict* dst) { if (0 == resourceList.count()) { return; } SkAutoTUnref<SkPDFDict> resources(new SkPDFDict); for (int i = 0; i < resourceList.count(); i++) { resources->insertObjRef(SkPDFResourceDict::getResourceName(type, i), SkRef(resourceList[i])); } dst->insertObject(get_resource_type_name(type), resources.detach()); }
bool SkConcaveToTriangles(size_t numPts, const SkPoint pts[], SkTDArray<SkPoint> *triangles) { DebugPrintf("SkConcaveToTriangles()\n"); SkTDArray<Vertex> vertices; vertices.setCount(numPts); if (!ConvertPointsToVertices(numPts, pts, vertices.begin())) return false; triangles->setReserve(numPts); triangles->setCount(0); return Triangulate(vertices.begin(), vertices.end() - 1, triangles); }
static void add_subdict( const SkTDArray<SkPDFObject*>& resourceList, SkPDFResourceDict::SkPDFResourceType type, SkPDFDict* dst) { if (0 == resourceList.count()) { return; } auto resources = sk_make_sp<SkPDFDict>(); for (int i = 0; i < resourceList.count(); i++) { resources->insertObjRef(SkPDFResourceDict::getResourceName(type, i), sk_ref_sp(resourceList[i])); } dst->insertObject(get_resource_type_name(type), std::move(resources)); }
void SkFontConfigParser::GetTestFontFamilies(SkTDArray<FontFamily*> &fontFamilies, const char* testMainConfigFile, const char* testFallbackConfigFile) { parseConfigFile(testMainConfigFile, fontFamilies); SkTDArray<FontFamily*> fallbackFonts; parseConfigFile(testFallbackConfigFile, fallbackFonts); // Append all fallback fonts to system fonts for (int i = 0; i < fallbackFonts.count(); ++i) { fallbackFonts[i]->fIsFallbackFont = true; *fontFamilies.append() = fallbackFonts[i]; } }
void SkTileGrid::search(const SkIRect& query, SkTDArray<void*>* results) { SkIRect adjustedQuery = query; adjustedQuery.inset(fInfo.fMargin.width(), fInfo.fMargin.height()); adjustedQuery.offset(fInfo.fOffset); // Convert the query rectangle from device coordinates to tile coordinates // by rounding outwards to the nearest tile boundary so that the resulting tile // region includes the query rectangle. (using truncating division to "floor") int tileStartX = adjustedQuery.left() / fInfo.fTileInterval.width(); int tileEndX = (adjustedQuery.right() + fInfo.fTileInterval.width() - 1) / fInfo.fTileInterval.width(); int tileStartY = adjustedQuery.top() / fInfo.fTileInterval.height(); int tileEndY = (adjustedQuery.bottom() + fInfo.fTileInterval.height() - 1) / fInfo.fTileInterval.height(); if (tileStartX >= fXTileCount || tileStartY >= fYTileCount || tileEndX <= 0 || tileEndY <= 0) { return; // query does not intersect the grid } // clamp to grid if (tileStartX < 0) tileStartX = 0; if (tileStartY < 0) tileStartY = 0; if (tileEndX > fXTileCount) tileEndX = fXTileCount; if (tileEndY > fYTileCount) tileEndY = fYTileCount; int queryTileCount = (tileEndX - tileStartX) * (tileEndY - tileStartY); if (queryTileCount == 1) { *results = this->tile(tileStartX, tileStartY); } else { results->reset(); SkTDArray<int> curPositions; curPositions.setCount(queryTileCount); // Note: Reserving space for 1024 tile pointers on the stack. If the // malloc becomes a bottleneck, we may consider increasing that number. // Typical large web page, say 2k x 16k, would require 512 tiles of // size 256 x 256 pixels. SkAutoSTArray<1024, SkTDArray<void *>*> storage(queryTileCount); SkTDArray<void *>** tileRange = storage.get(); int tile = 0; for (int x = tileStartX; x < tileEndX; ++x) { for (int y = tileStartY; y < tileEndY; ++y) { tileRange[tile] = &this->tile(x, y); curPositions[tile] = tileRange[tile]->count() ? 0 : kTileFinished; ++tile; } } void *nextElement; while(NULL != (nextElement = fNextDatumFunction(tileRange, curPositions))) { results->push(nextElement); } } }
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { for (Draw** iter = fList.begin(); iter < fList.end(); iter++) { (*iter)->setSelected(false); } Click* c = new Click(this); Draw* d = this->hitTestList(x, y); if (d) { d->setSelected(true); c->setType("dragger"); } else { c->setType("maker"); } return c; }
void GrLayerHoister::DrawLayersToAtlas(GrContext* context, const SkTDArray<GrHoistedLayer>& atlased) { if (atlased.count() > 0) { // All the atlased layers are rendered into the same GrTexture SkSurfaceProps props(0, kUnknown_SkPixelGeometry); SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect( atlased[0].fLayer->texture()->asRenderTarget(), &props)); SkCanvas* atlasCanvas = surface->getCanvas(); for (int i = 0; i < atlased.count(); ++i) { const GrCachedLayer* layer = atlased[i].fLayer; const SkBigPicture* pict = atlased[i].fPicture->asSkBigPicture(); if (!pict) { // TODO: can we assume / assert this? continue; } const SkIPoint offset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop); SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();) SkASSERT(!layerPaint || !layerPaint->getImageFilter()); SkASSERT(!layer->filter()); atlasCanvas->save(); // Add a rect clip to make sure the rendering doesn't // extend beyond the boundaries of the atlased sub-rect const SkRect bound = SkRect::Make(layer->rect()); atlasCanvas->clipRect(bound); atlasCanvas->clear(0); // '-offset' maps the layer's top/left to the origin. // Since this layer is atlased, the top/left corner needs // to be offset to the correct location in the backing texture. SkMatrix initialCTM; initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY)); initialCTM.preTranslate(bound.fLeft, bound.fTop); initialCTM.preConcat(atlased[i].fPreMat); atlasCanvas->setMatrix(initialCTM); atlasCanvas->concat(atlased[i].fLocalMat); pict->partialPlayback(atlasCanvas, layer->start() + 1, layer->stop(), initialCTM); atlasCanvas->restore(); } atlasCanvas->flush(); }
void SkFontData::loadFont() { SkTDArray<FontInitRec> info; SkTypeface * firstInFamily = NULL; loadXml( info ); for( int i = 0 ; i < info.count() ; i++ ) { const char * const * names = info[i].fNames; if( names != NULL ) firstInFamily = NULL; bool isFixedWidth; SkString name; SkTypeface::Style style; bool isExpected = ( names != gFBNames ); SkString fullpath; getFullPathDownloadFont( &fullpath, info[i].fFileName ); if( !getNameAndStyleDlFont( fullpath.c_str(), &name, &style, &isFixedWidth, isExpected ) ) continue; SkTypeface * tf = SkNEW_ARGS( FileTypeface, ( style, true, fullpath.c_str(), isFixedWidth ) ); addTypefaceLocked( tf, firstInFamily ); if( names != NULL ) { firstInFamily = tf; FamilyRec * family = findFamilyLocked( tf ); if( isDefaultSansFont( names ) ) { FileTypeface * ftf = ( FileTypeface * )tf; setFamilyAndTypeface( family, ftf ); setWebFaceName( names[0] ); } while( *names ) { addNameLocked( *names, family ); names += 1; } } } }
virtual void onDraw(SkCanvas* canvas) { this->drawBG(canvas); test_clearonlayers(canvas); return; // test_strokerect(canvas); return; for (Draw** iter = fList.begin(); iter < fList.end(); iter++) { (*iter)->draw(canvas); } if (fDraw) { fDraw->draw(canvas); } }
bool ActiveTrapezoids::insertNewTrapezoid(Vertex *vt, Vertex *left, Vertex *right) { DebugPrintf("Inserting a trapezoid..."); if (vt->fTrap0.left() == NULL && vt->fTrap0.right() == NULL) { vt->fTrap0.setLeft(left); vt->fTrap0.setRight(right); insert(&vt->fTrap0); } else if (vt->fTrap1.left() == NULL && vt->fTrap1.right() == NULL) { DebugPrintf("a second one..."); vt->fTrap1.setLeft(left); vt->fTrap1.setRight(right); if (vt->fTrap1 < vt->fTrap0) { // Keep trapezoids sorted. remove(&vt->fTrap0); Trapezoid t = vt->fTrap0; vt->fTrap0 = vt->fTrap1; vt->fTrap1 = t; insert(&vt->fTrap0); } insert(&vt->fTrap1); } else { FailureMessage("More than 2 trapezoids requested for a vertex\n"); return false; } DebugPrintf(" done. %d incomplete trapezoids\n", fTrapezoids.count()); return true; }
void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const bool isolated) { for (int i = 0; i < families.count(); i++) { FontFamily& family = *families[i]; SkTArray<NameToFamily, true>* nameToFamily = &fNameToFamilyMap; if (family.fIsFallbackFont) { nameToFamily = &fFallbackNameToFamilyMap; if (0 == family.fNames.count()) { SkString& fallbackName = family.fNames.push_back(); fallbackName.printf("%.2x##fallback", i); } } sk_sp<SkFontStyleSet_Android> newSet = sk_make_sp<SkFontStyleSet_Android>(family, fScanner, isolated); if (0 == newSet->count()) { continue; } for (const SkString& name : family.fNames) { nameToFamily->emplace_back(NameToFamily{name, newSet.get()}); } fStyleSets.emplace_back(std::move(newSet)); } }
static void drawdots(SkCanvas* canvas, const SkPaint& orig) { SkTDArray<SkPoint> pts; SkPathEffect* pe = makepe(0, &pts); SkScalar width = -1; SkPath path, dstPath; orig.getTextPath("9", 1, 0, 0, &path); pe->filterPath(&dstPath, path, &width); SkPaint p; p.setAntiAlias(true); p.setStrokeWidth(10); p.setColor(SK_ColorRED); canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(), p); }
static sk_sp<SkTypeface_AndroidSystem> find_family_style_character( const SkTDArray<NameToFamily>& fallbackNameToFamilyMap, const SkFontStyle& style, bool elegant, const SkString& langTag, SkUnichar character) { for (int i = 0; i < fallbackNameToFamilyMap.count(); ++i) { SkFontStyleSet_Android* family = fallbackNameToFamilyMap[i].styleSet; sk_sp<SkTypeface_AndroidSystem> face(family->matchStyle(style)); if (!langTag.isEmpty() && !face->fLang.getTag().startsWith(langTag.c_str())) { continue; } if (SkToBool(face->fVariantStyle & kElegant_FontVariant) != elegant) { continue; } SkPaint paint; paint.setTypeface(face); paint.setTextEncoding(SkPaint::kUTF32_TextEncoding); uint16_t glyphID; paint.textToGlyphs(&character, sizeof(character), &glyphID); if (glyphID != 0) { return face; } } return nullptr; }
void TestRunner::render() { // TODO: this doesn't really need to use SkRunnables any more. // We can just write the code to run in the for-loop directly. SkTaskGroup().batch(fRunnables.count(), [&](int i) { fRunnables[i]->run(); }); }
static bool contains_only_moveTo(const SkPath& path) { int verbCount = path.countVerbs(); if (verbCount == 0) { return true; } SkTDArray<uint8_t> verbs; verbs.setCount(verbCount); SkDEBUGCODE(int getVerbResult = ) path.getVerbs(verbs.begin(), verbCount); SkASSERT(getVerbResult == verbCount); for (int index = 0; index < verbCount; ++index) { if (verbs[index] != SkPath::kMove_Verb) { return false; } } return true; }
static void kick_off_gms(const SkTDArray<GMRegistry::Factory>& gms, const SkTArray<SkString>& configs, GrGLStandard gpuAPI, const DM::Expectations& expectations, DM::Reporter* reporter, DM::TaskRunner* tasks) { #define START(name, type, ...) \ if (lowercase(configs[j]).equals(name)) { \ tasks->add(SkNEW_ARGS(DM::type, (name, reporter, tasks, gms[i], ## __VA_ARGS__))); \ } for (int i = 0; i < gms.count(); i++) { for (int j = 0; j < configs.count(); j++) { START("565", CpuGMTask, expectations, kRGB_565_SkColorType); START("8888", CpuGMTask, expectations, kN32_SkColorType); START("gpu", GpuGMTask, expectations, native, gpuAPI, 0); START("msaa4", GpuGMTask, expectations, native, gpuAPI, 4); START("msaa16", GpuGMTask, expectations, native, gpuAPI, 16); START("nvprmsaa4", GpuGMTask, expectations, nvpr, gpuAPI, 4); START("nvprmsaa16", GpuGMTask, expectations, nvpr, gpuAPI, 16); START("gpunull", GpuGMTask, expectations, null, gpuAPI, 0); START("gpudebug", GpuGMTask, expectations, debug, gpuAPI, 0); START("angle", GpuGMTask, expectations, angle, gpuAPI, 0); START("mesa", GpuGMTask, expectations, mesa, gpuAPI, 0); START("pdf", PDFTask, RASTERIZE_PDF_PROC); } } #undef START }
static void convert_layers_to_replacements(const SkTDArray<GrHoistedLayer>& layers, GrReplacements* replacements) { // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer? for (int i = 0; i < layers.count(); ++i) { GrCachedLayer* layer = layers[i].fLayer; const SkPicture* picture = layers[i].fPicture; GrReplacements::ReplacementInfo* layerInfo = replacements->newReplacement(picture->uniqueID(), layer->start(), layers[i].fCTM); layerInfo->fStop = layer->stop(); layerInfo->fPos = layers[i].fOffset; SkBitmap bm; wrap_texture(layers[i].fLayer->texture(), !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().width() : layers[i].fLayer->texture()->width(), !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().height() : layers[i].fLayer->texture()->height(), &bm); layerInfo->fImage = SkImage::NewTexture(bm); layerInfo->fPaint = layers[i].fLayer->paint() ? SkNEW_ARGS(SkPaint, (*layers[i].fLayer->paint())) : NULL; layerInfo->fSrcRect = SkIRect::MakeXYWH(layers[i].fLayer->rect().fLeft, layers[i].fLayer->rect().fTop, layers[i].fLayer->rect().width(), layers[i].fLayer->rect().height()); } }
void DumpLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* label) { if (!FLAGS_verboseFontMgr) { return; } SkDebugf("\n--- Dumping %s\n", label); for (int i = 0; i < fontFamilies.count(); ++i) { SkDebugf("Family %d:\n", i); switch(fontFamilies[i]->fVariant) { case kElegant_FontVariant: SkDebugf(" elegant\n"); break; case kCompact_FontVariant: SkDebugf(" compact\n"); break; default: break; } SkDebugf(" basePath %s\n", fontFamilies[i]->fBasePath.c_str()); if (!fontFamilies[i]->fLanguage.getTag().isEmpty()) { SkDebugf(" language %s\n", fontFamilies[i]->fLanguage.getTag().c_str()); } for (int j = 0; j < fontFamilies[i]->fNames.count(); ++j) { SkDebugf(" name %s\n", fontFamilies[i]->fNames[j].c_str()); } for (int j = 0; j < fontFamilies[i]->fFonts.count(); ++j) { const FontFileInfo& ffi = fontFamilies[i]->fFonts[j]; SkDebugf(" file (%d) %s#%d\n", ffi.fWeight, ffi.fFileName.c_str(), ffi.fIndex); } } SkDebugf("\n\n"); }
static void oneOff(skiatest::Reporter* reporter, size_t x) { const SkDCubic& cubic = locals[x]; const SkPoint skcubic[4] = { {static_cast<float>(cubic[0].fX), static_cast<float>(cubic[0].fY)}, {static_cast<float>(cubic[1].fX), static_cast<float>(cubic[1].fY)}, {static_cast<float>(cubic[2].fX), static_cast<float>(cubic[2].fY)}, {static_cast<float>(cubic[3].fX), static_cast<float>(cubic[3].fY)} }; SkScalar skinflect[2]; int skin = SkFindCubicInflections(skcubic, skinflect); if (false) SkDebugf("%s %d %1.9g\n", __FUNCTION__, skin, skinflect[0]); SkTDArray<SkDQuad> quads; double precision = cubic.calcPrecision(); CubicToQuads(cubic, precision, quads); if (false) SkDebugf("%s quads=%d\n", __FUNCTION__, quads.count()); }
CameraView() { fRX = fRY = fRZ = 0; fShaderIndex = 0; fFrontFace = false; for (int i = 0;; i++) { SkString str; str.printf("/skimages/elephant%d.jpeg", i); SkBitmap bm; if (SkImageDecoder::DecodeFile(str.c_str(), &bm)) { SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); SkRect src = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }; SkRect dst = { -150, -150, 150, 150 }; SkMatrix matrix; matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit); s->setLocalMatrix(matrix); *fShaders.append() = s; } else { break; } } this->setBGColor(0xFFDDDDDD); }
static void kick_off_benches(const SkTDArray<BenchRegistry::Factory>& benches, const SkTArray<SkString>& configs, DM::Reporter* reporter, DM::TaskRunner* tasks) { #define START(name, type, ...) \ if (lowercase(configs[j]).equals(name)) { \ tasks->add(SkNEW_ARGS(DM::type, (name, reporter, tasks, benches[i], ## __VA_ARGS__))); \ } for (int i = 0; i < benches.count(); i++) { for (int j = 0; j < configs.count(); j++) { START("nonrendering", NonRenderingBenchTask); START("565", CpuBenchTask, kRGB_565_SkColorType); START("8888", CpuBenchTask, kN32_SkColorType); START("gpu", GpuBenchTask, native, 0); START("msaa4", GpuBenchTask, native, 4); START("msaa16", GpuBenchTask, native, 16); START("nvprmsaa4", GpuBenchTask, nvpr, 4); START("nvprmsaa16", GpuBenchTask, nvpr, 16); START("gpunull", GpuBenchTask, null, 0); START("gpudebug", GpuBenchTask, debug, 0); START("angle", GpuBenchTask, angle, 0); START("mesa", GpuBenchTask, mesa, 0); } } #undef START }