leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

deps: Update smithay

Browse source 
- Use new GAT frame
- Bugfixes
- Finish window debug overlay
This commit is contained in:
Victoria Brekenfeld 2022-11-28 17:48:50 +01:00
parent c585811cab
commit 7092c523f5
18 changed files with 445 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/backend/render/cursor.rs
View file

@ -129,15 +129,18 @@ fn load_icon(theme: &CursorTheme) -> Result<Vec<Image>, Error> {
render_elements! {
pub CursorRenderElement<R> where R: ImportAll;
Static=TextureRenderElement<<R as Renderer>::TextureId>,
Surface=WaylandSurfaceRenderElement,
Surface=WaylandSurfaceRenderElement<R>,
}
pub fn draw_surface_cursor<R: Renderer + ImportAll>(
pub fn draw_surface_cursor<R>(
renderer: &mut R,
surface: &wl_surface::WlSurface,
location: impl Into<Point<i32, Logical>>,
scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
{
let mut position = location.into();
let scale = scale.into();
@ -152,14 +155,25 @@ where
});
position -= h;
render_elements_from_surface_tree(surface, position.to_physical_precise_round(scale), scale)
render_elements_from_surface_tree(
renderer,
surface,
position.to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
pub fn draw_dnd_icon<R: Renderer + ImportAll>(
pub fn draw_dnd_icon<R>(
renderer: &mut R,
surface: &wl_surface::WlSurface,
location: impl Into<Point<i32, Logical>>,
scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>> {
) -> Vec<CursorRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
{
if get_role(&surface) != Some("dnd_icon") {
slog_scope::warn!(
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
@ -167,9 +181,11 @@ pub fn draw_dnd_icon<R: Renderer + ImportAll>(
}
let scale = scale.into();
render_elements_from_surface_tree(
renderer,
surface,
location.into().to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
@ -218,7 +234,7 @@ where
.unwrap_or(CursorImageStatus::Default);
if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
return draw_surface_cursor(wl_surface, location.to_i32_round(), scale);
return draw_surface_cursor(renderer, wl_surface, location.to_i32_round(), scale);
} else if draw_default && CursorImageStatus::Default == cursor_status {
let integer_scale = scale.x.max(scale.y).ceil() as u32;

80
src/backend/render/element.rs
View file

@ -2,22 +2,24 @@ use crate::shell::{CosmicMappedRenderElement, WorkspaceRenderElement};
use smithay::{
backend::renderer::{
element::{texture::TextureRenderElement, Element, RenderElement, UnderlyingStorage},
gles2::{Gles2Frame, Gles2Texture},
glow::GlowRenderer,
multigpu::Error as MultiError,
element::{Element, RenderElement, UnderlyingStorage},
glow::{GlowFrame, GlowRenderer},
Frame, ImportAll, Renderer,
},
utils::{Physical, Point, Rectangle, Scale},
};
#[cfg(feature = "debug")]
use smithay::backend::renderer::{
element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
};
use super::{cursor::CursorRenderElement, GlMultiFrame, GlMultiRenderer};
pub enum CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
Workspace(WorkspaceRenderElement<R>),
@ -31,7 +33,6 @@ impl<R> Element for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
@ -120,25 +121,22 @@ where
}
impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlowRenderer,
frame: &mut <GlowRenderer as Renderer>::Frame,
frame: &mut <GlowRenderer as Renderer>::Frame<'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, location, scale, damage, log)
}
}
}
@ -157,29 +155,28 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
}
impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a>> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlMultiRenderer<'a>,
frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
frame: &mut GlMultiFrame<'a, 'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer_mut();
let gles2_frame = frame.gles2_frame_mut();
elem.draw(glow_renderer, gles2_frame, location, scale, damage, log)
let elem = {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(
elem, glow_frame, location, scale, damage, log,
)
.map_err(|err| MultiError::Render(err))
};
elem
}
}
}
@ -210,7 +207,6 @@ impl<R> From<WorkspaceRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: WorkspaceRenderElement<R>) -> Self {
@ -222,7 +218,6 @@ impl<R> From<CursorRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CursorRenderElement<R>) -> Self {
@ -234,7 +229,6 @@ impl<R> From<CosmicMappedRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicMappedRenderElement<R>) -> Self {
@ -247,7 +241,6 @@ impl<R> From<TextureRenderElement<Gles2Texture>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<Gles2Texture>) -> Self {
@ -258,7 +251,6 @@ where
pub trait AsGlowRenderer
where
Self: Renderer,
<Self as Renderer>::Frame: AsGles2Frame,
{
fn glow_renderer(&self) -> &GlowRenderer;
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer;
@ -282,28 +274,28 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
}
}
pub trait AsGles2Frame
pub trait AsGlowFrame<'a>
where
Self: Frame,
{
fn gles2_frame(&self) -> &Gles2Frame;
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame;
fn glow_frame(&self) -> &GlowFrame<'a>;
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'a>;
}
impl AsGles2Frame for Gles2Frame {
fn gles2_frame(&self) -> &Gles2Frame {
impl<'frame> AsGlowFrame<'frame> for GlowFrame<'frame> {
fn glow_frame(&self) -> &GlowFrame<'frame> {
self
}
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
self
}
}
impl AsGles2Frame for GlMultiFrame {
fn gles2_frame(&self) -> &Gles2Frame {
impl<'renderer, 'frame> AsGlowFrame<'frame> for GlMultiFrame<'renderer, 'frame> {
fn glow_frame(&self) -> &GlowFrame<'frame> {
self.as_ref()
}
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
self.as_mut()
}
}

42
src/backend/render/mod.rs
View file

@ -41,7 +41,7 @@ use smithay::{
pub mod cursor;
use self::cursor::CursorRenderElement;
pub mod element;
use self::element::{AsGles2Frame, AsGlowRenderer, CosmicElement};
use self::element::{AsGlowRenderer, CosmicElement};
pub type GlMultiRenderer<'a> = MultiRenderer<
'a,
@ -50,7 +50,14 @@ pub type GlMultiRenderer<'a> = MultiRenderer<
EglGlesBackend<GlowRenderer>,
Gles2Renderbuffer,
>;
pub type GlMultiFrame = MultiFrame<EglGlesBackend<GlowRenderer>, EglGlesBackend<GlowRenderer>>;
pub type GlMultiFrame<'a, 'frame> = MultiFrame<
'a,
'a,
'frame,
EglGlesBackend<GlowRenderer>,
EglGlesBackend<GlowRenderer>,
Gles2Renderbuffer,
>;
pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
@ -61,7 +68,7 @@ pub enum CursorMode {
All,
}
pub fn cursor_elements<E, R>(
pub fn cursor_elements<'frame, E, R>(
renderer: &mut R,
state: &Common,
output: &Output,
@ -69,7 +76,6 @@ pub fn cursor_elements<E, R>(
) -> Vec<E>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
@ -101,7 +107,7 @@ where
if let Some(wl_surface) = get_dnd_icon(seat) {
elements.extend(
cursor::draw_dnd_icon(&wl_surface, location.to_i32_round(), scale)
cursor::draw_dnd_icon(renderer, &wl_surface, location.to_i32_round(), scale)
.into_iter()
.map(E::from),
);
@ -113,7 +119,7 @@ where
.unwrap()
.borrow()
.as_ref()
.map(|state| state.render::<E, R>(seat, output))
.map(|state| state.render::<E, R>(renderer, seat, output))
{
elements.extend(grab_elements);
}
@ -122,7 +128,7 @@ where
elements
}
pub fn render_output<R, Target, OffTarget, Source>(
pub fn render_output<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
@ -144,7 +150,6 @@ where
+ Offscreen<OffTarget>
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
@ -167,7 +172,7 @@ where
)
}
pub fn render_workspace<R, Target, OffTarget, Source>(
pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
@ -190,7 +195,6 @@ where
+ Offscreen<OffTarget>
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
@ -199,6 +203,15 @@ where
{
if let Some(ref mut fps) = fps {
fps.start();
#[cfg(feature = "debug")]
if screencopy.is_some() {
if let Some(rd) = fps.rd.as_mut() {
rd.start_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
}
}
let workspace = state.shell.space_for_handle(&handle).ok_or(OutputNoMode)?;
@ -245,7 +258,7 @@ where
elements.extend(
workspace
.render_output::<R>(output)
.render_output::<R>(renderer, output)
.map_err(|_| OutputNoMode)?
.into_iter()
.map(Into::into),
@ -307,6 +320,13 @@ where
}
if let Some(fps) = fps.as_mut() {
fps.screencopy();
#[cfg(feature = "debug")]
if let Some(rd) = fps.rd.as_mut() {
rd.end_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
}
}