void GrDebugGL::report() const {
for (int i = 0; i < fObjects.count(); ++i) {
GrAlwaysAssert(0 == fObjects[i]->getRefCount());
GrAlwaysAssert(0 < fObjects[i]->getHighRefCount());
GrAlwaysAssert(fObjects[i]->getDeleted());
}
}
GrFakeRefObj *GrDebugGL::findObject(GrGLuint ID, GrObjTypes type) {
for (int i = 0; i < fObjects.count(); ++i) {
if (fObjects[i]->getID() == ID) { // && fObjects[i]->getType() == type) {
// The application shouldn't be accessing objects
// that (as far as OpenGL knows) were already deleted
GrAlwaysAssert(!fObjects[i]->getDeleted());
GrAlwaysAssert(!fObjects[i]->getMarkedForDeletion());
return fObjects[i];
}
}
return NULL;
}
void test_sampleLocations(skiatest::Reporter* reporter, TestSampleLocationsInterface* testInterface,
GrContext* ctx) {
SkRandom rand;
SkAutoTUnref<GrRenderTarget> bottomUps[numTestPatterns];
SkAutoTUnref<GrRenderTarget> topDowns[numTestPatterns];
for (int i = 0; i < numTestPatterns; ++i) {
int numSamples = (int)kTestPatterns[i].size();
GrAlwaysAssert(numSamples > 1 && SkIsPow2(numSamples));
bottomUps[i].reset(create_render_target(ctx, kBottomLeft_GrSurfaceOrigin,
rand.nextRangeU(1 + numSamples / 2, numSamples)));
topDowns[i].reset(create_render_target(ctx, kTopLeft_GrSurfaceOrigin,
rand.nextRangeU(1 + numSamples / 2, numSamples)));
}
// Ensure all sample locations get queried and/or cached properly.
GrStencilSettings dummyStencil;
for (int repeat = 0; repeat < 2; ++repeat) {
for (int i = 0; i < numTestPatterns; ++i) {
testInterface->overrideSamplePattern(kTestPatterns[i]);
assert_equal(reporter, kTestPatterns[i],
topDowns[i]->renderTargetPriv().getMultisampleSpecs(dummyStencil), false);
assert_equal(reporter, kTestPatterns[i],
bottomUps[i]->renderTargetPriv().getMultisampleSpecs(dummyStencil), true);
}
}
}
void GrFrameBufferObj::setStencil(GrFBBindableObj *buffer) {
if (fStencilBuffer) {
// automatically break the binding of the old buffer
GrAlwaysAssert(fStencilBuffer->getStencilBound(this));
fStencilBuffer->resetStencilBound(this);
GrAlwaysAssert(!fStencilBuffer->getDeleted());
fStencilBuffer->unref();
}
fStencilBuffer = buffer;
if (fStencilBuffer) {
GrAlwaysAssert(!fStencilBuffer->getDeleted());
fStencilBuffer->ref();
GrAlwaysAssert(!fStencilBuffer->getStencilBound(this));
fStencilBuffer->setStencilBound(this);
}
}
void GrDebugGL::useProgram(GrProgramObj *program) {
if (fProgram) {
GrAlwaysAssert(fProgram->getInUse());
fProgram->resetInUse();
GrAlwaysAssert(!fProgram->getDeleted());
fProgram->unref();
}
fProgram = program;
if (fProgram) {
GrAlwaysAssert(!fProgram->getDeleted());
fProgram->ref();
GrAlwaysAssert(!fProgram->getInUse());
fProgram->setInUse();
}
}
void GrDebugGL::setRenderBuffer(GrRenderBufferObj *renderBuffer) {
if (fRenderBuffer) {
GrAlwaysAssert(fRenderBuffer->getBound());
fRenderBuffer->resetBound();
GrAlwaysAssert(!fRenderBuffer->getDeleted());
fRenderBuffer->unref();
}
fRenderBuffer = renderBuffer;
if (fRenderBuffer) {
GrAlwaysAssert(!fRenderBuffer->getDeleted());
fRenderBuffer->ref();
GrAlwaysAssert(!fRenderBuffer->getBound());
fRenderBuffer->setBound();
}
}
void GrDebugGL::setFrameBuffer(GrFrameBufferObj *frameBuffer) {
if (fFrameBuffer) {
GrAlwaysAssert(fFrameBuffer->getBound());
fFrameBuffer->resetBound();
GrAlwaysAssert(!fFrameBuffer->getDeleted());
fFrameBuffer->unref();
}
fFrameBuffer = frameBuffer;
if (fFrameBuffer) {
GrAlwaysAssert(!fFrameBuffer->getDeleted());
fFrameBuffer->ref();
GrAlwaysAssert(!fFrameBuffer->getBound());
fFrameBuffer->setBound();
}
}
void GrDebugGL::setArrayBuffer(GrBufferObj *arrayBuffer) {
if (fArrayBuffer) {
// automatically break the binding of the old buffer
GrAlwaysAssert(fArrayBuffer->getBound());
fArrayBuffer->resetBound();
GrAlwaysAssert(!fArrayBuffer->getDeleted());
fArrayBuffer->unref();
}
fArrayBuffer = arrayBuffer;
if (fArrayBuffer) {
GrAlwaysAssert(!fArrayBuffer->getDeleted());
fArrayBuffer->ref();
GrAlwaysAssert(!fArrayBuffer->getBound());
fArrayBuffer->setBound();
}
}
GLTestSampleLocationsInterface() : fTestContext(sk_gpu_test::CreateDebugGLTestContext()) {
fStandard = fTestContext->gl()->fStandard;
fExtensions = fTestContext->gl()->fExtensions;
fFunctions = fTestContext->gl()->fFunctions;
fFunctions.fGetIntegerv = [&](GrGLenum pname, GrGLint* params) {
GrAlwaysAssert(GR_GL_EFFECTIVE_RASTER_SAMPLES != pname);
if (GR_GL_SAMPLES == pname) {
GrAlwaysAssert(!fSamplePattern.empty());
*params = (int)fSamplePattern.size();
} else {
fTestContext->gl()->fFunctions.fGetIntegerv(pname, params);
}
};
fFunctions.fGetMultisamplefv = [&](GrGLenum pname, GrGLuint index, GrGLfloat* val) {
GrAlwaysAssert(GR_GL_SAMPLE_POSITION == pname);
val[0] = fSamplePattern[index].fX;
val[1] = fSamplePattern[index].fY;
};
}
static void* alloc_vertices(GrDrawTarget* drawTarget,
int numVertices,
bool useColorVerts) {
if (numVertices <= 0) {
return NULL;
}
void* vertices = NULL;
bool success = drawTarget->reserveVertexAndIndexSpace(numVertices,
get_vertex_stride(useColorVerts),
0,
&vertices,
NULL);
GrAlwaysAssert(success);
return vertices;
}
void assert_equal(skiatest::Reporter* reporter, const SamplePattern& pattern,
const GrGpu::MultisampleSpecs& specs, bool flipY) {
GrAlwaysAssert(specs.fSampleLocations);
if ((int)pattern.size() != specs.fEffectiveSampleCnt) {
REPORTER_ASSERT_MESSAGE(reporter, false, "Sample pattern has wrong number of samples.");
return;
}
for (int i = 0; i < specs.fEffectiveSampleCnt; ++i) {
SkPoint expectedLocation = specs.fSampleLocations[i];
if (flipY) {
expectedLocation.fY = 1 - expectedLocation.fY;
}
if (pattern[i] != expectedLocation) {
REPORTER_ASSERT_MESSAGE(reporter, false, "Sample pattern has wrong sample location.");
return;
}
}
}
GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target) {
GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
return GR_GL_FRAMEBUFFER_COMPLETE;
}
void GrTesselatedPathRenderer::drawPathToStencil() {
GrAlwaysAssert(!"multipass stencil should not be needed");
}
std::unique_ptr<GrFragmentProcessor> TwoPointConicalEffect::TestCreate(
GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkPoint center2 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1();
SkScalar radius2 = d->fRandom->nextUScalar1();
constexpr int kTestTypeMask = (1 << 2) - 1,
kTestNativelyFocalBit = (1 << 2),
kTestFocalOnCircleBit = (1 << 3),
kTestSwappedBit = (1 << 4);
// We won't treat isWellDefined and isRadiusIncreasing specially beacuse they
// should have high probability to be turned on and off as we're getting random
// radii and centers.
int mask = d->fRandom->nextU();
int type = mask & kTestTypeMask;
if (type == static_cast<int>(TwoPointConicalEffect::Type::kRadial)) {
center2 = center1;
// Make sure that the radii are different
if (SkScalarNearlyZero(radius1 - radius2)) {
radius2 += .1f;
}
} else if (type == static_cast<int>(TwoPointConicalEffect::Type::kStrip)) {
radius1 = SkTMax(radius1, .1f); // Make sure that the radius is non-zero
radius2 = radius1;
// Make sure that the centers are different
if (SkScalarNearlyZero(SkPoint::Distance(center1, center2))) {
center2.fX += .1f;
}
} else { // kFocal_Type
// Make sure that the centers are different
if (SkScalarNearlyZero(SkPoint::Distance(center1, center2))) {
center2.fX += .1f;
}
if (kTestNativelyFocalBit & mask) {
radius1 = 0;
}
if (kTestFocalOnCircleBit & mask) {
radius2 = radius1 + SkPoint::Distance(center1, center2);
}
if (kTestSwappedBit & mask) {
std::swap(radius1, radius2);
radius2 = 0;
}
// Make sure that the radii are different
if (SkScalarNearlyZero(radius1 - radius2)) {
radius2 += .1f;
}
}
if (SkScalarNearlyZero(radius1 - radius2) &&
SkScalarNearlyZero(SkPoint::Distance(center1, center2))) {
radius2 += .1f; // make sure that we're not degenerated
}
RandomGradientParams params(d->fRandom);
auto shader = params.fUseColors4f ?
SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
params.fColors4f, params.fColorSpace, params.fStops,
params.fColorCount, params.fTileMode) :
SkGradientShader::MakeTwoPointConical(center1, radius1, center2, radius2,
params.fColors, params.fStops,
params.fColorCount, params.fTileMode);
GrTest::TestAsFPArgs asFPArgs(d);
std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
GrAlwaysAssert(fp);
return fp;
}
void GrDistanceFieldTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
GrFixed vx, GrFixed vy,
GrFontScaler* scaler) {
if (NULL == fDrawTarget) {
return;
}
if (NULL == fStrike) {
fStrike = fContext->getFontCache()->getStrike(scaler, true);
}
GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
if (NULL == glyph || glyph->fBounds.isEmpty()) {
return;
}
SkScalar sx = SkFixedToScalar(vx);
SkScalar sy = SkFixedToScalar(vy);
/*
// not valid, need to find a different solution for this
vx += SkIntToFixed(glyph->fBounds.fLeft);
vy += SkIntToFixed(glyph->fBounds.fTop);
// keep them as ints until we've done the clip-test
GrFixed width = glyph->fBounds.width();
GrFixed height = glyph->fBounds.height();
// check if we clipped out
if (true || NULL == glyph->fPlot) {
int x = vx >> 16;
int y = vy >> 16;
if (fClipRect.quickReject(x, y, x + width, y + height)) {
// SkCLZ(3); // so we can set a break-point in the debugger
return;
}
}
*/
if (NULL == glyph->fPlot) {
if (fStrike->getGlyphAtlas(glyph, scaler)) {
goto HAS_ATLAS;
}
// try to clear out an unused plot before we flush
fContext->getFontCache()->freePlotExceptFor(fStrike);
if (fStrike->getGlyphAtlas(glyph, scaler)) {
goto HAS_ATLAS;
}
if (c_DumpFontCache) {
#ifdef SK_DEVELOPER
fContext->getFontCache()->dump();
#endif
}
// before we purge the cache, we must flush any accumulated draws
this->flushGlyphs();
fContext->flush();
// try to purge
fContext->getFontCache()->purgeExceptFor(fStrike);
// need to use new flush count here
if (fStrike->getGlyphAtlas(glyph, scaler)) {
goto HAS_ATLAS;
}
if (NULL == glyph->fPath) {
SkPath* path = SkNEW(SkPath);
if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
// flag the glyph as being dead?
delete path;
return;
}
glyph->fPath = path;
}
GrContext::AutoMatrix am;
SkMatrix translate;
translate.setTranslate(sx, sy);
GrPaint tmpPaint(fPaint);
am.setPreConcat(fContext, translate, &tmpPaint);
SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
fContext->drawPath(tmpPaint, *glyph->fPath, stroke);
return;
}
HAS_ATLAS:
SkASSERT(glyph->fPlot);
GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
glyph->fPlot->setDrawToken(drawToken);
GrTexture* texture = glyph->fPlot->texture();
SkASSERT(texture);
if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
this->flushGlyphs();
fCurrTexture = texture;
fCurrTexture->ref();
}
if (NULL == fVertices) {
// If we need to reserve vertices allow the draw target to suggest
// a number of verts to reserve and whether to perform a flush.
fMaxVertices = kMinRequestedVerts;
fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
SK_ARRAY_COUNT(gTextVertexAttribs));
bool flush = fDrawTarget->geometryHints(&fMaxVertices, NULL);
if (flush) {
this->flushGlyphs();
fContext->flush();
fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
SK_ARRAY_COUNT(gTextVertexAttribs));
}
fMaxVertices = kDefaultRequestedVerts;
// ignore return, no point in flushing again.
fDrawTarget->geometryHints(&fMaxVertices, NULL);
int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->maxQuads();
if (fMaxVertices < kMinRequestedVerts) {
fMaxVertices = kDefaultRequestedVerts;
} else if (fMaxVertices > maxQuadVertices) {
// don't exceed the limit of the index buffer
fMaxVertices = maxQuadVertices;
}
bool success = fDrawTarget->reserveVertexAndIndexSpace(fMaxVertices,
0,
GrTCast<void**>(&fVertices),
NULL);
GrAlwaysAssert(success);
SkASSERT(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize());
}
SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft);
SkScalar dy = SkIntToScalar(glyph->fBounds.fTop);
SkScalar width = SkIntToScalar(glyph->fBounds.width());
SkScalar height = SkIntToScalar(glyph->fBounds.height());
SkScalar scale = fTextRatio;
dx *= scale;
dy *= scale;
sx += dx;
sy += dy;
width *= scale;
height *= scale;
GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX);
GrFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY);
GrFixed tw = SkIntToFixed(glyph->fBounds.width());
GrFixed th = SkIntToFixed(glyph->fBounds.height());
fVertices[2*fCurrVertex].setRectFan(sx,
sy,
sx + width,
sy + height,
2 * sizeof(SkPoint));
fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)),
SkFixedToFloat(texture->normalizeFixedY(ty)),
SkFixedToFloat(texture->normalizeFixedX(tx + tw)),
SkFixedToFloat(texture->normalizeFixedY(ty + th)),
2 * sizeof(SkPoint));
fCurrVertex += 4;
}
void GrBitmapTextContext::drawText(const GrPaint& paint, const SkPaint& skPaint,
const char text[], size_t byteLength,
SkScalar x, SkScalar y) {
SkASSERT(byteLength == 0 || text != NULL);
// nothing to draw
if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
return;
}
this->init(paint, skPaint);
if (NULL == fDrawTarget) {
return;
}
SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
SkAutoGlyphCache autoCache(fSkPaint, &fDeviceProperties, &fContext->getMatrix());
SkGlyphCache* cache = autoCache.getCache();
GrFontScaler* fontScaler = GetGrFontScaler(cache);
if (NULL == fStrike) {
fStrike = fContext->getFontCache()->getStrike(fontScaler, false);
}
// transform our starting point
{
SkPoint loc;
fContext->getMatrix().mapXY(x, y, &loc);
x = loc.fX;
y = loc.fY;
}
// need to measure first
if (fSkPaint.getTextAlign() != SkPaint::kLeft_Align) {
SkVector stop;
MeasureText(cache, glyphCacheProc, text, byteLength, &stop);
SkScalar stopX = stop.fX;
SkScalar stopY = stop.fY;
if (fSkPaint.getTextAlign() == SkPaint::kCenter_Align) {
stopX = SkScalarHalf(stopX);
stopY = SkScalarHalf(stopY);
}
x -= stopX;
y -= stopY;
}
const char* stop = text + byteLength;
// allocate vertices
SkASSERT(NULL == fVertices);
bool useColorVerts = kA8_GrMaskFormat == fStrike->getMaskFormat();
if (useColorVerts) {
fDrawTarget->drawState()->setVertexAttribs<gTextVertexWithColorAttribs>(
SK_ARRAY_COUNT(gTextVertexWithColorAttribs));
} else {
fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>(
SK_ARRAY_COUNT(gTextVertexAttribs));
}
int numGlyphs = fSkPaint.textToGlyphs(text, byteLength, NULL);
bool success = fDrawTarget->reserveVertexAndIndexSpace(4*numGlyphs,
0,
&fVertices,
NULL);
GrAlwaysAssert(success);
SkAutoKern autokern;
SkFixed fxMask = ~0;
SkFixed fyMask = ~0;
SkFixed halfSampleX, halfSampleY;
if (cache->isSubpixel()) {
halfSampleX = halfSampleY = (SK_FixedHalf >> SkGlyph::kSubBits);
SkAxisAlignment baseline = SkComputeAxisAlignmentForHText(fContext->getMatrix());
if (kX_SkAxisAlignment == baseline) {
fyMask = 0;
halfSampleY = SK_FixedHalf;
} else if (kY_SkAxisAlignment == baseline) {
fxMask = 0;
halfSampleX = SK_FixedHalf;
}
} else {
