//! Vector graphics for sketches: SVG in, cubic geometry as data, and two //! interchangeable renderers. The CPU backend computes exact coverage and //! runs anywhere (it is also the reference in tests); the GPU backend //! describes stencil-then-cover passes for the host to run. The backend is //! a comptime choice: `vector.Renderer(.gpu)` or `vector.Renderer(.cpu)`. const std = @import("std"); const abi = @import("abi"); pub const geom = @import("geom.zig"); pub const Drawing = @import("Drawing.zig"); pub const svg = @import("svg.zig"); pub const Polygons = @import("Polygons.zig"); pub const Paint = @import("Paint.zig"); pub const Cpu = @import("Cpu.zig"); pub const Gpu = @import("Gpu.zig"); pub const layouts = @import("vector_layouts"); pub const morph = @import("morph.zig"); pub const Backend = enum { cpu, gpu }; pub const Options = struct { /// Multiplies everything the shape draws. alpha: f32 = 1, fill: bool = true, stroke: bool = true, /// Also outline the shape in its fill color, `width` device pixels wide /// (manim's Write draws glyph borders before filling them). outline: ?struct { width: f32, alpha: f32 = 1 } = null, /// The drawn fraction of strokes and outlines, along their length. trim: f32 = 1, }; /// Draws drawings into an image of `width` x `height` pixels. `host` is a /// `sketch.Host`; `f` a `sketch.Frame`. Both are duck-typed, so the library /// depends on nothing but the ABI. pub fn Renderer(comptime backend: Backend) type { return struct { const Self = @This(); pub const kind = backend; target: switch (backend) { .cpu => Cpu, .gpu => Gpu, }, polys: Polygons, image: abi.Image, pub fn init(gpa: std.mem.Allocator, host: anytype, w: u32, h: u32) !Self { const image = host.newImage(w, h); return .{ .target = switch (backend) { .cpu => try .init(gpa, w, h), .gpu => .{ .width = w, .height = h, .image = image }, }, .polys = .init(gpa), .image = image, }; } pub fn deinit(r: *Self, host: anytype) void { if (backend == .cpu) r.target.deinit(); r.polys.deinit(); host.freeImage(r.image); } pub fn width(r: *const Self) u32 { return r.target.width; } pub fn height(r: *const Self) u32 { return r.target.height; } /// Starts a picture. `f.arena` holds what the GPU pass needs until /// the frame is consumed. pub fn begin(r: *Self, f: anytype, clear: Drawing.Color) void { switch (backend) { .cpu => r.target.clear(clear), .gpu => r.target.begin(f.arena, clear), } } /// All shapes of `d`; `m` maps its user space to pixels. pub fn draw(r: *Self, d: Drawing, m: geom.Affine, alpha: f32) !void { for (d.shapes) |shape| try r.drawShape(d, shape, m, .{ .alpha = alpha }); } pub fn drawShape(r: *Self, d: Drawing, shape: Drawing.Shape, user_to_device: geom.Affine, o: Options) !void { const m = user_to_device.mul(shape.transform); const s = shape.style; const clip: ?[4]geom.Vec = if (shape.clip) |q| .{ user_to_device.apply(q[0]), user_to_device.apply(q[1]), user_to_device.apply(q[2]), user_to_device.apply(q[3]) } else null; if (o.fill and s.fill != .none) { r.polys.clear(); try r.polys.fill(d, shape, m); if (clip) |q| try r.polys.clipConvex(q); r.fill(s.fill_rule, &Paint.of(d, shape, s.fill, m), o.alpha * s.opacity * s.fill_opacity); } if (o.stroke and s.stroke != .none and s.stroke_width > 0) { var st: Polygons.Stroke = .of(s, m); st.dashes = s.dashes[0..s.dash_count]; st.trim = o.trim; r.polys.clear(); try r.polys.stroke(d, shape, m, st); if (clip) |q| try r.polys.clipConvex(q); r.fill(.nonzero, &Paint.of(d, shape, s.stroke, m), o.alpha * s.opacity * s.stroke_opacity); } if (o.outline) |outline| if (s.fill != .none) { r.polys.clear(); try r.polys.stroke(d, shape, m, .{ .width = outline.width, .cap = .round, .join = .round, .trim = o.trim, .space = .identity }); r.fill(.nonzero, &Paint.of(d, shape, s.fill, m), o.alpha * s.opacity * outline.alpha); }; } /// Fills whatever is in `r.polys`. pub fn fill(r: *Self, rule: Drawing.FillRule, paint: *const Paint, alpha: f32) void { r.target.fill(&r.polys, rule, paint, alpha); } /// Hands the picture to the host and draws it at `dst`. pub fn present(r: *Self, f: anytype, dst: anytype) void { switch (backend) { .cpu => f.pixels(r.image, r.target.width, r.target.height, r.target.pixels, .{ .premultiplied = true }), .gpu => f.gpu(r.target.pass()), } f.image(r.image, dst, .{}); } }; } /// The transform placing a drawing's view box into `dst`, centered and /// scaled to fit (SVG's default `xMidYMid meet`). pub fn fit(d: Drawing, dst: geom.Rect) geom.Affine { const v = d.view; if (v.w <= 0 or v.h <= 0) return .translate(dst.x, dst.y); const s = @min(dst.w / v.w, dst.h / v.h); return geom.Affine.translate(dst.x + (dst.w - v.w * s) / 2, dst.y + (dst.h - v.h * s) / 2).mul(.scale(s, s)).mul(.translate(-v.x, -v.y)); } test { _ = morph; _ = geom; _ = svg; _ = Polygons; _ = Cpu; _ = Gpu; }