im trying to zoom in and out the desktop would like some helps thanks

[okcomput3]

i added into Ecompositor.cpp

void ECompositor::setupAutomaticZoom()
{
float minScale = 0.25f; // Adjusted to ensure it doesn't go too small
float maxScale = 5.0f;
bool increaseScale = true; // Direction of scale change

// Increased duration for a smoother transition
UInt32 duration = 1000; // Example: 10 seconds for the complete zoom in and out cycle

LAnimation::oneShot(duration,
    [this, &increaseScale, minScale, maxScale](LAnimation *anim) {
        float currentValue = anim->value(); // Range: 0.0 to 1.0
        float deltaScale = (maxScale - minScale) * currentValue;
        if (increaseScale) {
            // Smoother increase from minScale towards maxScale
            globalScaleFactor = minScale + deltaScale;
        } else {
            // Smoother decrease from maxScale back to minScale
            globalScaleFactor = maxScale - deltaScale;
        }

        // Apply the updated scale factor to your outputs here
        for (LOutput *output : seat()->outputs()) {
            output->setScale(globalScaleFactor);
            output->repaint();
        }
    },
    [this, &increaseScale](LAnimation *) {
        // Toggle the direction of scale change at the end of each animation
        increaseScale = !increaseScale;

        // Restart the animation for a continuous loop
        setupAutomaticZoom(); 
    }
);

}
while it works it goes slow is there any way of making it go fast?

[ehopperdietzel]

It could be slow for two reasons:

1. You're creating a scaled copy of the wallpaper texture each time LOutput::resizeGL() is called, just like the tutorial, which is slow but produces higher quality scaling. Instead, you could keep the texture intact and use LTextureView::setSrcRect() and LTextureView::setDstSize() to crop and scale the wallpaper view as desired without any performance penalty.

2. Louvre uses oversampling by default when using fractional scales, which means it destroys and creates a new framebuffer each time you change the scale. You could disable it while doing the animation with LOutput::enableFractionalOversampling(). This way, everything is scaled and rendered directly to the "screen" framebuffers, making it faster but potentially producing aliasing artifacts.

Instead of changing the output scale, another approach could involve creating a root parent layer view and using LView::setScalingVector(). However, it's important to note that due to precision loss, damage tracking is disabled for all views with a scaling vector other than (1, 1). This can significantly impact performance, so it's advisable to use it exclusively for animations and similar purposes.

[okcomput3]

the 1st works like a charm...it is now smooth thanks