Texture Expansion Behavior in setBufferScale Function

[okcomput3]

Hi, I've noticed that when using setBufferScale, the texture expansion seems to occur only towards the right and bottom sides, with the top left corner remaining stationary at coordinates (0,0). I'm wondering if it's feasible to modify this behavior so that texture expansion can occur from any corner or even in between at certain points?

[ehopperdietzel]

First of all, the purpose of LTextureView::setBufferScale() is not what I think you are assuming. This is used to indicate, for example, whether the texture is lowDPI (e.g., scale = 1) or hiDPI (e.g., scale = 2) to display it correctly on various screens (more info). To change its size, I recommend using LTextureView::setDstSize(). Returning to your question, the origin of the views is always the top-left corner, but you can easily achieve what you want. For instance, if you want to enlarge it from its center, simply use:

view.enableDstSize(true);
view.setDstSize(newSize);
view.setPos(view.nativePos() - newSize / 2);

Now, I may have misunderstood you, perhaps what you want is to crop the texture and use only a sub-rectangle of it, for that, you should use LTextureView::setSrcRect(). But keep in mind that it is disabled by default (the entire texture is used as src), to make it work, you need to use LTextureView::enableSrcRect().

[okcomput3]

oh yeah it was output->setScale(globalScaleFactor); which was doing the zooming not setBufferScale so how would i use view.enableDstSize(true);
view.setDstSize(globalScaleFactor));
view.setPos(view.nativePos() - globalScaleFactor / 2);
say if i have it in void EOutput::updateWallpaper() how would i get to update and render the screen, at the moment it does change the initial sizes but it doesn`t seen to update after that?

[ehopperdietzel]

I'm not entirely clear on your intentions. Could you please provide more details or elaborate on what you are trying to achieve?

[okcomput3]

im zooming in and out of the desktop it works for the first desktop but i can also side scroll up and also down right left to different desktops which works, but as for zooming into different desktop say in 4x4 grid that i have setup i can`t control the scaling so it wouldnt work for zooming into other desktops as i am using output->setScale for zooming in and out, where as i think i should be using view.enableDstSize(true); view.setDstSize(newSize); view.setPos(view.nativePos() - newSize / 2);

void ECompositor::setupAutomaticZoom()
{
float minScale = 0.25f; // Adjusted to ensure it doesn't go too small
float maxScale = 1.0f;

// Increased duration for a smoother transition
UInt32 duration = 5000; // 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(); 
    }
);

}

[okcomput3]

as i have put the code in updateWallpaper() for arrangement of desktops do i just need to keep calling updateWallpaper() which has the code

view.enableDstSize(true); view.setDstSize(globalScaleFactor); view.setPos(view.nativePos() - globalScaleFactor / 2);

updateWallpaper() which just now it only gets called in the init function just now in EOutput and then not use output->setScale(globalScaleFactor); in ECompositor::setupAutomaticZoom()

[ehopperdietzel]

Are you trying to do something like this ? And then zoom in into a specific workspace?

[ehopperdietzel]

Also, when you say desktop, do you mean a display (LOutput) ?

[okcomput3]

hi ive just made a video i`ll give the link in next message once it finished uploading, it is similar to that yes zooming into workspaces...

[ehopperdietzel]

Another tip: after finishing the animation, remember to set the root view scaling vector precisely to (1, 1). Otherwise, the damage tracking system will always perform a full repaint of each view that change, instead of repainting only, for example, a button that was pressed.

[okcomput3]

Thank you for the suggestions. I'll give it a try and keep you updated on my progress. More people should definitely be using Louvre, it's fantastic!!!

[okcomput3]

I tried to implement a method to adjust the scale and position of root layers associated with each output dynamically. However, the expected scaling effects are not being applied, and I suspect there might be a mistake in my implementation.

What I've Done:

Created a root LLayerView for each LOutput and stored these in a std::map to manage their relationships.
Implemented the setupAutomaticZoom() method to adjust the scaling factor based on animation progress, applying this scale to each root layer.
Used Louvre::LSizeF to create a scaling vector and applied it to the root layers.
Called this->repaintAllOutputs() at the end of the animation to update the display.

void ECompositor::initialized()
{
// Set a keyboard map with "latam" layout
seat()->keyboard()->setKeymap(nullptr, nullptr, "US", nullptr);

Int32 totalWidth { 0 };

// Initialize all avaliable outputs
for (LOutput *output : seat()->outputs())
{
    // Set double scale to outputs with DPI >= 200
    output->setScale(output->dpi() >= 200 ? 2.f : 1.f);

    // Assuming your outputs are not rotated or flipped
    output->setTransform(LFramebuffer::Normal);

    output->setPos(LPoint(totalWidth, 0));
    totalWidth += output->size().w();

    LLayerView* rootLayer = new LLayerView();
    static_cast<EOutput*>(output)->setRootView(rootLayer);
    rootLayers[output] = rootLayer;
    rootLayer->enableParentScaling(true);
    rootLayer->enableParentOffset(true);


    // Creating a child layer or view with rootLayer as its parent
    LLayerView* workspaceLayer = new LLayerView(rootLayer);
    workspaceLayers[output] = workspaceLayer;
    workspaceLayer->enableParentScaling(true);
    workspaceLayer->enableParentOffset(true);


    // Clipping setup for the workspace layer
    LRect clippingRect = output->rect(); // Get the output's rectangle for the clipping region
    workspaceLayer->enableClipping(true); // Enable clipping for the workspace layer
    workspaceLayer->setClippingRect(clippingRect); // Set the clipping rectangle


    addOutput(output);
    output->repaint();
}

}

//...........................
#include

using namespace Louvre;

class ESurface;

class ECompositor : public LCompositor
{
public:

//...............................
private:
std::map<LOutput*, LLayerView*> rootLayers;
std::map<LOutput*, LLayerView*> workspaceLayers;
};

#endif // ECOMPOSITOR_H

void ECompositor::setupAutomaticZoom()
{
//.............................................

LAnimation::oneShot(duration,
[this, minScale, maxScale](LAnimation *anim) mutable {
float currentValue = anim->value(); // Animation progress: 0.0 to 1.0
float deltaScale = (maxScale - minScale) * currentValue;
globalScaleFactor = increaseScale ? minScale + deltaScale : maxScale - deltaScale;

        // Apply the updated scale factor and position to each root layer
        for (LOutput *output : this->outputs()) { // Using LCompositor::outputs() to access initialized outputs
            LLayerView* rootLayer = rootLayers[output]; // Access the root layer associated with this output

            // Set the root layer's position
            rootLayer->setPos(LPoint(0, 0));

            // Create a scaling vector and apply it to the root layer
            Louvre::LSizeF scalingVector(static_cast<float>(globalScaleFactor), static_cast<float>(globalScaleFactor));
            rootLayer->setScalingVector(scalingVector);

            // Note: Assuming output->setScale() is not needed if rootLayer scaling is used
            // output->repaint(); is not directly called; we'll use repaintAllOutputs() after the loop
        }

        // Repaint all outputs after applying the transformations
        this->repaintAllOutputs();
      },
[this](LAnimation *anim) mutable {
        // Toggle the direction of scale change at the end of each animation
        increaseScale = !increaseScale;
    }
);

}

[ehopperdietzel]

Hmm, first of all, an LOutput represents a single display. For instance, if you're using your laptop alone, there should be a single LOutput. If you hotplug another display, such as a TV or external monitor, then there would be 2 LOutputs.

If you followed the tutorial, you probably created your own LOutput subclass (EOutput). In this case, you don't need to use any map to link the views with each output. You could simply add it as a member of EOutput, and then each output will have its own root LLayerView.

class EOutput : public Louvre::LOutput
{
    // ....
    LLayerView rootViewForThisOutput; // Make it child of LScene::mainView()
    std::vector<LLayerView*> workspacesOfThisOutput; // Make them child of rootViewForThisOutput
}

To make a view a child of another view, you have to use LView::setParent() or LView::insertAfter().

Once you've made the views children of the root view, you could create a recursive function to update their parameters like this:

static void enableParentOffsetToAllChildren(LView *root, bool enabled)
{
    for (LView *child : root->children())
    {
        child->enableParentOffset(enabled);
        enableParentOffsetToAllChildren(child, enabled);
    }
}

Do the same to enable parent scaling, enabling and setting the clipping rect, etc.

I suggest you perform simple tests, like creating an LLayerView, making another LSolidColorView as a child, and test LLayerView::setScalingVector() and other methods, so you can better understand how they work.

[ehopperdietzel]

Enabling the parent offset property of a view means that the position you assigned it will be affected by the position of its parent view.
Enabling the parent scaling property of a view means that the position and size of the view will be multiplied by the parent scaling vector.

[okcomput3]

Hi, and thanks for your thorough answers ive just been setting up my roland egx 300 cnc on my windows 11 past couple of dayz so am back just getting round to figuring this out though I'm still a bit confused about a couple of points and could use some further clarification:

1 Where to Place enableParentOffsetToAllChildren: where is the most appropriate place to call this function. Should this be invoked within the EOutput constructor, or is there a better stage during the view hierarchy's initialization or update process where this function should be executed?

2 Initialization Process: I attempted to establish and manage the view hierarchy by introducing an initializeViews method within EOutput, which I planned to call from ECompositor::initialized(). However, this approach seems to interfere with loading the compositor GUI correctly, Could you provide some pointers on the correct way to initialize views within EOutput instances. Is there a recommended approach for setting up and managing the view hierarchy that ensures the GUI loads properly or any additional debug output which would be beneficial in resolving initialization issues?

void ECompositor::initialized() {
// Set a keyboard map with "UK" layout
seat()->keyboard()->setKeymap(nullptr, nullptr, "gb", nullptr);

Int32 totalWidth = 0;

// Initialize all available outputs
for (LOutput* output : this->outputs()) { // Assuming this->outputs() correctly retrieves EOutput instances
    EOutput* eOutput = static_cast<EOutput*>(output); // Cast LOutput to EOutput

    eOutput->setScale(eOutput->dpi() >= 200 ? 2.0f : 1.0f);

    eOutput->setTransform(LFramebuffer::Normal);

    eOutput->setPos(LPoint(totalWidth, 0));
    totalWidth += eOutput->size().w();

    // Initialize views for this output
    eOutput->initializeViews(); // Setup view hierarchy including rootView and any child views

    // Add output to compositor's management and trigger repaint
    this->addOutput(eOutput);
    eOutput->repaint();
}

// Optional: Call testScaling to apply and test scaling functionality

// testScaling();
}

[ehopperdietzel]

Global Coordinate System

Firstly, it's important to grasp that there is a unified compositor global space coordinate system which uses surface coordinates as units.

This implies that you can organize outputs in this space as desired. For instance, in both the tutorial and the default Louvre implementation of LCompositor::initialized(), the first output is positioned at (0,0), and the subsequent one at (prevOutput.pos().x() + prevOutput.size().w(), 0), and so forth. However, you have the flexibility to modify this arrangement as needed. Additionally, altering an output's mode (resolution) or scale factor will change its size, necessitating a rearrangement to avoid overlap or ensure tight alignment, crucial for smooth cursor transitions. You can use the LOutput::resizeGL() event to manage these scenarios.

This implies that if you set the position of a view to (0, 0), it will appear in the top-left corner of the first output but not the second. If you wish to display it in the second output, you need to set its position equal to secondOutput.pos(). Furthermore, if you aim to display the same view in both outputs (at the same time), you cannot achieve this directly; you need to create two distinct views and position them accordingly. This principle also applies when using LPainter for rendering instead of the views system. For example, if you intend to draw a texture in the top-left corner of an output, you must use LPainter::drawTexture(texture, output.pos(), ...).

To summarize, it's crucial to understand that all outputs do not possess their own coordinate system starting at (0,0); only the first one (if using the default Louvre arranging approach) does.

Scene and Views

To streamline rendering for all outputs, you can create a single LScene and integrate it into each output calling LScene::handleInitializeGL() from LOutput::initializeGL(), LScene::handlePaintGL() from paintGL(), and so on...

The LScene has a root invisible view located at position (0,0), accessible through LScene::mainView(). Consequently, the LScene can exclusively render views that are children or sub-children of LScene::mainView(). While you have the flexibility to organize your hierarchy as you see fit, it's imperative to ensure that LScene::mainView() is the topmost parent in your setup.

Initialization

The LCompositor::initialized() event triggers after proper initialization of Wayland, input, and graphic backends. All input and Wayland events are handled in the main thread. Upon calling LCompositor::addOutput(), the given output gets initialized, and each output has its dedicated rendering thread. Consequently, all LOutput::xxxGL() events are triggered from the associated rendering thread. It's worth noting that LCompositor::addOutput() blocks the main thread until both the output and the new rendering thread are fully initialized (after LOutput::initializeGL() is triggered).

When you invoke LOutput::repaint(), the corresponding output rendering thread is unblocked, and LOutput::paintGL() is asynchronously called. It's crucial to understand that LOutput::paintGL() is the only event where rendering for the specific output is permissible.

By plugging LScene::handlePaintGL() into the LOutput::paintGL() event, the scene takes charge of rendering, drawing only the views visible within the output rect (LOutput::pos(), LOutput::size()). For instance, if you intend to display a wallpaper on all outputs, you must create a distinct view for each one, ensuring its position and size align with the respective output.

Views can be modified from any thread, but they will only be rendered on a specific output when LScene::handlePaintGL() is invoked. That is why it's necessary to call LOutput::repaint(), but since views keep track of the outputs they are visible in, they automatically trigger a repaint when parameters are updated.

So, you can create a LLayerView (for each EOutput) to group all the views you want to display on a specific output and call enableParentOffsetToAllChildren() from LOutput::initializeGL(), to automatically move all the LLayerView child views along with it. You can also create a similar function to clip the views to the LOutput::rect() to prevent them from appearing in other outputs when, for instance, one is dragged beyond the output's edge.