void SkAnimateMaker::deleteMembers() {
int index;
#if defined SK_DEBUG && 0
//this code checks to see if helpers are among the children, but it is not complete -
//it should check the children of the children
int result;
SkTDArray<SkDisplayable*> children(fChildren.begin(), fChildren.count());
SkQSort(children.begin(), children.count(), sizeof(SkDisplayable*),compare_disp);
for (index = 0; index < fHelpers.count(); index++) {
SkDisplayable* helper = fHelpers[index];
result = SkTSearch(children.begin(), children.count(), helper, sizeof(SkDisplayable*));
SkASSERT(result < 0);
}
#endif
for (index = 0; index < fChildren.count(); index++) {
SkDisplayable* child = fChildren[index];
delete child;
}
for (index = 0; index < fHelpers.count(); index++) {
SkDisplayable* helper = fHelpers[index];
delete helper;
}
for (index = 0; index < fExtras.count(); index++) {
SkExtras* extras = fExtras[index];
delete extras;
}
}
void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo) {
fMSFBOType = kNone_MSFBOType;
if (kDesktop_GrGLBinding != ctxInfo.binding()) {
if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
// chrome's extension is equivalent to the EXT msaa
// and fbo_blit extensions.
fMSFBOType = kDesktopEXT_MSFBOType;
} else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {
fMSFBOType = kAppleES_MSFBOType;
}
} else {
if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||
ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
fMSFBOType = GrGLCaps::kDesktopARB_MSFBOType;
} else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&
ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {
fMSFBOType = GrGLCaps::kDesktopEXT_MSFBOType;
}
// TODO: We could populate fMSAACoverageModes using GetInternalformativ
// on GL 4.2+. It's format-specific, though. See also
// http://code.google.com/p/skia/issues/detail?id=470 about using actual
// rather than requested sample counts in cache key.
if (ctxInfo.hasExtension("GL_NV_framebuffer_multisample_coverage")) {
fCoverageAAType = kNVDesktop_CoverageAAType;
GrGLint count;
GR_GL_GetIntegerv(ctxInfo.interface(),
GR_GL_MAX_MULTISAMPLE_COVERAGE_MODES,
&count);
fMSAACoverageModes.setCount(count);
GR_GL_GetIntegerv(ctxInfo.interface(),
GR_GL_MULTISAMPLE_COVERAGE_MODES,
(int*)&fMSAACoverageModes[0]);
// The NV driver seems to return the modes already sorted but the
// spec doesn't require this. So we sort.
SkQSortCompareProc compareProc =
reinterpret_cast<SkQSortCompareProc>(&coverage_mode_compare);
SkQSort(&fMSAACoverageModes[0],
count,
sizeof(MSAACoverageMode),
compareProc);
}
}
if (kNone_MSFBOType != fMSFBOType) {
GR_GL_GetIntegerv(ctxInfo.interface(),
GR_GL_MAX_SAMPLES,
&fMaxSampleCount);
}
}
void SkQSort_UnitTest()
{
#ifdef SK_SUPPORT_UNITTEST
int array[100];
SkRandom rand;
for (int i = 0; i < 1000; i++)
{
int j, count = rand.nextRangeU(1, SK_ARRAY_COUNT(array));
for (j = 0; j < count; j++)
array[j] = rand.nextS() & 0xFF;
SkQSort(array, count, sizeof(int), compare_int);
for (j = 1; j < count; j++)
SkASSERT(array[j-1] <= array[j]);
}
#endif
}
int SkRTree::distributeChildren(Branch* children) {
// We have two sides to sort by on each of two axes:
const static SortSide sorts[2][2] = {
{&SkIRect::fLeft, &SkIRect::fRight},
{&SkIRect::fTop, &SkIRect::fBottom}
};
// We want to choose an axis to split on, then a distribution along that axis; we'll need
// three pieces of info: the split axis, the side to sort by on that axis, and the index
// to split the sorted array on.
int32_t sortSide = -1;
int32_t k = -1;
int32_t axis = -1;
int32_t bestS = SK_MaxS32;
// Evaluate each axis, we want the min summed margin-value (s) over all distributions
for (int i = 0; i < 2; ++i) {
int32_t minOverlap = SK_MaxS32;
int32_t minArea = SK_MaxS32;
int32_t axisBestK = 0;
int32_t axisBestSide = 0;
int32_t s = 0;
// Evaluate each sort
for (int j = 0; j < 2; ++j) {
SkQSort(sorts[i][j], children, children + fMaxChildren, &RectLessThan);
// Evaluate each split index
for (int32_t k = 1; k <= fMaxChildren - 2 * fMinChildren + 2; ++k) {
SkIRect r1 = children[0].fBounds;
SkIRect r2 = children[fMinChildren + k - 1].fBounds;
for (int32_t l = 1; l < fMinChildren - 1 + k; ++l) {
join_no_empty_check(children[l].fBounds, &r1);
}
for (int32_t l = fMinChildren + k; l < fMaxChildren + 1; ++l) {
join_no_empty_check(children[l].fBounds, &r2);
}
int32_t area = get_area(r1) + get_area(r2);
int32_t overlap = get_overlap(r1, r2);
s += get_margin(r1) + get_margin(r2);
if (overlap < minOverlap || (overlap == minOverlap && area < minArea)) {
minOverlap = overlap;
minArea = area;
axisBestSide = j;
axisBestK = k;
}
}
}
if (s < bestS) {
bestS = s;
axis = i;
sortSide = axisBestSide;
k = axisBestK;
}
}
// replicate the sort of the winning distribution, (we can skip this if the last
// sort ended up being best)
if (!(axis == 1 && sortSide == 1)) {
SkQSort(sorts[axis][sortSide], children, children + fMaxChildren, &RectLessThan);
}
return fMinChildren - 1 + k;
}