Move rendering out of output to a new namespace
This commit is contained in:
Isaac Freund
parent
1ffd13ef86
commit
e77506a003
342
src/output.zig
342
src/output.zig
@ -1,30 +1,10 @@
|
||||
const std = @import("std");
|
||||
const c = @import("c.zig");
|
||||
const render = @import("render.zig");
|
||||
|
||||
const Box = @import("box.zig").Box;
|
||||
const LayerSurface = @import("layer_surface.zig").LayerSurface;
|
||||
const Root = @import("root.zig").Root;
|
||||
const Server = @import("server.zig").Server;
|
||||
const View = @import("view.zig").View;
|
||||
const ViewStack = @import("view_stack.zig").ViewStack;
|
||||
|
||||
const ViewRenderData = struct {
|
||||
output: *c.wlr_output,
|
||||
renderer: *c.wlr_renderer,
|
||||
view: *View,
|
||||
when: *c.struct_timespec,
|
||||
ox: f64,
|
||||
oy: f64,
|
||||
};
|
||||
|
||||
const LayerSurfaceRenderData = struct {
|
||||
output: *c.wlr_output,
|
||||
renderer: *c.wlr_renderer,
|
||||
layer_surface: *LayerSurface,
|
||||
when: *c.struct_timespec,
|
||||
ox: f64,
|
||||
oy: f64,
|
||||
};
|
||||
|
||||
pub const Output = struct {
|
||||
const Self = @This();
|
||||
@ -166,324 +146,6 @@ pub const Output = struct {
|
||||
// This function is called every time an output is ready to display a frame,
|
||||
// generally at the output's refresh rate (e.g. 60Hz).
|
||||
const output = @fieldParentPtr(Output, "listen_frame", listener.?);
|
||||
const renderer = output.root.server.wlr_renderer;
|
||||
|
||||
var now: c.struct_timespec = undefined;
|
||||
_ = c.clock_gettime(c.CLOCK_MONOTONIC, &now);
|
||||
|
||||
// wlr_output_attach_render makes the OpenGL context current.
|
||||
if (!c.wlr_output_attach_render(output.wlr_output, null)) {
|
||||
return;
|
||||
}
|
||||
// The "effective" resolution can change if you rotate your outputs.
|
||||
var width: c_int = undefined;
|
||||
var height: c_int = undefined;
|
||||
c.wlr_output_effective_resolution(output.wlr_output, &width, &height);
|
||||
// Begin the renderer (calls glViewport and some other GL sanity checks)
|
||||
c.wlr_renderer_begin(renderer, width, height);
|
||||
|
||||
const color = [_]f32{ 0.0, 0.16862745, 0.21176471, 1.0 };
|
||||
c.wlr_renderer_clear(renderer, &color);
|
||||
|
||||
// The view has a position in layout coordinates. If you have two displays,
|
||||
// one next to the other, both 1080p, a view on the rightmost display might
|
||||
// have layout coordinates of 2000,100. We need to translate that to
|
||||
// output-local coordinates, or (2000 - 1920).
|
||||
var ox: f64 = 0.0;
|
||||
var oy: f64 = 0.0;
|
||||
c.wlr_output_layout_output_coords(
|
||||
output.root.wlr_output_layout,
|
||||
output.wlr_output,
|
||||
&ox,
|
||||
&oy,
|
||||
);
|
||||
|
||||
output.renderLayer(output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &now, ox, oy);
|
||||
output.renderLayer(output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &now, ox, oy);
|
||||
|
||||
// The first view in the list is "on top" so iterate in reverse.
|
||||
var it = ViewStack.reverseIterator(
|
||||
output.root.views.last,
|
||||
output.root.current_focused_tags,
|
||||
);
|
||||
while (it.next()) |view| {
|
||||
// This check prevents a race condition when a frame is requested
|
||||
// between mapping of a view and the first configure being handled.
|
||||
if (view.current_box.width == 0 or view.current_box.height == 0) {
|
||||
continue;
|
||||
}
|
||||
output.renderView(view, &now, ox, oy);
|
||||
output.renderBorders(view, &now, ox, oy);
|
||||
}
|
||||
|
||||
output.renderLayer(output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_TOP], &now, ox, oy);
|
||||
output.renderLayer(output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &now, ox, oy);
|
||||
|
||||
// Hardware cursors are rendered by the GPU on a separate plane, and can be
|
||||
// moved around without re-rendering what's beneath them - which is more
|
||||
// efficient. However, not all hardware supports hardware cursors. For this
|
||||
// reason, wlroots provides a software fallback, which we ask it to render
|
||||
// here. wlr_cursor handles configuring hardware vs software cursors for you,
|
||||
// and this function is a no-op when hardware cursors are in use.
|
||||
c.wlr_output_render_software_cursors(output.wlr_output, null);
|
||||
|
||||
// Conclude rendering and swap the buffers, showing the final frame
|
||||
// on-screen.
|
||||
c.wlr_renderer_end(renderer);
|
||||
// TODO: handle failure
|
||||
_ = c.wlr_output_commit(output.wlr_output);
|
||||
}
|
||||
|
||||
/// Render all surfaces on the passed layer
|
||||
fn renderLayer(self: Self, layer: std.TailQueue(LayerSurface), now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
var it = layer.first;
|
||||
while (it) |node| : (it = node.next) {
|
||||
const layer_surface = &node.data;
|
||||
var rdata = LayerSurfaceRenderData{
|
||||
.output = self.wlr_output,
|
||||
.renderer = self.root.server.wlr_renderer,
|
||||
.layer_surface = layer_surface,
|
||||
.when = now,
|
||||
.ox = ox,
|
||||
.oy = oy,
|
||||
};
|
||||
c.wlr_layer_surface_v1_for_each_surface(
|
||||
layer_surface.wlr_layer_surface,
|
||||
renderLayerSurface,
|
||||
&rdata,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// This function is called for every layer surface and popup that needs to be rendered.
|
||||
/// TODO: refactor this to reduce code duplication
|
||||
fn renderLayerSurface(_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void {
|
||||
// wlroots says this will never be null
|
||||
const surface = _surface.?;
|
||||
// This function is called for every surface that needs to be rendered.
|
||||
const rdata = @ptrCast(*LayerSurfaceRenderData, @alignCast(@alignOf(LayerSurfaceRenderData), data));
|
||||
const layer_surface = rdata.layer_surface;
|
||||
const output = rdata.output;
|
||||
|
||||
// We first obtain a wlr_texture, which is a GPU resource. wlroots
|
||||
// automatically handles negotiating these with the client. The underlying
|
||||
// resource could be an opaque handle passed from the client, or the client
|
||||
// could have sent a pixel buffer which we copied to the GPU, or a few other
|
||||
// means. You don't have to worry about this, wlroots takes care of it.
|
||||
const texture = c.wlr_surface_get_texture(surface);
|
||||
if (texture == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
var box = c.wlr_box{
|
||||
.x = @floatToInt(c_int, rdata.ox) + layer_surface.box.x + sx,
|
||||
.y = @floatToInt(c_int, rdata.oy) + layer_surface.box.y + sy,
|
||||
.width = surface.current.width,
|
||||
.height = surface.current.height,
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, output.scale);
|
||||
|
||||
// wlr_matrix_project_box is a helper which takes a box with a desired
|
||||
// x, y coordinates, width and height, and an output geometry, then
|
||||
// prepares an orthographic projection and multiplies the necessary
|
||||
// transforms to produce a model-view-projection matrix.
|
||||
var matrix: [9]f32 = undefined;
|
||||
const transform = c.wlr_output_transform_invert(surface.current.transform);
|
||||
c.wlr_matrix_project_box(&matrix, &box, transform, 0.0, &output.transform_matrix);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(rdata.renderer, texture, &matrix, 1.0);
|
||||
|
||||
// This lets the client know that we've displayed that frame and it can
|
||||
// prepare another one now if it likes.
|
||||
c.wlr_surface_send_frame_done(surface, rdata.when);
|
||||
}
|
||||
|
||||
fn renderView(self: Self, view: *View, now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
// If we have a stashed buffer, we are in the middle of a transaction
|
||||
// and need to render that buffer until the transaction is complete.
|
||||
if (view.stashed_buffer) |buffer| {
|
||||
const border_width = view.root.server.config.border_width;
|
||||
const view_padding = view.root.server.config.view_padding;
|
||||
var box = c.wlr_box{
|
||||
.x = view.current_box.x + @intCast(i32, border_width + view_padding),
|
||||
.y = view.current_box.y + @intCast(i32, border_width + view_padding),
|
||||
.width = @intCast(c_int, view.current_box.width - border_width * 2 - view_padding * 2),
|
||||
.height = @intCast(c_int, view.current_box.height - border_width * 2 - view_padding * 2),
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, self.wlr_output.scale);
|
||||
|
||||
var matrix: [9]f32 = undefined;
|
||||
c.wlr_matrix_project_box(
|
||||
&matrix,
|
||||
&box,
|
||||
c.enum_wl_output_transform.WL_OUTPUT_TRANSFORM_NORMAL,
|
||||
0.0,
|
||||
&self.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(
|
||||
self.root.server.wlr_renderer,
|
||||
buffer.texture,
|
||||
&matrix,
|
||||
1.0,
|
||||
);
|
||||
} else {
|
||||
// Since there is no stashed buffer, we are not in the middle of
|
||||
// a transaction and may simply render each toplevel surface.
|
||||
var rdata = ViewRenderData{
|
||||
.output = self.wlr_output,
|
||||
.view = view,
|
||||
.renderer = self.root.server.wlr_renderer,
|
||||
.when = now,
|
||||
.ox = ox,
|
||||
.oy = oy,
|
||||
};
|
||||
|
||||
// This calls our render_surface function for each surface among the
|
||||
// xdg_surface's toplevel and popups.
|
||||
c.wlr_xdg_surface_for_each_surface(view.wlr_xdg_surface, renderSurface, &rdata);
|
||||
}
|
||||
}
|
||||
|
||||
/// This function is called for every toplevel and popup surface that needs to be rendered.
|
||||
fn renderSurface(_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void {
|
||||
// wlroots says this will never be null
|
||||
const surface = _surface.?;
|
||||
const rdata = @ptrCast(*ViewRenderData, @alignCast(@alignOf(ViewRenderData), data));
|
||||
const view = rdata.view;
|
||||
const output = rdata.output;
|
||||
|
||||
// We first obtain a wlr_texture, which is a GPU resource. wlroots
|
||||
// automatically handles negotiating these with the client. The underlying
|
||||
// resource could be an opaque handle passed from the client, or the client
|
||||
// could have sent a pixel buffer which we copied to the GPU, or a few other
|
||||
// means. You don't have to worry about this, wlroots takes care of it.
|
||||
const texture = c.wlr_surface_get_texture(surface);
|
||||
if (texture == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
const border_width = view.root.server.config.border_width;
|
||||
const view_padding = view.root.server.config.view_padding;
|
||||
var box = c.wlr_box{
|
||||
.x = @floatToInt(c_int, rdata.ox) + view.current_box.x + sx +
|
||||
@intCast(c_int, border_width + view_padding),
|
||||
.y = @floatToInt(c_int, rdata.oy) + view.current_box.y + sy +
|
||||
@intCast(c_int, border_width + view_padding),
|
||||
.width = surface.current.width,
|
||||
.height = surface.current.height,
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, output.scale);
|
||||
|
||||
// wlr_matrix_project_box is a helper which takes a box with a desired
|
||||
// x, y coordinates, width and height, and an output geometry, then
|
||||
// prepares an orthographic projection and multiplies the necessary
|
||||
// transforms to produce a model-view-projection matrix.
|
||||
var matrix: [9]f32 = undefined;
|
||||
const transform = c.wlr_output_transform_invert(surface.current.transform);
|
||||
c.wlr_matrix_project_box(&matrix, &box, transform, 0.0, &output.transform_matrix);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(rdata.renderer, texture, &matrix, 1.0);
|
||||
|
||||
// This lets the client know that we've displayed that frame and it can
|
||||
// prepare another one now if it likes.
|
||||
c.wlr_surface_send_frame_done(surface, rdata.when);
|
||||
}
|
||||
|
||||
fn renderBorders(self: Self, view: *View, now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
var border: c.wlr_box = undefined;
|
||||
const color = if (self.root.focused_view == view)
|
||||
[_]f32{ 0.57647059, 0.63137255, 0.63137255, 1.0 } // Solarized base1
|
||||
else
|
||||
[_]f32{ 0.34509804, 0.43137255, 0.45882353, 1.0 }; // Solarized base01
|
||||
const border_width = self.root.server.config.border_width;
|
||||
const view_padding = self.root.server.config.view_padding;
|
||||
|
||||
// left border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x + @intCast(c_int, view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y + @intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, border_width);
|
||||
border.height = @intCast(c_int, view.current_box.height - view_padding * 2);
|
||||
scaleBox(&border, self.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
self.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&self.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// right border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, view.current_box.width - border_width - view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y + @intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, border_width);
|
||||
border.height = @intCast(c_int, view.current_box.height - view_padding * 2);
|
||||
scaleBox(&border, self.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
self.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&self.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// top border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, border_width + view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y +
|
||||
@intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, view.current_box.width -
|
||||
border_width * 2 - view_padding * 2);
|
||||
border.height = @intCast(c_int, border_width);
|
||||
scaleBox(&border, self.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
self.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&self.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// bottom border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, border_width + view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y +
|
||||
@intCast(c_int, view.current_box.height - border_width - view_padding);
|
||||
border.width = @intCast(c_int, view.current_box.width -
|
||||
border_width * 2 - view_padding * 2);
|
||||
border.height = @intCast(c_int, border_width);
|
||||
scaleBox(&border, self.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
self.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&self.wlr_output.transform_matrix,
|
||||
);
|
||||
render.renderOutput(output);
|
||||
}
|
||||
};
|
||||
|
||||
/// Scale a wlr_box, taking the possibility of fractional scaling into account.
|
||||
fn scaleBox(box: *c.wlr_box, scale: f64) void {
|
||||
box.x = @floatToInt(c_int, @round(@intToFloat(f64, box.x) * scale));
|
||||
box.y = @floatToInt(c_int, @round(@intToFloat(f64, box.y) * scale));
|
||||
box.width = scaleLength(box.width, box.x, scale);
|
||||
box.height = scaleLength(box.height, box.x, scale);
|
||||
}
|
||||
|
||||
/// Scales a width/height.
|
||||
///
|
||||
/// This might seem overly complex, but it needs to work for fractional scaling.
|
||||
fn scaleLength(length: c_int, offset: c_int, scale: f64) c_int {
|
||||
return @floatToInt(c_int, @round(@intToFloat(f64, offset + length) * scale) -
|
||||
@round(@intToFloat(f64, offset) * scale));
|
||||
}
|
||||
|
||||
348
src/render.zig
Normal file
348
src/render.zig
Normal file
@ -0,0 +1,348 @@
|
||||
const std = @import("std");
|
||||
const c = @import("c.zig");
|
||||
|
||||
const LayerSurface = @import("layer_surface.zig").LayerSurface;
|
||||
const Output = @import("output.zig").Output;
|
||||
const Server = @import("server.zig").Server;
|
||||
const View = @import("view.zig").View;
|
||||
const ViewStack = @import("view_stack.zig").ViewStack;
|
||||
|
||||
pub fn renderOutput(output: *Output) void {
|
||||
const renderer = output.root.server.wlr_renderer;
|
||||
|
||||
var now: c.struct_timespec = undefined;
|
||||
_ = c.clock_gettime(c.CLOCK_MONOTONIC, &now);
|
||||
|
||||
// wlr_output_attach_render makes the OpenGL context current.
|
||||
if (!c.wlr_output_attach_render(output.wlr_output, null)) {
|
||||
return;
|
||||
}
|
||||
// The "effective" resolution can change if you rotate your outputs.
|
||||
var width: c_int = undefined;
|
||||
var height: c_int = undefined;
|
||||
c.wlr_output_effective_resolution(output.wlr_output, &width, &height);
|
||||
// Begin the renderer (calls glViewport and some other GL sanity checks)
|
||||
c.wlr_renderer_begin(renderer, width, height);
|
||||
|
||||
const color = [_]f32{ 0.0, 0.16862745, 0.21176471, 1.0 };
|
||||
c.wlr_renderer_clear(renderer, &color);
|
||||
|
||||
// The view has a position in layout coordinates. If you have two displays,
|
||||
// one next to the other, both 1080p, a view on the rightmost display might
|
||||
// have layout coordinates of 2000,100. We need to translate that to
|
||||
// output-local coordinates, or (2000 - 1920).
|
||||
var ox: f64 = 0.0;
|
||||
var oy: f64 = 0.0;
|
||||
c.wlr_output_layout_output_coords(
|
||||
output.root.wlr_output_layout,
|
||||
output.wlr_output,
|
||||
&ox,
|
||||
&oy,
|
||||
);
|
||||
|
||||
renderLayer(output.*, output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &now, ox, oy);
|
||||
renderLayer(output.*, output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &now, ox, oy);
|
||||
|
||||
// The first view in the list is "on top" so iterate in reverse.
|
||||
var it = ViewStack.reverseIterator(
|
||||
output.root.views.last,
|
||||
output.root.current_focused_tags,
|
||||
);
|
||||
while (it.next()) |view| {
|
||||
// This check prevents a race condition when a frame is requested
|
||||
// between mapping of a view and the first configure being handled.
|
||||
if (view.current_box.width == 0 or view.current_box.height == 0) {
|
||||
continue;
|
||||
}
|
||||
renderView(output.*, view, &now, ox, oy);
|
||||
renderBorders(output.*, view, &now, ox, oy);
|
||||
}
|
||||
|
||||
renderLayer(output.*, output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_TOP], &now, ox, oy);
|
||||
renderLayer(output.*, output.layers[c.ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &now, ox, oy);
|
||||
|
||||
// Hardware cursors are rendered by the GPU on a separate plane, and can be
|
||||
// moved around without re-rendering what's beneath them - which is more
|
||||
// efficient. However, not all hardware supports hardware cursors. For this
|
||||
// reason, wlroots provides a software fallback, which we ask it to render
|
||||
// here. wlr_cursor handles configuring hardware vs software cursors for you,
|
||||
// and this function is a no-op when hardware cursors are in use.
|
||||
c.wlr_output_render_software_cursors(output.wlr_output, null);
|
||||
|
||||
// Conclude rendering and swap the buffers, showing the final frame
|
||||
// on-screen.
|
||||
c.wlr_renderer_end(renderer);
|
||||
// TODO: handle failure
|
||||
_ = c.wlr_output_commit(output.wlr_output);
|
||||
}
|
||||
|
||||
const LayerSurfaceRenderData = struct {
|
||||
output: *c.wlr_output,
|
||||
renderer: *c.wlr_renderer,
|
||||
layer_surface: *LayerSurface,
|
||||
when: *c.struct_timespec,
|
||||
ox: f64,
|
||||
oy: f64,
|
||||
};
|
||||
|
||||
/// Render all surfaces on the passed layer
|
||||
fn renderLayer(output: Output, layer: std.TailQueue(LayerSurface), now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
var it = layer.first;
|
||||
while (it) |node| : (it = node.next) {
|
||||
const layer_surface = &node.data;
|
||||
var rdata = LayerSurfaceRenderData{
|
||||
.output = output.wlr_output,
|
||||
.renderer = output.root.server.wlr_renderer,
|
||||
.layer_surface = layer_surface,
|
||||
.when = now,
|
||||
.ox = ox,
|
||||
.oy = oy,
|
||||
};
|
||||
c.wlr_layer_surface_v1_for_each_surface(
|
||||
layer_surface.wlr_layer_surface,
|
||||
renderLayerSurface,
|
||||
&rdata,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// This function is called for every layer surface and popup that needs to be rendered.
|
||||
/// TODO: refactor this to reduce code duplication
|
||||
fn renderLayerSurface(_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void {
|
||||
// wlroots says this will never be null
|
||||
const surface = _surface.?;
|
||||
// This function is called for every surface that needs to be rendered.
|
||||
const rdata = @ptrCast(*LayerSurfaceRenderData, @alignCast(@alignOf(LayerSurfaceRenderData), data));
|
||||
const layer_surface = rdata.layer_surface;
|
||||
const output = rdata.output;
|
||||
|
||||
// We first obtain a wlr_texture, which is a GPU resource. wlroots
|
||||
// automatically handles negotiating these with the client. The underlying
|
||||
// resource could be an opaque handle passed from the client, or the client
|
||||
// could have sent a pixel buffer which we copied to the GPU, or a few other
|
||||
// means. You don't have to worry about this, wlroots takes care of it.
|
||||
const texture = c.wlr_surface_get_texture(surface);
|
||||
if (texture == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
var box = c.wlr_box{
|
||||
.x = @floatToInt(c_int, rdata.ox) + layer_surface.box.x + sx,
|
||||
.y = @floatToInt(c_int, rdata.oy) + layer_surface.box.y + sy,
|
||||
.width = surface.current.width,
|
||||
.height = surface.current.height,
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, output.scale);
|
||||
|
||||
// wlr_matrix_project_box is a helper which takes a box with a desired
|
||||
// x, y coordinates, width and height, and an output geometry, then
|
||||
// prepares an orthographic projection and multiplies the necessary
|
||||
// transforms to produce a model-view-projection matrix.
|
||||
var matrix: [9]f32 = undefined;
|
||||
const transform = c.wlr_output_transform_invert(surface.current.transform);
|
||||
c.wlr_matrix_project_box(&matrix, &box, transform, 0.0, &output.transform_matrix);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(rdata.renderer, texture, &matrix, 1.0);
|
||||
|
||||
// This lets the client know that we've displayed that frame and it can
|
||||
// prepare another one now if it likes.
|
||||
c.wlr_surface_send_frame_done(surface, rdata.when);
|
||||
}
|
||||
|
||||
const ViewRenderData = struct {
|
||||
output: *c.wlr_output,
|
||||
renderer: *c.wlr_renderer,
|
||||
view: *View,
|
||||
when: *c.struct_timespec,
|
||||
ox: f64,
|
||||
oy: f64,
|
||||
};
|
||||
|
||||
fn renderView(output: Output, view: *View, now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
// If we have a stashed buffer, we are in the middle of a transaction
|
||||
// and need to render that buffer until the transaction is complete.
|
||||
if (view.stashed_buffer) |buffer| {
|
||||
const border_width = view.root.server.config.border_width;
|
||||
const view_padding = view.root.server.config.view_padding;
|
||||
var box = c.wlr_box{
|
||||
.x = view.current_box.x + @intCast(i32, border_width + view_padding),
|
||||
.y = view.current_box.y + @intCast(i32, border_width + view_padding),
|
||||
.width = @intCast(c_int, view.current_box.width - border_width * 2 - view_padding * 2),
|
||||
.height = @intCast(c_int, view.current_box.height - border_width * 2 - view_padding * 2),
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, output.wlr_output.scale);
|
||||
|
||||
var matrix: [9]f32 = undefined;
|
||||
c.wlr_matrix_project_box(
|
||||
&matrix,
|
||||
&box,
|
||||
c.enum_wl_output_transform.WL_OUTPUT_TRANSFORM_NORMAL,
|
||||
0.0,
|
||||
&output.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(
|
||||
output.root.server.wlr_renderer,
|
||||
buffer.texture,
|
||||
&matrix,
|
||||
1.0,
|
||||
);
|
||||
} else {
|
||||
// Since there is no stashed buffer, we are not in the middle of
|
||||
// a transaction and may simply render each toplevel surface.
|
||||
var rdata = ViewRenderData{
|
||||
.output = output.wlr_output,
|
||||
.view = view,
|
||||
.renderer = output.root.server.wlr_renderer,
|
||||
.when = now,
|
||||
.ox = ox,
|
||||
.oy = oy,
|
||||
};
|
||||
|
||||
// This calls our render_surface function for each surface among the
|
||||
// xdg_surface's toplevel and popups.
|
||||
c.wlr_xdg_surface_for_each_surface(view.wlr_xdg_surface, renderSurface, &rdata);
|
||||
}
|
||||
}
|
||||
|
||||
/// This function is called for every toplevel and popup surface that needs to be rendered.
|
||||
fn renderSurface(_surface: ?*c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void {
|
||||
// wlroots says this will never be null
|
||||
const surface = _surface.?;
|
||||
const rdata = @ptrCast(*ViewRenderData, @alignCast(@alignOf(ViewRenderData), data));
|
||||
const view = rdata.view;
|
||||
const output = rdata.output;
|
||||
|
||||
// We first obtain a wlr_texture, which is a GPU resource. wlroots
|
||||
// automatically handles negotiating these with the client. The underlying
|
||||
// resource could be an opaque handle passed from the client, or the client
|
||||
// could have sent a pixel buffer which we copied to the GPU, or a few other
|
||||
// means. You don't have to worry about this, wlroots takes care of it.
|
||||
const texture = c.wlr_surface_get_texture(surface);
|
||||
if (texture == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
const border_width = view.root.server.config.border_width;
|
||||
const view_padding = view.root.server.config.view_padding;
|
||||
var box = c.wlr_box{
|
||||
.x = @floatToInt(c_int, rdata.ox) + view.current_box.x + sx +
|
||||
@intCast(c_int, border_width + view_padding),
|
||||
.y = @floatToInt(c_int, rdata.oy) + view.current_box.y + sy +
|
||||
@intCast(c_int, border_width + view_padding),
|
||||
.width = surface.current.width,
|
||||
.height = surface.current.height,
|
||||
};
|
||||
|
||||
// Scale the box to the output's current scaling factor
|
||||
scaleBox(&box, output.scale);
|
||||
|
||||
// wlr_matrix_project_box is a helper which takes a box with a desired
|
||||
// x, y coordinates, width and height, and an output geometry, then
|
||||
// prepares an orthographic projection and multiplies the necessary
|
||||
// transforms to produce a model-view-projection matrix.
|
||||
var matrix: [9]f32 = undefined;
|
||||
const transform = c.wlr_output_transform_invert(surface.current.transform);
|
||||
c.wlr_matrix_project_box(&matrix, &box, transform, 0.0, &output.transform_matrix);
|
||||
|
||||
// This takes our matrix, the texture, and an alpha, and performs the actual
|
||||
// rendering on the GPU.
|
||||
_ = c.wlr_render_texture_with_matrix(rdata.renderer, texture, &matrix, 1.0);
|
||||
|
||||
// This lets the client know that we've displayed that frame and it can
|
||||
// prepare another one now if it likes.
|
||||
c.wlr_surface_send_frame_done(surface, rdata.when);
|
||||
}
|
||||
|
||||
fn renderBorders(output: Output, view: *View, now: *c.struct_timespec, ox: f64, oy: f64) void {
|
||||
var border: c.wlr_box = undefined;
|
||||
const color = if (output.root.focused_view == view)
|
||||
[_]f32{ 0.57647059, 0.63137255, 0.63137255, 1.0 } // Solarized base1
|
||||
else
|
||||
[_]f32{ 0.34509804, 0.43137255, 0.45882353, 1.0 }; // Solarized base01
|
||||
const border_width = output.root.server.config.border_width;
|
||||
const view_padding = output.root.server.config.view_padding;
|
||||
|
||||
// left border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x + @intCast(c_int, view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y + @intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, border_width);
|
||||
border.height = @intCast(c_int, view.current_box.height - view_padding * 2);
|
||||
scaleBox(&border, output.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
output.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&output.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// right border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, view.current_box.width - border_width - view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y + @intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, border_width);
|
||||
border.height = @intCast(c_int, view.current_box.height - view_padding * 2);
|
||||
scaleBox(&border, output.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
output.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&output.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// top border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, border_width + view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y +
|
||||
@intCast(c_int, view_padding);
|
||||
border.width = @intCast(c_int, view.current_box.width -
|
||||
border_width * 2 - view_padding * 2);
|
||||
border.height = @intCast(c_int, border_width);
|
||||
scaleBox(&border, output.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
output.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&output.wlr_output.transform_matrix,
|
||||
);
|
||||
|
||||
// bottom border
|
||||
border.x = @floatToInt(c_int, ox) + view.current_box.x +
|
||||
@intCast(c_int, border_width + view_padding);
|
||||
border.y = @floatToInt(c_int, oy) + view.current_box.y +
|
||||
@intCast(c_int, view.current_box.height - border_width - view_padding);
|
||||
border.width = @intCast(c_int, view.current_box.width -
|
||||
border_width * 2 - view_padding * 2);
|
||||
border.height = @intCast(c_int, border_width);
|
||||
scaleBox(&border, output.wlr_output.scale);
|
||||
c.wlr_render_rect(
|
||||
output.root.server.wlr_renderer,
|
||||
&border,
|
||||
&color,
|
||||
&output.wlr_output.transform_matrix,
|
||||
);
|
||||
}
|
||||
|
||||
/// Scale a wlr_box, taking the possibility of fractional scaling into account.
|
||||
fn scaleBox(box: *c.wlr_box, scale: f64) void {
|
||||
box.x = @floatToInt(c_int, @round(@intToFloat(f64, box.x) * scale));
|
||||
box.y = @floatToInt(c_int, @round(@intToFloat(f64, box.y) * scale));
|
||||
box.width = scaleLength(box.width, box.x, scale);
|
||||
box.height = scaleLength(box.height, box.x, scale);
|
||||
}
|
||||
|
||||
/// Scales a width/height.
|
||||
///
|
||||
/// This might seem overly complex, but it needs to work for fractional scaling.
|
||||
fn scaleLength(length: c_int, offset: c_int, scale: f64) c_int {
|
||||
return @floatToInt(c_int, @round(@intToFloat(f64, offset + length) * scale) -
|
||||
@round(@intToFloat(f64, offset) * scale));
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user