void* GrMemoryPool::allocate(size_t size) { VALIDATE; size += kPerAllocPad; size = GrSizeAlignUp(size, kAlignment); if (fTail->fFreeSize < size) { size_t blockSize = size; blockSize = SkTMax<size_t>(blockSize, fMinAllocSize); BlockHeader* block = CreateBlock(blockSize); block->fPrev = fTail; block->fNext = nullptr; SkASSERT(nullptr == fTail->fNext); fTail->fNext = block; fTail = block; fSize += block->fSize; SkDEBUGCODE(++fAllocBlockCnt); } SkASSERT(kAssignedMarker == fTail->fBlockSentinal); SkASSERT(fTail->fFreeSize >= size); intptr_t ptr = fTail->fCurrPtr; // We stash a pointer to the block header, just before the allocated space, // so that we can decrement the live count on delete in constant time. AllocHeader* allocData = reinterpret_cast<AllocHeader*>(ptr); SkDEBUGCODE(allocData->fSentinal = kAssignedMarker); allocData->fHeader = fTail; ptr += kPerAllocPad; fTail->fPrevPtr = fTail->fCurrPtr; fTail->fCurrPtr += size; fTail->fFreeSize -= size; fTail->fLiveCount += 1; SkDEBUGCODE(++fAllocationCnt); VALIDATE; return reinterpret_cast<void*>(ptr); }
// please keep in sync with debugMergeMatches() // Look to see if pt-t linked list contains same segment more than once // if so, and if each pt-t is directly pointed to by spans in that segment, // merge them // keep the points, but remove spans so that the segment doesn't have 2 or more // spans pointing to the same pt-t loop at different loop elements void SkOpSpanBase::mergeMatches(SkOpSpanBase* opp) { SkOpPtT* test = &fPtT; SkOpPtT* testNext; const SkOpPtT* stop = test; do { testNext = test->next(); if (test->deleted()) { continue; } SkOpSpanBase* testBase = test->span(); SkASSERT(testBase->ptT() == test); SkOpSegment* segment = test->segment(); if (segment->done()) { continue; } SkOpPtT* inner = opp->ptT(); const SkOpPtT* innerStop = inner; do { if (inner->segment() != segment) { continue; } if (inner->deleted()) { continue; } SkOpSpanBase* innerBase = inner->span(); SkASSERT(innerBase->ptT() == inner); // when the intersection is first detected, the span base is marked if there are // more than one point in the intersection. if (!zero_or_one(inner->fT)) { innerBase->upCast()->release(test); } else { SkOPASSERT(inner->fT != test->fT); if (!zero_or_one(test->fT)) { testBase->upCast()->release(inner); } else { segment->markAllDone(); // mark segment as collapsed SkDEBUGCODE(testBase->debugSetDeleted()); test->setDeleted(); SkDEBUGCODE(innerBase->debugSetDeleted()); inner->setDeleted(); } } #ifdef SK_DEBUG // assert if another undeleted entry points to segment const SkOpPtT* debugInner = inner; while ((debugInner = debugInner->next()) != innerStop) { if (debugInner->segment() != segment) { continue; } if (debugInner->deleted()) { continue; } SkOPASSERT(0); } #endif break; } while ((inner = inner->next()) != innerStop); } while ((test = testNext) != stop); this->checkForCollapsedCoincidence(); }
void SkOpSpanBase::initBase(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) { fSegment = segment; fPtT.init(this, t, pt, false); fCoinEnd = this; fFromAngle = nullptr; fPrev = prev; fSpanAdds = 0; fAligned = true; fChased = false; SkDEBUGCODE(fCount = 1); SkDEBUGCODE(fID = globalState()->nextSpanID()); SkDEBUGCODE(fDebugDeleted = false); }
GrDrawOp::RequiresDstTexture GrSimpleMeshDrawOpHelper::xpRequiresDstTexture( const GrCaps& caps, const GrAppliedClip* clip, GrProcessorAnalysisCoverage geometryCoverage, GrProcessorAnalysisColor* geometryColor) { SkDEBUGCODE(fDidAnalysis = true); GrProcessorSet::Analysis analysis; if (fProcessors) { GrProcessorAnalysisCoverage coverage = geometryCoverage; if (GrProcessorAnalysisCoverage::kNone == coverage) { coverage = clip->clipCoverageFragmentProcessor() ? GrProcessorAnalysisCoverage::kSingleChannel : GrProcessorAnalysisCoverage::kNone; } bool isMixedSamples = this->aaType() == GrAAType::kMixedSamples; GrColor overrideColor; analysis = fProcessors->finalize(*geometryColor, coverage, clip, isMixedSamples, caps, &overrideColor); if (analysis.inputColorIsOverridden()) { *geometryColor = overrideColor; } } else { analysis = GrProcessorSet::EmptySetAnalysis(); } fRequiresDstTexture = analysis.requiresDstTexture(); fUsesLocalCoords = analysis.usesLocalCoords(); fCompatibleWithAlphaAsCoveage = analysis.isCompatibleWithCoverageAsAlpha(); return analysis.requiresDstTexture() ? GrDrawOp::RequiresDstTexture::kYes : GrDrawOp::RequiresDstTexture::kNo; }
// Writes the path data key into the passed pointer. static void write_path_key_from_data(const SkPath& path, uint32_t* origKey) { uint32_t* key = origKey; // The check below should take care of negative values casted positive. const int verbCnt = path.countVerbs(); const int pointCnt = path.countPoints(); const int conicWeightCnt = SkPathPriv::ConicWeightCnt(path); SkASSERT(verbCnt <= GrShape::kMaxKeyFromDataVerbCnt); SkASSERT(pointCnt && verbCnt); *key++ = path.getFillType(); *key++ = verbCnt; memcpy(key, SkPathPriv::VerbData(path), verbCnt * sizeof(uint8_t)); int verbKeySize = SkAlign4(verbCnt); // pad out to uint32_t alignment using value that will stand out when debugging. uint8_t* pad = reinterpret_cast<uint8_t*>(key)+ verbCnt; memset(pad, 0xDE, verbKeySize - verbCnt); key += verbKeySize >> 2; memcpy(key, SkPathPriv::PointData(path), sizeof(SkPoint) * pointCnt); GR_STATIC_ASSERT(sizeof(SkPoint) == 2 * sizeof(uint32_t)); key += 2 * pointCnt; sk_careful_memcpy(key, SkPathPriv::ConicWeightData(path), sizeof(SkScalar) * conicWeightCnt); GR_STATIC_ASSERT(sizeof(SkScalar) == sizeof(uint32_t)); SkDEBUGCODE(key += conicWeightCnt); SkASSERT(key - origKey == path_key_from_data_size(path)); }
GrDrawTarget::~GrDrawTarget() { SkASSERT(1 == fGeoSrcStateStack.count()); SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back()); SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc); SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc); fDrawState->unref(); }
virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(PerGlyphInfo, const uint32_t*, uint32_t) const override { SkDEBUGCODE(SkDebugf("SkCairoFTTypeface::onGetAdvancedTypefaceMetrics unimplemented\n")); return NULL; }
void SkPictureData::WriteFactories(SkWStream* stream, const SkFactorySet& rec) { int count = rec.count(); SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count); SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get(); rec.copyToArray(array); size_t size = compute_chunk_size(array, count); // TODO: write_tag_size should really take a size_t write_tag_size(stream, SK_PICT_FACTORY_TAG, (uint32_t) size); SkDEBUGCODE(size_t start = stream->bytesWritten()); stream->write32(count); for (int i = 0; i < count; i++) { const char* name = SkFlattenable::FactoryToName(array[i]); if (nullptr == name || 0 == *name) { stream->writePackedUInt(0); } else { size_t len = strlen(name); stream->writePackedUInt(len); stream->write(name, len); } } SkASSERT(size == (stream->bytesWritten() - start)); }
void SkOpSpan::release(const SkOpPtT* kept) { SkDEBUGCODE(fDebugDeleted = true); SkOPASSERT(kept->span() != this); SkASSERT(!final()); SkOpSpan* prev = this->prev(); SkASSERT(prev); SkOpSpanBase* next = this->next(); SkASSERT(next); prev->setNext(next); next->setPrev(prev); this->segment()->release(this); SkOpCoincidence* coincidence = this->globalState()->coincidence(); if (coincidence) { coincidence->fixUp(this->ptT(), kept); } this->ptT()->setDeleted(); SkOpPtT* stopPtT = this->ptT(); SkOpPtT* testPtT = stopPtT; const SkOpSpanBase* keptSpan = kept->span(); do { if (this == testPtT->span()) { testPtT->setSpan(keptSpan); } } while ((testPtT = testPtT->next()) != stopPtT); }
void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location, GrGLenum genMode, GrGLint components, const SkMatrix& matrix) { float coefficients[3 * 3]; SkASSERT(components >= 1 && components <= 3); coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]); coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]); coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]); if (components >= 2) { coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]); coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]); coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]); } if (components >= 3) { coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]); coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]); coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]); } SkDEBUGCODE(verify_floats(coefficients, components * 3)); GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coefficients)); }
GrGpuResource::GrGpuResource(GrGpu* gpu, LifeCycle lifeCycle) : fGpu(gpu) , fGpuMemorySize(kInvalidGpuMemorySize) , fLifeCycle(lifeCycle) , fUniqueID(CreateUniqueID()) { SkDEBUGCODE(fCacheArrayIndex = -1); }
GrMemoryPool::GrMemoryPool(size_t preallocSize, size_t minAllocSize) { SkDEBUGCODE(fAllocationCnt = 0); SkDEBUGCODE(fAllocBlockCnt = 0); minAllocSize = SkTMax<size_t>(minAllocSize, 1 << 10); fMinAllocSize = GrSizeAlignUp(minAllocSize + kPerAllocPad, kAlignment); fPreallocSize = GrSizeAlignUp(preallocSize + kPerAllocPad, kAlignment); fPreallocSize = SkTMax(fPreallocSize, fMinAllocSize); fSize = 0; fHead = CreateBlock(fPreallocSize); fTail = fHead; fHead->fNext = nullptr; fHead->fPrev = nullptr; VALIDATE; };
// see parallel routine in line quadratic intersections int intersectRay(double roots[3]) { double adj = fLine[1].fX - fLine[0].fX; double opp = fLine[1].fY - fLine[0].fY; SkDCubic c; SkDEBUGCODE(c.fDebugGlobalState = fIntersections->globalState()); for (int n = 0; n < 4; ++n) { c[n].fX = (fCubic[n].fY - fLine[0].fY) * adj - (fCubic[n].fX - fLine[0].fX) * opp; } double A, B, C, D; SkDCubic::Coefficients(&c[0].fX, &A, &B, &C, &D); int count = SkDCubic::RootsValidT(A, B, C, D, roots); for (int index = 0; index < count; ++index) { SkDPoint calcPt = c.ptAtT(roots[index]); if (!approximately_zero(calcPt.fX)) { for (int n = 0; n < 4; ++n) { c[n].fY = (fCubic[n].fY - fLine[0].fY) * opp + (fCubic[n].fX - fLine[0].fX) * adj; } double extremeTs[6]; int extrema = SkDCubic::FindExtrema(&c[0].fX, extremeTs); count = c.searchRoots(extremeTs, extrema, 0, SkDCubic::kXAxis, roots); break; } } return count; }
void GrCCPathParser::parsePath(const SkPath& path, const SkPoint* deviceSpacePts) { SkASSERT(!fInstanceBuffer); // Can't call after finalize(). SkASSERT(!fParsingPath); // Call saveParsedPath() or discardParsedPath() for the last one first. SkDEBUGCODE(fParsingPath = true); SkASSERT(path.isEmpty() || deviceSpacePts); fCurrPathPointsIdx = fGeometry.points().count(); fCurrPathVerbsIdx = fGeometry.verbs().count(); fCurrPathPrimitiveCounts = PrimitiveTallies(); fGeometry.beginPath(); if (path.isEmpty()) { return; } const float* conicWeights = SkPathPriv::ConicWeightData(path); int ptsIdx = 0; int conicWeightsIdx = 0; bool insideContour = false; for (SkPath::Verb verb : SkPathPriv::Verbs(path)) { switch (verb) { case SkPath::kMove_Verb: this->endContourIfNeeded(insideContour); fGeometry.beginContour(deviceSpacePts[ptsIdx]); ++ptsIdx; insideContour = true; continue; case SkPath::kClose_Verb: this->endContourIfNeeded(insideContour); insideContour = false; continue; case SkPath::kLine_Verb: fGeometry.lineTo(&deviceSpacePts[ptsIdx - 1]); ++ptsIdx; continue; case SkPath::kQuad_Verb: fGeometry.quadraticTo(&deviceSpacePts[ptsIdx - 1]); ptsIdx += 2; continue; case SkPath::kCubic_Verb: fGeometry.cubicTo(&deviceSpacePts[ptsIdx - 1]); ptsIdx += 3; continue; case SkPath::kConic_Verb: fGeometry.conicTo(&deviceSpacePts[ptsIdx - 1], conicWeights[conicWeightsIdx]); ptsIdx += 2; ++conicWeightsIdx; continue; default: SK_ABORT("Unexpected path verb."); } } SkASSERT(ptsIdx == path.countPoints()); SkASSERT(conicWeightsIdx == SkPathPriv::ConicWeightCnt(path)); this->endContourIfNeeded(insideContour); }
SkRTree::Node* SkRTree::allocateNodeAtLevel(uint16_t level) { SkDEBUGCODE(Node* p = fNodes.begin()); Node* out = fNodes.push(); SkASSERT(fNodes.begin() == p); // If this fails, we didn't setReserve() enough. out->fNumChildren = 0; out->fLevel = level; return out; }
static bool get_packed_glyph_df_image(SkGlyphCache* cache, const SkGlyph& glyph, int width, int height, void* dst) { SkASSERT(glyph.fWidth + 2*SK_DistanceFieldPad == width); SkASSERT(glyph.fHeight + 2*SK_DistanceFieldPad == height); #ifndef SK_USE_LEGACY_DISTANCE_FIELDS const SkPath* path = cache->findPath(glyph); if (nullptr == path) { return false; } SkDEBUGCODE(SkRect glyphBounds = SkRect::MakeXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight)); SkASSERT(glyphBounds.contains(path->getBounds())); // now generate the distance field SkASSERT(dst); SkMatrix drawMatrix; drawMatrix.setTranslate((SkScalar)-glyph.fLeft, (SkScalar)-glyph.fTop); // Generate signed distance field directly from SkPath bool succeed = GrGenerateDistanceFieldFromPath((unsigned char*)dst, *path, drawMatrix, width, height, width * sizeof(unsigned char)); if (!succeed) { #endif const void* image = cache->findImage(glyph); if (nullptr == image) { return false; } // now generate the distance field SkASSERT(dst); SkMask::Format maskFormat = static_cast<SkMask::Format>(glyph.fMaskFormat); if (SkMask::kA8_Format == maskFormat) { // make the distance field from the image SkGenerateDistanceFieldFromA8Image((unsigned char*)dst, (unsigned char*)image, glyph.fWidth, glyph.fHeight, glyph.rowBytes()); } else if (SkMask::kBW_Format == maskFormat) { // make the distance field from the image SkGenerateDistanceFieldFromBWImage((unsigned char*)dst, (unsigned char*)image, glyph.fWidth, glyph.fHeight, glyph.rowBytes()); } else { return false; } #ifndef SK_USE_LEGACY_DISTANCE_FIELDS } #endif return true; }
sk_sp<SkPDFFont> SkPDFFont::GetFontResource(SkPDFCanon* canon, SkTypeface* face, SkGlyphID glyphID) { SkASSERT(canon); SkASSERT(face); // All SkPDFDevice::internalDrawText ensures this. const SkAdvancedTypefaceMetrics* fontMetrics = SkPDFFont::GetMetrics(face, canon); SkASSERT(fontMetrics); // SkPDFDevice::internalDrawText ensures the typeface is good. // GetMetrics only returns null to signify a bad typeface. const SkAdvancedTypefaceMetrics& metrics = *fontMetrics; SkAdvancedTypefaceMetrics::FontType type = SkPDFFont::FontType(metrics); bool multibyte = SkPDFFont::IsMultiByte(type); SkGlyphID subsetCode = multibyte ? 0 : first_nonzero_glyph_for_single_byte_encoding(glyphID); uint64_t fontID = (static_cast<uint64_t>(SkTypeface::UniqueID(face)) << 16) | subsetCode; if (sk_sp<SkPDFFont>* found = canon->fFontMap.find(fontID)) { SkDEBUGCODE(SkPDFFont* foundFont = found->get()); SkASSERT(foundFont && multibyte == foundFont->multiByteGlyphs()); return *found; } sk_sp<SkTypeface> typeface(sk_ref_sp(face)); SkASSERT(typeface); SkGlyphID lastGlyph = SkToU16(typeface->countGlyphs() - 1); // should be caught by SkPDFDevice::internalDrawText SkASSERT(glyphID <= lastGlyph); SkGlyphID firstNonZeroGlyph; if (multibyte) { firstNonZeroGlyph = 1; } else { firstNonZeroGlyph = subsetCode; lastGlyph = SkToU16(SkTMin<int>((int)lastGlyph, 254 + (int)subsetCode)); } SkPDFFont::Info info = {std::move(typeface), firstNonZeroGlyph, lastGlyph, type}; sk_sp<SkPDFFont> font; switch (type) { case SkAdvancedTypefaceMetrics::kType1CID_Font: case SkAdvancedTypefaceMetrics::kTrueType_Font: SkASSERT(multibyte); font = sk_make_sp<SkPDFType0Font>(std::move(info), metrics); break; case SkAdvancedTypefaceMetrics::kType1_Font: SkASSERT(!multibyte); font = sk_make_sp<SkPDFType1Font>(std::move(info), metrics, canon); break; default: SkASSERT(!multibyte); // Type3 is our fallback font. font = sk_make_sp<SkPDFType3Font>(std::move(info), metrics); break; } canon->fFontMap.set(fontID, font); return font; }
static void testop(const SkIRect& r0, const SkIRect& r1, SkRegion::Op op, const SkIRect& expectedR) { SkAAClip c0, c1, c2; c0.setRect(r0); c1.setRect(r1); c2.op(c0, c1, op); SkDEBUGCODE(SkIRect r2 = c2.getBounds()); SkASSERT(r2 == expectedR); }
static SkString map_flags_to_string(uint32_t flags) { SkString str; if (GrCaps::kNone_MapFlags == flags) { str = "none"; } else { SkASSERT(GrCaps::kCanMap_MapFlag & flags); SkDEBUGCODE(flags &= ~GrCaps::kCanMap_MapFlag); str = "can_map"; if (GrCaps::kSubset_MapFlag & flags) { str.append(" partial"); } else { str.append(" full"); } SkDEBUGCODE(flags &= ~GrCaps::kSubset_MapFlag); } SkASSERT(0 == flags); // Make sure we handled all the flags. return str; }
void SkOpPtT::init(SkOpSpanBase* span, double t, const SkPoint& pt, bool duplicate) { fT = t; fPt = pt; fSpan = span; fNext = this; fDuplicatePt = duplicate; fDeleted = false; fCoincident = false; SkDEBUGCODE(fID = span->globalState()->nextPtTID()); }
static bool initSystemFontsLocked() { if( !createFontManager() ) { return false; } getInstance()->initSystemFontsLocked(); SkDEBUGCODE( dumpGlobalsLocked() ); return true; }
virtual void onDraw(int loops, SkCanvas* canvas) { SkDEBUGCODE(this->validateBounds(canvas)); SkPaint paint; this->setupPaint(&paint); for (int i = 0; i < N; i++) { SkRect current; setRectangle(current, i); for (int j = 0; j < loops * gmailScrollingRectSpec[i*3]; j++) { canvas->drawRect(current, paint); } } }
void GrCCFillGeometry::beginContour(const SkPoint& pt) { SkASSERT(!fBuildingContour); // Store the current verb count in the fTriangles field for now. When we close the contour we // will use this value to calculate the actual number of triangles in its fan. fCurrContourTallies = {fVerbs.count(), 0, 0, 0, 0}; fPoints.push_back(pt); fVerbs.push_back(Verb::kBeginContour); fCurrAnchorPoint = pt; SkDEBUGCODE(fBuildingContour = true); }
void SkInterpolatorBase::reset(int elemCount, int frameCount) { fFlags = 0; fElemCount = SkToU8(elemCount); fFrameCount = SkToS16(frameCount); fRepeat = SK_Scalar1; if (fStorage) { sk_free(fStorage); fStorage = NULL; fTimes = NULL; SkDEBUGCODE(fTimesArray = NULL); } }
void GrMemoryPool::release(void* p) { VALIDATE; intptr_t ptr = reinterpret_cast<intptr_t>(p) - kPerAllocPad; AllocHeader* allocData = reinterpret_cast<AllocHeader*>(ptr); SkASSERT(kAssignedMarker == allocData->fSentinal); SkDEBUGCODE(allocData->fSentinal = kFreedMarker); BlockHeader* block = allocData->fHeader; SkASSERT(kAssignedMarker == block->fBlockSentinal); if (1 == block->fLiveCount) { // the head block is special, it is reset rather than deleted if (fHead == block) { fHead->fCurrPtr = reinterpret_cast<intptr_t>(fHead) + kHeaderSize; fHead->fLiveCount = 0; fHead->fFreeSize = fPreallocSize; } else { BlockHeader* prev = block->fPrev; BlockHeader* next = block->fNext; SkASSERT(prev); prev->fNext = next; if (next) { next->fPrev = prev; } else { SkASSERT(fTail == block); fTail = prev; } fSize -= block->fSize; DeleteBlock(block); SkDEBUGCODE(fAllocBlockCnt--); } } else { --block->fLiveCount; // Trivial reclaim: if we're releasing the most recent allocation, reuse it if (block->fPrevPtr == ptr) { block->fFreeSize += (block->fCurrPtr - block->fPrevPtr); block->fCurrPtr = block->fPrevPtr; } } SkDEBUGCODE(--fAllocationCnt); VALIDATE; }
int intersect() { this->addExactEndPoints(); if (fAllowNear) { this->addNearEndPoints(); } double rootVals[2]; int roots = this->intersectRay(rootVals); for (int index = 0; index < roots; ++index) { double conicT = rootVals[index]; double lineT = this->findLineT(conicT); SkDEBUGCODE(SkDPoint conicPt = fConic.ptAtT(conicT)); SkDEBUGCODE(SkDPoint linePt = fLine->ptAtT(lineT)); SkASSERT(conicPt.approximatelyEqual(linePt)); SkDPoint pt; if (this->pinTs(&conicT, &lineT, &pt, kPointUninitialized) && this->uniqueAnswer(conicT, pt)) { fIntersections->insert(conicT, lineT, pt); } } this->checkCoincident(); return fIntersections->used(); }
void GrGLPath::InitPathObjectPathData(GrGLGpu* gpu, GrGLuint pathID, const SkPath& skPath) { SkASSERT(!skPath.isEmpty()); #ifdef SK_SCALAR_IS_FLOAT // This branch does type punning, converting SkPoint* to GrGLfloat*. if ((skPath.getSegmentMasks() & SkPath::kConic_SegmentMask) == 0) { int verbCnt = skPath.countVerbs(); int pointCnt = skPath.countPoints(); int coordCnt = pointCnt * 2; SkSTArray<16, GrGLubyte, true> pathCommands(verbCnt); SkSTArray<16, GrGLfloat, true> pathCoords(coordCnt); static_assert(sizeof(SkPoint) == sizeof(GrGLfloat) * 2, "sk_point_not_two_floats"); pathCommands.resize_back(verbCnt); pathCoords.resize_back(coordCnt); skPath.getPoints(reinterpret_cast<SkPoint*>(&pathCoords[0]), pointCnt); skPath.getVerbs(&pathCommands[0], verbCnt); SkDEBUGCODE(int verbCoordCnt = 0); for (int i = 0; i < verbCnt; ++i) { SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]); pathCommands[i] = verb_to_gl_path_cmd(v); SkDEBUGCODE(verbCoordCnt += num_coords(v)); } SkASSERT(verbCnt == pathCommands.count()); SkASSERT(verbCoordCnt == pathCoords.count()); SkDEBUGCODE(verify_floats(&pathCoords[0], pathCoords.count())); GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0], pathCoords.count(), GR_GL_FLOAT, &pathCoords[0])); return; } #endif SkAssertResult(init_path_object_for_general_path<false>(gpu, pathID, skPath)); }
GrMemoryPool::BlockHeader* GrMemoryPool::CreateBlock(size_t size) { size_t paddedSize = size + kHeaderSize; BlockHeader* block = reinterpret_cast<BlockHeader*>(sk_malloc_throw(paddedSize)); // we assume malloc gives us aligned memory SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment)); SkDEBUGCODE(block->fBlockSentinal = kAssignedMarker); block->fLiveCount = 0; block->fFreeSize = size; block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize; block->fPrevPtr = 0; // gcc warns on assigning nullptr to an intptr_t. block->fSize = paddedSize; return block; }
void SkOpCoincidence::add(SkOpPtT* coinPtTStart, SkOpPtT* coinPtTEnd, SkOpPtT* oppPtTStart, SkOpPtT* oppPtTEnd, SkChunkAlloc* allocator) { SkASSERT(coinPtTStart->fT < coinPtTEnd->fT); bool flipped = oppPtTStart->fT > oppPtTEnd->fT; SkCoincidentSpans* coinRec = SkOpTAllocator<SkCoincidentSpans>::Allocate(allocator); coinRec->fNext = this->fHead; coinRec->fCoinPtTStart = coinPtTStart; coinRec->fCoinPtTEnd = coinPtTEnd; coinRec->fOppPtTStart = oppPtTStart; coinRec->fOppPtTEnd = oppPtTEnd; coinRec->fFlipped = flipped; SkDEBUGCODE(coinRec->fID = fDebugState->nextCoinID()); this->fHead = coinRec; }
GrSimpleMeshDrawOpHelper::GrSimpleMeshDrawOpHelper(const MakeArgs& args, GrAAType aaType, Flags flags) : fProcessors(args.fProcessorSet) , fPipelineFlags(args.fSRGBFlags) , fAAType((int)aaType) , fRequiresDstTexture(false) , fUsesLocalCoords(false) , fCompatibleWithAlphaAsCoveage(false) { SkDEBUGCODE(fDidAnalysis = false); if (GrAATypeIsHW(aaType)) { fPipelineFlags |= GrPipeline::kHWAntialias_Flag; } if (flags & Flags::kSnapVerticesToPixelCenters) { fPipelineFlags |= GrPipeline::kSnapVerticesToPixelCenters_Flag; } }