Introduce advanced glyph shapes using smufl cutouts and apply it to accidentals

[mike-spa]

Currently, our layout system (meaning all the collision checks) looks at accidentals like this:

With this PR, we look at accidentals like this:

In score very heavy of accidentals, this may have a small performance cost, because every accidental now is made of more than a single rectangle. However, that cost is basically offset by the gain made with this optimization. Besides, it is exactly in the situation with many accidentals that using cutouts like this can dramatically improve the layout.

This allows smufl cutouts to be used also by any other item that needs them in future.

[igorkorsukov]

I think better move this method to IEngravingFont

[cbjeukendrup]

And when doing that, we might want to cache the Shape calculated by this method, just like we do for the bbox actually

[mike-spa]

I think better move this method to IEngravingFont

Done!

And when doing that, we might want to cache the Shape calculated by this method, just like we do for the bbox actually

I'm not sure I know where or how we would cache that Shape. How would you do this?

[cbjeukendrup]

I'm not sure I know where or how we would cache that Shape. How would you do this?

You would add a new shapeWithCutouts field to the EngravingFont::Sym struct. This will probably need to be mutable.
Then, in EngravingFont::shapeWithCutouts, use const Sym& s = sym(id) to obtain the Sym for that symbol. Check if the shapeWithCutouts is empty; if not, just return it; if yes, then calculate it and store it for the next time, and return it.
You might also need to do some stuff with useFallbackFont(id).

To some extent, EngravingFont::bbox is a good example, except that all bboxes are calculated in advance when the font is loaded, instead of just at the moment that they are needed.

[igorkorsukov]

Maybe we should add method like addAll(const std::vector<RectF>& rects, EngravingItem* item)
then we can do m_elements.reserve to avoid relocated several times

[igorkorsukov]

or we can add method reserve to Shape class :)

[mike-spa]

I made a new Shape constructor for this case :)

[MarcSabatella]

You probably realize this already, but just in case: we do already use cutouts in the stacking algorithm for accidentals within a chord:

MuseScore/src/engraving/rendering/dev/chordlayout.cpp

Lines 2450 to 2468 in cfd3da6

	PointF bboxNE = ac->symBbox(ac->symId()).topRight();
	PointF bboxSW = ac->symBbox(ac->symId()).bottomLeft();
	PointF cutOutNE = ac->symSmuflAnchor(ac->symId(), SmuflAnchorId::cutOutNE);
	PointF cutOutSW = ac->symSmuflAnchor(ac->symId(), SmuflAnchorId::cutOutSW);
	if (!cutOutNE.isNull()) {
	acel.ascent = cutOutNE.y() - bboxNE.y();
	acel.rightClear = bboxNE.x() - cutOutNE.x();
	} else {
	acel.ascent = 0.0;
	acel.rightClear = 0.0;
	}
	if (!cutOutSW.isNull()) {
	acel.descent = bboxSW.y() - cutOutSW.y();
	acel.leftClear = cutOutSW.x() - bboxSW.x();
	} else {
	acel.descent = 0.0;
	acel.leftClear = 0.0;
	}

Also for key signatures:

MuseScore/src/engraving/rendering/dev/tlayout.cpp

Lines 3604 to 3610 in cfd3da6

	SmuflAnchorId currentCutout = isAscending ? SmuflAnchorId::cutOutSW : SmuflAnchorId::cutOutNW;
	SmuflAnchorId previousCutout = isAscending ? SmuflAnchorId::cutOutNE : SmuflAnchorId::cutOutSE;
	PointF cutout = item->symSmuflAnchor(sym, currentCutout);
	double currentCutoutY = line * step + cutout.y();
	double previousCutoutY = previous.line * step + item->symSmuflAnchor(previous.sym, previousCutout).y();
	if ((isAscending && currentCutoutY < previousCutoutY) || (!isAscending && currentCutoutY > previousCutoutY)) {
	x -= cutout.x() / _spatium;

These are the "dev" versions, but the code has been in place a long time - predates autoplace. Perhaps the new shape system could be used here instead of this special casing.

[mike-spa]

@igorkorsukov @cbjeukendrup I've implemented your suggestions. If you think this is good to go, it would be good to merge it before Igor's work on the Shape class, otherwise we get conflicts :)