1 files changed, 63 insertions, 0 deletions
diff --git a/src/render.zig b/src/render.zig
new file mode 100644
index 0000000..dc03de1
--- /dev/null
+++ b/src/render.zig
@@ -0,0 +1,63 @@
+const RenderData = struct {
+    output: *c.wlr_output,
+    renderer: *c.wlr_renderer,
+    view: *View,
+    when: *c.struct_timespec,
+};
+
+fn render_surface(surface: [*c]c.wlr_surface, sx: c_int, sy: c_int, data: ?*c_void) callconv(.C) void {
+    // This function is called for every surface that needs to be rendered.
+    var rdata = @ptrCast(*RenderData, @alignCast(@alignOf(RenderData), data));
+    var view = rdata.*.view;
+    var 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.
+    var texture = c.wlr_surface_get_texture(surface);
+    if (texture == null) {
+        return;
+    }
+
+    // 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(view.*.server.*.output_layout, output, &ox, &oy);
+    ox += @intToFloat(f64, view.*.x + sx);
+    oy += @intToFloat(f64, view.*.y + sy);
+
+    // We also have to apply the scale factor for HiDPI outputs. This is only
+    // part of the puzzle, TinyWL does not fully support HiDPI.
+    var box = c.wlr_box{
+        .x = @floatToInt(c_int, ox * output.*.scale),
+        .y = @floatToInt(c_int, oy * output.*.scale),
+        .width = @floatToInt(c_int, @intToFloat(f32, surface.*.current.width) * output.*.scale),
+        .height = @floatToInt(c_int, @intToFloat(f32, surface.*.current.height) * output.*.scale),
+    };
+
+    // Those familiar with OpenGL are also familiar with the role of matricies
+    // in graphics programming. We need to prepare a matrix to render the view
+    // with. 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.
+    //
+    // Naturally you can do this any way you like, for example to make a 3D
+    // compositor.
+    var matrix: [9]f32 = undefined;
+    var 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);
+}