Proposal: Removing the cache padding

[asturur]

I ll try to do my best to explain the scope of this change it requires having an understanding of how caching work, so please have a read here first:
http://fabricjs.com/fabric-object-caching (of course the interesting part is broken )

Today the cache makes a copy of the object as an image in a temporary canvas so that a series of complex operations can be simplified as a single drawImage.
This is a very simple and common approach that works very well for dragging one or more objects, or panning the canvas.
Now if you scale an object that will become quickly pixellated, when when you end your scaling transformation fabric will update the cache with a new image that is of the correct amount of pixels.
This is the BASE behaviour.

Now while i think that cache scaling is a perfectly good no brain compromise, some apps developer do not think so.
So we have some code in fabricJS that is detecting a scaling operation and that allow you to disable this behaviour

  _updateCacheCanvas() {
    const targetCanvas = this.canvas;
    if (this.noScaleCache && targetCanvas && targetCanvas._currentTransform) {
      const transform = targetCanvas._currentTransform,
        target = transform.target,
        action = transform.action;
      if (
        this === (target as unknown as this) &&
        action &&
        action.startsWith('scale')
      ) {
        return false;
      }
    }
    return super._updateCacheCanvas();
  }

If you read this code it basically says, update the cache but if 'noScaleCache' is true and we are transforming, do it only if is not a scale transformation.

Now in case you want to disable this behavior you would end up with a scale operation trigger hundreds of cache invalidations and redraws, causing a lot of new canvases created and a lot of memory trashing and GC collecting.

So to avoid that when we create a cache canvas we create it a bit larger ( 10% i think ) so that a single canvas has space for more than a single size and you are trashing canvases only once in a while.

( note adds some perf inspection)

Now looking back this doesn't seem a smart choice anymore.
All those handling of specific cases makes the code harder to read and to understand for little gain.

This proposal is to evaluate the following change:

• the cache is built to fit the object size ( respecting the minimal 256px size )
• in noScaleCache is true instead of invalidating the cache during a scale we do stop caching during a scale
• if caching is required because of rendering properties you'll get the performance hit during the scale operation
• the performance difference gets measured and evaluated as part of this proposal ( so needs POC so can be tried on different type of machines and a screenshot )

[asturur]

reserved for screenshots