8e8bfbb0b1 added fifo and merged non
buffer states before comitting them, something about certain xwl non
buffer commits expects a commit to happend and causes regressions as in
low fps.
Renames `misc:new_window_takes_over_fullscreen` into
`misc:on_focus_under_fullscreen` and implements the following behavior:
- By default, when a tiling window is being focused on a workspace where
a fullscreen/maximized window exists, respect
the `misc:on_focus_under_fullscreen` config variable.
as protocol states there is two events. 'presented' or 'discarded'.
wp_presentation_feedback::sync_output
As presentation can be synchronized to only one output at a time, this event tells which output it was.
This event is only sent prior to the presented event.
wlr-randr disconnects immediately after receiving success event, but
before applying the monitor configuration. This causes the state to be
lost when performMonitorReload() is called.
By postponing the success event until the call of the hook
monitorLayoutChanged we ensure the configuration to remain valid during
the reload process.
* protocols: add Fifo-v1
introduce fifo-v1
* fifo: only present locked surfaces
dont present to unlocked surfaces and commit pending states from the
fifo protocol.
* fifo: cformat
cformat
* protocols: add committiming and surface state queue
introduce CSurfaceStateQueue and commit-timing-v1
* fifo: schedule a frame if waiting on barrier
if we are waiting on a barrier the state doesnt commit until the next
refresh cycle meaning the monitor might have no pending damage and we
never get onPresented to unlock the barrier, moment 22. so schedule a
frame.
* fifo: properly check monitor intersection
check for m_enteredoutputs or monitor intersection if client hasnt bound
one yet, and dont fifo lock it until the surface is mapped.
* buffer: try to merge states before committing them
try to merge states before committing them meaning way less churn and
surface commits if a surface sends multiple small ones while we wait for
buffer readyness from either fifo locks or simply fences.
* buffer: dont commit states past the buffer
certain changes are relative to the buffer attached, cant go beyond it
and apply those onto the next buffer.
* buffer: set the lockmask directly
cant use .lock since the state hasnt been queued yet, set the lockmask
directly when exporting buffer fence.
* fifo: dont fifo lock on tearing
dont fifo lock on tearing.
* buffer: queue the state directly
queue the state directly and use the .lock function instead of directly
modify the lockMask on the state.
* buffer: revert creating texture at commit time
fifo barriers introduces such long wait that upon commit time a
race happends with current xdg configure implentation that the buffer
and image is actually destroyed when entering commitState, doing it at
buffer creation time with EGL_PRESERVED_KHR means it sticks around until
we are done. so revert 82759d4 and 32f3233 for now.
* buffer: rename enum and lockreasons
eLockReason and LOCK_REASON_NONE.
* fifo: workaround direct scanout lock
workaround cursor commits causing fifo to get forever locked, this
entire thing needs to be worked out.
The forceidle dispatcher resets all ext-idle-notify timers as if the
user had been idle for the specified number of seconds. If a
notification has already fired, but would now be set with a nonzero
delay, then it is reset. Conversely, if a timer has not yet fired, but
would now be set to a nonpositive delay, then it is immediately fired.
This process ignores any existing inhibitors, but timers are otherwise
reset as normal if any new inhibitors are created or destroyed.
Use setDPMS() instead of directly manipulating m_dpmsStatus to ensure the dpmsChanged event fires and protocol
clients receive mode change confirmation via sendMode().
buffer can be recomitted, when moving texture creation from constructor
to committime it means same buffer recommit can cause a new texture
unless we store it per buffer and return the pointer for it.
* buffer: move texture creation to commit time
move creating texture away from buffer attach into commitstate in an
attempt to postpone gpu work until its really needed. best case scenario
gpu clocks have ramped up before because we are actively doing things
causing surface states and a commit to happend meaning less visible lag.
* buffer: simplify texture creation
make createTexture return a shared ptr directly, remove not needed
member variables as m_success and m_texture.
* compositor: make pending states store frame callbacks
move frame callbacks to pending states so they are only committed in the
order they came depending on the buffer wait for readyness.
* buffer: damage is relative to current commit
ensure the damage is only used once, or we are constantly redrawing
things on state commits that isnt a buffer.
thanks PlasmaPower.
* compositor: move callbacks back to compositor
move SSurfaceStateFrameCB back to compositor in the class
CWLCallbackResource as per request, but still keep the state as owning.
* compositor: ensure commits come in order
if a buffer is waiting any commits after it might be non buffer commits
from the "future" and applying directly. and when the old buffer that
was waiting becomes ready it applies its states and overwrites the
future changes.
move things to scheduleState and add a m_pendingWaiting guard. and
schedule the next pending state from the old buffer commit when done.
and as such it loops itself and keeps thing orderly.
* compositor: make pending states store frame callbacks
move frame callbacks to pending states so they are only committed in the
order they came depending on the buffer wait for readyness.
* buffer: damage is relative to current commit
ensure the damage is only used once, or we are constantly redrawing
things on state commits that isnt a buffer.
thanks PlasmaPower.
* compositor: move callbacks back to compositor
move SSurfaceStateFrameCB back to compositor in the class
CWLCallbackResource as per request, but still keep the state as owning.
* compositor: ensure commits come in order
if a buffer is waiting any commits after it might be non buffer commits
from the "future" and applying directly. and when the old buffer that
was waiting becomes ready it applies its states and overwrites the
future changes.
move things to scheduleState and add a m_pendingWaiting guard. and
schedule the next pending state from the old buffer commit when done.
and as such it loops itself and keeps thing orderly.
Clamps the pending wp_viewport source rect back inside the attached buffer when it misses by <= 1 px, so if clients request something that falls within the 256-increment wl_fixed_from_double precision error it’s still treated as valid.
use unique pointers and rvalue references where applicable, buffer is
still a shared pointer because CHLBufferReference uses it to hold it
locked.
in CSHMPool destructor add a check for m_data != MAP_FAILED same in
resize, because mmap returns (void *) -1 on failure and that is not
comparable to nullptr. delete default constructor so we dont end up in
weird states with m_data.
