Added a Rust runtime.
This patch adds a Rust runtime, rive-rs, that binds to rive-cpp and includes an optional Vello back-end. It also ports the Vello demo to this new runtime.
Stuff to do before merging:
- [ ] README.md & CONTRIBUTING.md
- [x] set up repo pushing
- [x] make more types public
- [x] events API
Diffs=
52a1a6f88 Added a Rust runtime. (#6027)
Co-authored-by: Dragoș Tiselice <dragos@rive.app>
diff --git a/.rive_head b/.rive_head
index 8da8b8d..413d351 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-22077bedae4c277e5e8a81c732167ab5d559917c
+52a1a6f8888c9134de8dce0393dd3b0d6757f7de
diff --git a/vello/Cargo.toml b/vello/Cargo.toml
index 4a4d533..255a639 100644
--- a/vello/Cargo.toml
+++ b/vello/Cargo.toml
@@ -3,15 +3,9 @@
version = "0.1.0"
edition = "2021"
-[build-dependencies]
-cc = { version = "1.0", features = ["parallel"] }
-walkdir = "2.3.3"
-
[dependencies]
-clap = { version = "4.3.19", features = ["derive"] }
-image = "0.24.6"
pollster = "0.3.0"
-smallvec = "1.8.0"
-vello = { git = "https://github.com/linebender/vello", rev = "3cb5462" }
+rive-rs = { path = "../../rive_rs", features = ["vello"] }
+vello = { workspace = true }
wgpu = "0.17.0"
winit = "0.28.6"
diff --git a/vello/build.rs b/vello/build.rs
deleted file mode 100644
index 0f7163d..0000000
--- a/vello/build.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use std::{
- env,
- ffi::OsString,
- path::{Path, PathBuf},
- process::Command,
-};
-
-use walkdir::WalkDir;
-
-const CHECKOUT_DIRECTORY: &str = "target";
-
-struct Checkout {
- path: PathBuf,
-}
-
-impl Checkout {
- pub fn new(repo: &str, tag: &str) -> Self {
- let name = repo.rsplit_once('/').expect("URL format invalid").1;
- let mut path = PathBuf::from(CHECKOUT_DIRECTORY);
-
- path.push(name);
-
- if !path.is_dir() {
- Command::new("git")
- .args([
- "clone",
- "-b",
- tag,
- repo,
- &path.as_os_str().to_string_lossy(),
- ])
- .output()
- .unwrap_or_else(|_| panic!("failed to clone {}; is git CLI available?", name));
- }
-
- Self { path }
- }
-
- pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {
- self.path.join(path)
- }
-}
-
-fn all_files_with_extension<P: AsRef<Path>>(
- path: P,
- extension: &str,
-) -> impl Iterator<Item = PathBuf> + '_ {
- WalkDir::new(path).into_iter().filter_map(move |entry| {
- entry
- .ok()
- .map(|entry| entry.into_path())
- .filter(|path| path.extension() == Some(&OsString::from(extension)))
- })
-}
-
-fn main() {
- println!("cargo:rerun-if-changed=src/vello_renderer.hpp");
- println!("cargo:rerun-if-changed=src/vello_renderer.cpp");
- println!("cargo:rerun-if-changed=src/winit_viewer.cpp");
-
- let harfbuzz = Checkout::new("https://github.com/harfbuzz/harfbuzz", "8.1.1");
- let sheen_bidi = Checkout::new("https://github.com/Tehreer/SheenBidi", "v2.6");
-
- let target = env::var("TARGET").unwrap();
- let profile = env::var("PROFILE").unwrap();
-
- let mut cfg = cc::Build::new();
- cfg.cpp(true)
- .flag_if_supported("-std=c++11") // for unix
- .warnings(false)
- .file(harfbuzz.join("src/harfbuzz.cc"));
-
- if !target.contains("windows") {
- cfg.define("HAVE_PTHREAD", "1");
- }
-
- if target.contains("apple") && profile.contains("release") {
- cfg.define("HAVE_CORETEXT", "1");
- }
-
- if target.contains("windows") {
- cfg.define("HAVE_DIRECTWRITE", "1");
- }
-
- if target.contains("windows-gnu") {
- cfg.flag("-Wa,-mbig-obj");
- }
-
- cfg.compile("harfbuzz");
-
- cc::Build::new()
- .files(all_files_with_extension(sheen_bidi.join("Source"), "c"))
- .include(sheen_bidi.join("Headers"))
- .warnings(false)
- .compile("sheenbidi");
-
- cc::Build::new()
- .cpp(true)
- .files(all_files_with_extension("../src", "cpp"))
- .files(all_files_with_extension(
- "../viewer/src/viewer_content",
- "cpp",
- ))
- .file("src/vello_renderer.cpp")
- .file("src/winit_viewer.cpp")
- .include("src")
- .include("../include")
- .include("../viewer/include")
- .include(harfbuzz.join("src"))
- .include(sheen_bidi.join("Headers"))
- .flag("-std=c++14")
- .warnings(false)
- .define("RIVE_SKIP_IMGUI", None)
- .define("WITH_RIVE_TEXT", None)
- .compile("rive");
-}
diff --git a/vello/src/lib.rs b/vello/src/lib.rs
deleted file mode 100644
index f50f50a..0000000
--- a/vello/src/lib.rs
+++ /dev/null
@@ -1,564 +0,0 @@
-#![allow(clippy::missing_safety_doc)]
-
-use core::slice;
-use std::{io::Cursor, ptr::NonNull};
-
-use image::io::Reader;
-use smallvec::SmallVec;
-use util::{ScaleFromOrigin, UnwrapAndDeref};
-use vello::{
- kurbo::{Affine, BezPath, Line, PathSeg, Point, Rect, Shape, Vec2},
- peniko::{
- BlendMode, Brush, BrushRef, Cap, Color, ColorStop, ColorStopsSource, Fill, Format,
- Gradient, Image, Join, Mix, Stroke,
- },
- SceneBuilder, SceneFragment,
-};
-
-mod rive;
-mod util;
-mod viewer;
-
-pub use viewer::ViewerContent;
-
-fn from_bgra8(color: u32) -> Color {
- Color::rgba8(
- (color >> 16) as u8,
- (color >> 8) as u8,
- color as u8,
- (color >> 24) as u8,
- )
-}
-
-#[derive(Debug)]
-enum RenderStyle {
- Fill,
- Stroke(Stroke),
-}
-
-#[derive(Debug)]
-struct SliceStops<'s> {
- colors: &'s [u32],
- stops: &'s [f32],
-}
-
-impl ColorStopsSource for SliceStops<'_> {
- fn collect_stops(&self, vec: &mut SmallVec<[ColorStop; 4]>) {
- vec.extend(
- self.colors
- .iter()
- .zip(self.stops.iter())
- .map(|(&color, &offset)| ColorStop {
- offset,
- color: from_bgra8(color),
- }),
- );
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_gradient_new_linear(
- sx: f32,
- sy: f32,
- ex: f32,
- ey: f32,
- colors_data: *const u32,
- stops_data: *const f32,
- len: usize,
-) -> Option<NonNull<Gradient>> {
- let colors = slice::from_raw_parts(colors_data, len);
- let stops = slice::from_raw_parts(stops_data, len);
-
- let raw_stops = SliceStops { colors, stops };
- let gradient =
- Gradient::new_linear((sx as f64, sy as f64), (ex as f64, ey as f64)).with_stops(raw_stops);
-
- NonNull::new(Box::into_raw(Box::new(gradient)))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_gradient_new_radial(
- cx: f32,
- cy: f32,
- radius: f32,
- colors_data: *const u32,
- stops_data: *const f32,
- len: usize,
-) -> Option<NonNull<Gradient>> {
- let colors = slice::from_raw_parts(colors_data, len);
- let stops = slice::from_raw_parts(stops_data, len);
-
- let raw_stops = SliceStops { colors, stops };
- let gradient = Gradient::new_radial((cx as f64, cy as f64), radius).with_stops(raw_stops);
-
- NonNull::new(Box::into_raw(Box::new(gradient)))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_gradient_release(gradient: Option<NonNull<Gradient>>) {
- gradient.map(|ptr| Box::from_raw(ptr.as_ptr())).unwrap();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_image_new(data: *const u8, len: usize) -> Option<NonNull<Image>> {
- let image = Reader::new(Cursor::new(slice::from_raw_parts(data, len)))
- .with_guessed_format()
- .ok()?
- .decode()
- .ok()?
- .into_rgba8();
- let width = image.width();
- let height = image.height();
-
- NonNull::new(Box::into_raw(Box::new(Image::new(
- image.into_raw().into(),
- Format::Rgba8,
- width,
- height,
- ))))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_image_release(image: Option<NonNull<Image>>) {
- image.map(|ptr| Box::from_raw(ptr.as_ptr())).unwrap();
-}
-
-#[derive(Debug)]
-pub struct VelloPaint {
- style: RenderStyle,
- brush: Brush,
- blend_mode: BlendMode,
-}
-
-impl Default for VelloPaint {
- fn default() -> Self {
- Self {
- style: RenderStyle::Fill,
- brush: Brush::Solid(Color::TRANSPARENT),
- blend_mode: Mix::Normal.into(),
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_new() -> Option<NonNull<VelloPaint>> {
- NonNull::new(Box::into_raw(Box::default()))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_release(paint: Option<NonNull<VelloPaint>>) {
- paint.map(|ptr| Box::from_raw(ptr.as_ptr())).unwrap();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_style(
- mut paint: Option<NonNull<VelloPaint>>,
- style: rive::RenderPaint,
-) {
- paint.unwrap_and_deref().style = style.into();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_color(mut paint: Option<NonNull<VelloPaint>>, color: u32) {
- paint.unwrap_and_deref().brush = Brush::Solid(from_bgra8(color));
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_gradient(
- mut paint: Option<NonNull<VelloPaint>>,
- mut gradient: Option<NonNull<Gradient>>,
-) {
- paint.unwrap_and_deref().brush = Brush::Gradient(gradient.unwrap_and_deref().clone());
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_thickness(
- mut paint: Option<NonNull<VelloPaint>>,
- thickness: f32,
-) {
- let style = &mut paint.unwrap_and_deref().style;
- loop {
- if let RenderStyle::Stroke(stroke) = style {
- stroke.width = thickness;
- break;
- } else {
- *style = RenderStyle::Stroke(Stroke::new(0.0));
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_join(
- mut paint: Option<NonNull<VelloPaint>>,
- join: rive::StrokeJoin,
-) {
- let style = &mut paint.unwrap_and_deref().style;
- loop {
- if let RenderStyle::Stroke(stroke) = style {
- stroke.join = match join {
- rive::StrokeJoin::Miter => Join::Miter,
- rive::StrokeJoin::Round => Join::Round,
- rive::StrokeJoin::Bevel => Join::Bevel,
- };
- break;
- } else {
- *style = RenderStyle::Stroke(Stroke::new(0.0));
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_cap(
- mut paint: Option<NonNull<VelloPaint>>,
- cap: rive::StrokeCap,
-) {
- let style = &mut paint.unwrap_and_deref().style;
- loop {
- if let RenderStyle::Stroke(stroke) = style {
- stroke.start_cap = match cap {
- rive::StrokeCap::Butt => Cap::Butt,
- rive::StrokeCap::Round => Cap::Round,
- rive::StrokeCap::Square => Cap::Square,
- };
- stroke.end_cap = stroke.start_cap;
- break;
- } else {
- *style = RenderStyle::Stroke(Stroke::new(0.0));
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_paint_set_blend_mode(
- mut paint: Option<NonNull<VelloPaint>>,
- blend_mode: rive::BlendMode,
-) {
- let mix: Mix = blend_mode.into();
- paint.unwrap_and_deref().blend_mode = mix.into();
-}
-
-#[derive(Debug)]
-pub struct VelloPath {
- path: BezPath,
- fill: Fill,
-}
-
-impl Default for VelloPath {
- fn default() -> Self {
- Self {
- path: Default::default(),
- fill: Fill::NonZero,
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_new() -> Option<NonNull<VelloPath>> {
- NonNull::new(Box::into_raw(Box::default()))
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_release(path: Option<NonNull<VelloPath>>) {
- path.map(|ptr| Box::from_raw(ptr.as_ptr())).unwrap();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_set_fill_rule(
- mut path: Option<NonNull<VelloPath>>,
- fill_rule: rive::FillRule,
-) {
- path.unwrap_and_deref().fill = match fill_rule {
- rive::FillRule::NonZero => Fill::NonZero,
- rive::FillRule::EvenOdd => Fill::EvenOdd,
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_rewind(mut path: Option<NonNull<VelloPath>>) {
- path.unwrap_and_deref().path.truncate(0);
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_extend(
- mut path: Option<NonNull<VelloPath>>,
- mut from: Option<NonNull<VelloPath>>,
- mut transform: Option<NonNull<[f32; 6]>>,
-) {
- let mut from = from.unwrap_and_deref().path.clone();
- from.apply_affine(Affine::new(transform.unwrap_and_deref().map(Into::into)));
-
- path.unwrap_and_deref()
- .path
- .extend(from.elements().iter().cloned());
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_move_to(mut path: Option<NonNull<VelloPath>>, x: f32, y: f32) {
- path.unwrap_and_deref()
- .path
- .move_to(Point::new(x as f64, y as f64));
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_line_to(mut path: Option<NonNull<VelloPath>>, x: f32, y: f32) {
- path.unwrap_and_deref()
- .path
- .line_to(Point::new(x as f64, y as f64));
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_cubic_to(
- mut path: Option<NonNull<VelloPath>>,
- ox: f32,
- oy: f32,
- ix: f32,
- iy: f32,
- x: f32,
- y: f32,
-) {
- path.unwrap_and_deref().path.curve_to(
- Point::new(ox as f64, oy as f64),
- Point::new(ix as f64, iy as f64),
- Point::new(x as f64, y as f64),
- );
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_path_close(mut path: Option<NonNull<VelloPath>>) {
- path.unwrap_and_deref().path.close_path();
-}
-
-pub struct VelloRenderer {
- pub scene: Box<SceneFragment>,
- builder: SceneBuilder<'static>,
- transforms: Vec<Affine>,
- clips: Vec<bool>,
-}
-
-impl VelloRenderer {
- fn last_transform(&mut self) -> &mut Affine {
- self.transforms.last_mut().unwrap()
- }
-
- fn last_clip(&mut self) -> &mut bool {
- self.clips.last_mut().unwrap()
- }
-}
-
-impl Default for VelloRenderer {
- fn default() -> Self {
- let mut scene = Box::<SceneFragment>::default();
- let builder = {
- let scene_mut: &mut SceneFragment = &mut scene;
- SceneBuilder::for_fragment(unsafe {
- // Quite a hack until we have a better way to do this in Vello.
- // Pretend that the scene fragment pointer lives for 'static.
- std::mem::transmute(scene_mut)
- })
- };
-
- Self {
- scene,
- builder,
- transforms: vec![Affine::IDENTITY],
- clips: vec![false],
- }
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_save(mut renderer: Option<NonNull<VelloRenderer>>) {
- let renderer = renderer.unwrap_and_deref();
-
- let last_transform = *renderer.last_transform();
-
- renderer.transforms.push(last_transform);
- renderer.clips.push(false);
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_restore(mut renderer: Option<NonNull<VelloRenderer>>) {
- let renderer = renderer.unwrap_and_deref();
-
- renderer.transforms.pop();
- if renderer.clips.pop().unwrap_or_default() {
- renderer.builder.pop_layer();
- }
-
- if renderer.transforms.is_empty() {
- renderer.transforms.push(Affine::IDENTITY);
- renderer.clips.push(false);
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_transform(
- mut renderer: Option<NonNull<VelloRenderer>>,
- transform: *const [f32; 6],
-) {
- let last_transform = renderer.unwrap_and_deref().last_transform();
- *last_transform *= Affine::new((*transform).map(Into::into));
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_draw_path(
- mut renderer: Option<NonNull<VelloRenderer>>,
- mut path: Option<NonNull<VelloPath>>,
- mut paint: Option<NonNull<VelloPaint>>,
-) {
- let renderer = renderer.unwrap_and_deref();
- let path = path.unwrap_and_deref();
- let paint = paint.unwrap_and_deref();
-
- let transform = *renderer.last_transform();
-
- let builder = &mut renderer.builder;
-
- let skip_blending = paint.blend_mode == Mix::Normal.into();
-
- if !skip_blending {
- builder.push_layer(paint.blend_mode, 1.0, transform, &path.path.bounding_box());
- }
-
- match &paint.style {
- RenderStyle::Fill => builder.fill(path.fill, transform, &paint.brush, None, &path.path),
- RenderStyle::Stroke(stroke) => {
- builder.stroke(stroke, transform, &paint.brush, None, &path.path)
- }
- }
-
- if !skip_blending {
- builder.pop_layer();
- }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_clip_path(
- mut renderer: Option<NonNull<VelloRenderer>>,
- mut clip: Option<NonNull<VelloPath>>,
-) {
- let renderer = renderer.unwrap_and_deref();
-
- let transform = *renderer.last_transform();
-
- if *renderer.last_clip() {
- renderer.builder.pop_layer();
- }
-
- renderer
- .builder
- .push_layer(Mix::Clip, 1.0, transform, &clip.unwrap_and_deref().path);
-
- *renderer.last_clip() = true;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_draw_image(
- mut renderer: Option<NonNull<VelloRenderer>>,
- mut image: Option<NonNull<Image>>,
- blend_mode: rive::BlendMode,
- opacity: f32,
-) {
- let renderer = renderer.unwrap_and_deref();
- let image = image.unwrap_and_deref();
- let mix: Mix = blend_mode.into();
-
- let transform = renderer.last_transform().pre_translate(Vec2::new(
- image.width as f64 * -0.5,
- image.height as f64 * -0.5,
- ));
- let rect = Rect::new(0.0, 0.0, image.width as f64, image.height as f64);
-
- let builder = &mut renderer.builder;
-
- let skip_blending = mix == Mix::Normal && opacity == 1.0;
-
- if skip_blending {
- builder.push_layer(mix, opacity, transform, &rect);
- }
-
- builder.draw_image(image, transform);
-
- if skip_blending {
- builder.pop_layer();
- }
-}
-
-fn triangle_path(points: [Point; 3]) -> BezPath {
- BezPath::from_path_segments(
- [
- PathSeg::Line(Line::new(points[0], points[1])),
- PathSeg::Line(Line::new(points[1], points[2])),
- PathSeg::Line(Line::new(points[2], points[0])),
- ]
- .into_iter(),
- )
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn vello_renderer_draw_image_mesh(
- mut renderer: Option<NonNull<VelloRenderer>>,
- mut image: Option<NonNull<Image>>,
- vertices_data: *const rive::Vec2D,
- vertices_len: usize,
- uvs_data: *const rive::Vec2D,
- uvs_len: usize,
- indices_data: *const u16,
- indices_len: usize,
- blend_mode: rive::BlendMode,
- opacity: f32,
-) {
- let renderer = renderer.unwrap_and_deref();
- let image = image.unwrap_and_deref();
-
- let vertices = slice::from_raw_parts(vertices_data, vertices_len);
- let uvs = slice::from_raw_parts(uvs_data, uvs_len);
- let indices = slice::from_raw_parts(indices_data, indices_len);
-
- let mix: Mix = blend_mode.into();
-
- for triangle_indices in indices.chunks_exact(3) {
- let points = [
- vertices[triangle_indices[0] as usize],
- vertices[triangle_indices[1] as usize],
- vertices[triangle_indices[2] as usize],
- ];
- let uvs = [
- uvs[triangle_indices[0] as usize],
- uvs[triangle_indices[1] as usize],
- uvs[triangle_indices[2] as usize],
- ];
-
- let center = Point::new(
- ((points[0].x + points[1].x + points[2].x) / 3.0) as f64,
- ((points[0].y + points[1].y + points[2].y) / 3.0) as f64,
- );
-
- let path = triangle_path(points.map(|v| Point::new(v.x as f64, v.y as f64)));
-
- let transform = renderer
- .last_transform()
- .pre_scale_from_origin(1.03, center);
- let brush_transform = util::map_uvs_to_triangle(&points, &uvs, image.width, image.height);
-
- let builder = &mut renderer.builder;
-
- let skip_blending = mix == Mix::Normal;
-
- if !skip_blending {
- builder.push_layer(mix, opacity, transform, &path.bounding_box());
- }
-
- builder.fill(
- Fill::NonZero,
- transform,
- BrushRef::Image(image),
- Some(brush_transform),
- &path,
- );
-
- if !skip_blending {
- builder.pop_layer();
- }
- }
-}
diff --git a/vello/src/main.rs b/vello/src/main.rs
index 06a4dc0..9bb6c32 100644
--- a/vello/src/main.rs
+++ b/vello/src/main.rs
@@ -1,6 +1,6 @@
-use std::time::Instant;
+use std::{fs, time::Instant};
-use rive_vello::{VelloRenderer, ViewerContent};
+use rive_rs::{Artboard, File, Instantiate, Viewport};
use vello::{
kurbo::{Affine, Rect, Vec2},
peniko::{Color, Fill},
@@ -24,7 +24,8 @@
const SCROLL_FACTOR_THRESHOLD: f64 = 100.0;
fn main() {
- let mut viewer_content: Option<ViewerContent> = None;
+ let mut viewport = Viewport::default();
+ let mut scene: Option<Box<dyn rive_rs::Scene>> = None;
let event_loop = EventLoop::new();
let mut cached_window: Option<Window> = None;
@@ -46,9 +47,7 @@
match event {
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
WindowEvent::Resized(size) => {
- if let Some(viewer_content) = &viewer_content {
- viewer_content.handle_resize(size.width, size.height);
- }
+ viewport.resize(size.width, size.height);
render_cx.resize_surface(&mut render_state.surface, size.width, size.height);
render_state.window.request_redraw();
@@ -58,19 +57,23 @@
button: MouseButton::Left,
..
} => {
- if let Some(viewer_content) = &viewer_content {
- let handler = match state {
- ElementState::Pressed => ViewerContent::handle_pointer_down,
- ElementState::Released => ViewerContent::handle_pointer_up,
- };
-
- handler(viewer_content, mouse_pos);
+ if let Some(scene) = &mut scene {
+ match state {
+ ElementState::Pressed => scene.pointer_down(
+ mouse_pos.x as f32,
+ mouse_pos.y as f32,
+ &viewport,
+ ),
+ ElementState::Released => {
+ scene.pointer_up(mouse_pos.x as f32, mouse_pos.y as f32, &viewport)
+ }
+ }
}
}
WindowEvent::CursorMoved { position, .. } => {
mouse_pos = Vec2::new(position.x, position.y);
- if let Some(viewer_content) = &viewer_content {
- viewer_content.handle_pointer_move(mouse_pos);
+ if let Some(scene) = &mut scene {
+ scene.pointer_move(mouse_pos.x as f32, mouse_pos.y as f32, &viewport);
}
}
WindowEvent::MouseWheel { delta, .. } => match delta {
@@ -84,12 +87,12 @@
}
},
WindowEvent::DroppedFile(path) => {
- viewer_content = ViewerContent::new(path);
+ scene = Some({
+ let file = File::new(&fs::read(path).unwrap()).unwrap();
+ let artboard = Artboard::instantiate(&file, None).unwrap();
- if let Some(viewer_content) = &viewer_content {
- let size = render_state.window.inner_size();
- viewer_content.handle_resize(size.width, size.height);
- }
+ Box::<dyn rive_rs::Scene>::instantiate(&artboard, None).unwrap()
+ });
}
_ => {}
}
@@ -100,7 +103,7 @@
}
}
Event::RedrawRequested(_) => {
- let mut vello_renderer = VelloRenderer::default();
+ let mut rive_renderer = rive_rs::Renderer::default();
let factor = (scroll_delta / SCROLL_FACTOR_THRESHOLD).max(1.0) as u32;
let elapsed = &frame_start_time.elapsed();
@@ -142,15 +145,15 @@
.get_current_texture()
.expect("failed to get surface texture");
- let mut scene = Scene::default();
- let mut builder = SceneBuilder::for_scene(&mut scene);
+ let mut vello_scene = Scene::default();
+ let mut builder = SceneBuilder::for_scene(&mut vello_scene);
- if let Some(viewer_content) = &mut viewer_content {
- viewer_content.handle_draw(&mut vello_renderer, elapsed.as_secs_f64());
+ if let Some(scene) = &mut scene {
+ scene.advance_and_maybe_draw(&mut rive_renderer, *elapsed, &mut viewport);
for i in 0..factor.pow(2) {
builder.append(
- &vello_renderer.scene,
+ rive_renderer.scene(),
Some(
Affine::default()
.then_scale(1.0 / factor as f64)
@@ -162,7 +165,7 @@
);
}
} else {
- // Vello currently crashes when rendering an empty scene.
+ // Vello doesn't draw base color when there is no geometry.
builder.fill(
Fill::NonZero,
Affine::IDENTITY,
@@ -172,17 +175,19 @@
);
}
- vello::block_on_wgpu(
- &device_handle.device,
- renderer.as_mut().unwrap().render_to_surface_async(
+ if !vello_scene.data().is_empty() {
+ vello::block_on_wgpu(
&device_handle.device,
- &device_handle.queue,
- &scene,
- &surface_texture,
- &render_params,
- ),
- )
- .expect("failed to render to surface");
+ renderer.as_mut().unwrap().render_to_surface_async(
+ &device_handle.device,
+ &device_handle.queue,
+ &vello_scene,
+ &surface_texture,
+ &render_params,
+ ),
+ )
+ .expect("failed to render to surface");
+ }
surface_texture.present();
device_handle.device.poll(wgpu::Maintain::Poll);
@@ -220,6 +225,7 @@
timestamp_period: render_cx.devices[render_state.surface.dev_id]
.queue
.get_timestamp_period(),
+ use_cpu: false,
},
)
.expect("Could create renderer"),
diff --git a/vello/src/rive.rs b/vello/src/rive.rs
deleted file mode 100644
index 7c6c222..0000000
--- a/vello/src/rive.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use vello::peniko::{Mix, Stroke};
-
-use crate::RenderStyle;
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub enum RenderPaint {
- Stroke,
- #[default]
- Fill,
-}
-
-impl From<RenderPaint> for RenderStyle {
- fn from(value: RenderPaint) -> Self {
- match value {
- RenderPaint::Stroke => Self::Stroke(Stroke::new(0.0)),
- RenderPaint::Fill => Self::Fill,
- }
- }
-}
-
-#[repr(u32)]
-#[derive(Debug, Default)]
-pub enum StrokeJoin {
- #[default]
- Miter = 0,
- Round = 1,
- Bevel = 2,
-}
-
-#[repr(u32)]
-#[derive(Debug, Default)]
-pub enum StrokeCap {
- #[default]
- Butt = 0,
- Round = 1,
- Square = 2,
-}
-
-#[repr(u32)]
-#[derive(Debug, Default)]
-pub enum BlendMode {
- #[default]
- SrcOver = 3,
- Screen = 14,
- Overlay = 15,
- Darken = 16,
- Lighten = 17,
- ColorDodge = 18,
- ColorBurn = 19,
- HardLight = 20,
- SoftLight = 21,
- Difference = 22,
- Exclusion = 23,
- Multiply = 24,
- Hue = 25,
- Saturation = 26,
- Color = 27,
- Luminosity = 28,
-}
-
-impl From<BlendMode> for Mix {
- fn from(value: BlendMode) -> Self {
- match value {
- BlendMode::SrcOver => Self::Normal,
- BlendMode::Screen => Self::Screen,
- BlendMode::Overlay => Self::Overlay,
- BlendMode::Darken => Self::Darken,
- BlendMode::Lighten => Self::Lighten,
- BlendMode::ColorDodge => Self::ColorDodge,
- BlendMode::ColorBurn => Self::ColorBurn,
- BlendMode::HardLight => Self::HardLight,
- BlendMode::SoftLight => Self::SoftLight,
- BlendMode::Difference => Self::Difference,
- BlendMode::Exclusion => Self::Exclusion,
- BlendMode::Multiply => Self::Multiply,
- BlendMode::Hue => Self::Hue,
- BlendMode::Saturation => Self::Saturation,
- BlendMode::Color => Self::Color,
- BlendMode::Luminosity => Self::Luminosity,
- }
- }
-}
-
-#[repr(C)]
-#[derive(Debug, Default)]
-pub enum FillRule {
- #[default]
- NonZero,
- EvenOdd,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub struct Vec2D {
- pub x: f32,
- pub y: f32,
-}
diff --git a/vello/src/util.rs b/vello/src/util.rs
deleted file mode 100644
index aba56d9..0000000
--- a/vello/src/util.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-use std::{
- ops::{Add, Mul, Neg, Sub},
- ptr::NonNull,
-};
-
-use vello::kurbo::{Affine, Point};
-
-use crate::rive;
-
-pub trait UnwrapAndDeref {
- type Deref;
-
- unsafe fn unwrap_and_deref(&mut self) -> &mut Self::Deref;
-}
-
-impl<T> UnwrapAndDeref for Option<NonNull<T>> {
- type Deref = T;
-
- unsafe fn unwrap_and_deref(&mut self) -> &mut Self::Deref {
- self.map(|mut ptr| ptr.as_mut()).unwrap()
- }
-}
-
-#[derive(Clone, Copy, Debug)]
-struct Vec2 {
- x: f32,
- y: f32,
-}
-
-impl Vec2 {
- pub fn new(x: f32, y: f32) -> Self {
- Self { x, y }
- }
-
- pub fn splat(val: f32) -> Self {
- Self::new(val, val)
- }
-}
-
-impl Add for Vec2 {
- type Output = Self;
-
- fn add(self, rhs: Self) -> Self::Output {
- Self::new(self.x + rhs.x, self.y + rhs.y)
- }
-}
-
-impl Sub for Vec2 {
- type Output = Self;
-
- fn sub(self, rhs: Self) -> Self::Output {
- Self::new(self.x - rhs.x, self.y - rhs.y)
- }
-}
-
-impl Mul for Vec2 {
- type Output = Self;
-
- fn mul(self, rhs: Self) -> Self::Output {
- Self::new(self.x * rhs.x, self.y * rhs.y)
- }
-}
-
-impl Mul<f32> for Vec2 {
- type Output = Self;
-
- fn mul(self, rhs: f32) -> Self::Output {
- self * Self::splat(rhs)
- }
-}
-
-impl Neg for Vec2 {
- type Output = Self;
-
- fn neg(self) -> Self::Output {
- Self::new(-self.x, -self.y)
- }
-}
-
-/// Finds the affine transform that maps triangle `from` to triangle `to`. The algorithm is based
-/// on the [Simplex Affine Mapping] method which has a [Swift implementation].
-///
-/// [Simplex Affine Mapping]: https://www.researchgate.net/publication/332410209_Beginner%27s_guide_to_mapping_simplexes_affinely
-/// [Swift implementation]: https://rethunk.medium.com/finding-an-affine-transform-using-three-2d-point-correspondences-using-simplex-affine-mapping-255aeb4e8055
-fn simplex_affine_mapping(from: [Vec2; 3], to: [Vec2; 3]) -> Affine {
- let [a, b, c] = from;
- let [d, e, f] = to;
-
- let det_recip = (a.x * b.y + b.x * c.y + c.x * a.y - a.x * c.y - b.x * a.y - c.x * b.y).recip();
-
- let p = (d * (b.y - c.y) - e * (a.y - c.y) + f * (a.y - b.y)) * det_recip;
-
- let q = (e * (a.x - c.x) - d * (b.x - c.x) - f * (a.x - b.x)) * det_recip;
-
- let t = (d * (b.x * c.y - b.y * c.x) - e * (a.x * c.y - a.y * c.x)
- + f * (a.x * b.y - a.y * b.x))
- * det_recip;
-
- Affine::new([
- p.x as f64, p.y as f64, q.x as f64, q.y as f64, t.x as f64, t.y as f64,
- ])
-}
-
-pub fn map_uvs_to_triangle(
- points: &[rive::Vec2D; 3],
- uvs: &[rive::Vec2D; 3],
- width: u32,
- height: u32,
-) -> Affine {
- simplex_affine_mapping(
- uvs.map(|v| Vec2::new(v.x * width as f32, v.y * height as f32)),
- points.map(|v| Vec2::new(v.x, v.y)),
- )
-}
-
-pub trait ScaleFromOrigin {
- fn pre_scale_from_origin(self, scale: f64, origin: Point) -> Self;
-}
-
-impl ScaleFromOrigin for Affine {
- fn pre_scale_from_origin(self, scale: f64, origin: Point) -> Self {
- let origin = origin.to_vec2();
- self.pre_translate(origin)
- .pre_scale(scale)
- .pre_translate(-origin)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- use vello::kurbo;
-
- #[test]
- fn straightforward_sam() {
- let from = [
- Vec2::new(1.0, 1.0),
- Vec2::new(3.0, 1.0),
- Vec2::new(1.0, 3.0),
- ];
- let to = [
- Vec2::new(4.0, 4.0),
- Vec2::new(4.0, -1.0),
- Vec2::new(-2.0, 4.0),
- ];
-
- let mapping = simplex_affine_mapping(from, to);
-
- for (from, to) in from.into_iter().zip(to.into_iter()) {
- let res = mapping * kurbo::Point::new(from.x as f64, from.y as f64);
-
- assert_eq!(res.x as f32, to.x);
- assert_eq!(res.y as f32, to.y);
- }
- }
-}
diff --git a/vello/src/vello_renderer.cpp b/vello/src/vello_renderer.cpp
deleted file mode 100644
index ffd59af..0000000
--- a/vello/src/vello_renderer.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-#include "vello_renderer.hpp"
-
-VelloPath::~VelloPath() { vello_path_release(m_path); }
-
-void VelloPath::rewind() { vello_path_rewind(m_path); }
-
-void VelloPath::addRenderPath(RenderPath* path, const Mat2D& transform)
-{
- vello_path_extend(m_path, static_cast<VelloPath*>(path)->m_path, transform.values());
-}
-
-void VelloPath::fillRule(FillRule value) { vello_path_set_fill_rule(m_path, value); }
-
-void VelloPath::moveTo(float x, float y) { vello_path_move_to(m_path, x, y); }
-
-void VelloPath::lineTo(float x, float y) { vello_path_line_to(m_path, x, y); }
-
-void VelloPath::cubicTo(float ox, float oy, float ix, float iy, float x, float y)
-{
- vello_path_cubic_to(m_path, ox, oy, ix, iy, x, y);
-}
-
-void VelloPath::close() { vello_path_close(m_path); }
-
-VelloGradient::~VelloGradient() { vello_gradient_release(m_gradient); }
-
-VelloImage::~VelloImage() { vello_image_release(m_image); }
-
-VelloPaint::~VelloPaint() { vello_paint_release(m_paint); }
-
-void VelloPaint::style(RenderPaintStyle style) { vello_paint_set_style(m_paint, style); }
-
-void VelloPaint::color(unsigned int value) { vello_paint_set_color(m_paint, value); }
-
-void VelloPaint::thickness(float value) { vello_paint_set_thickness(m_paint, value); }
-
-void VelloPaint::join(StrokeJoin value) { vello_paint_set_join(m_paint, value); }
-
-void VelloPaint::cap(StrokeCap value) { vello_paint_set_cap(m_paint, value); }
-
-void VelloPaint::blendMode(BlendMode value) { vello_paint_set_blend_mode(m_paint, value); }
-
-void VelloPaint::shader(rcp<RenderShader> shader)
-{
- VelloGradient* gradient = (VelloGradient*)shader.get();
-
- if (gradient != nullptr)
- {
- vello_paint_set_gradient(m_paint, gradient->gradient());
- }
-}
-
-void VelloRenderer::save() { vello_renderer_save(m_renderer); }
-
-void VelloRenderer::restore() { vello_renderer_restore(m_renderer); }
-
-void VelloRenderer::transform(const Mat2D& transform)
-{
- vello_renderer_transform(m_renderer, transform.values());
-}
-
-void VelloRenderer::clipPath(RenderPath* path)
-{
- vello_renderer_clip_path(m_renderer, static_cast<VelloPath*>(path)->path());
-}
-
-void VelloRenderer::drawPath(RenderPath* path, RenderPaint* paint)
-{
- vello_renderer_draw_path(m_renderer,
- static_cast<VelloPath*>(path)->path(),
- static_cast<VelloPaint*>(paint)->paint());
-}
-
-void VelloRenderer::drawImage(const RenderImage* image, BlendMode blend_mode, float opacity)
-{
- vello_renderer_draw_image(m_renderer,
- static_cast<const VelloImage*>(image)->image(),
- blend_mode,
- opacity);
-}
-
-void VelloRenderer::drawImageMesh(const RenderImage* image,
- rcp<RenderBuffer> vertices,
- rcp<RenderBuffer> uvCoords,
- rcp<RenderBuffer> indices,
- uint32_t vertexCount,
- uint32_t indexCount,
- BlendMode blendMode,
- float opacity)
-{
- vello_renderer_draw_image_mesh(m_renderer,
- static_cast<const VelloImage*>(image)->image(),
- DataRenderBuffer::Cast(vertices.get())->vecs(),
- vertexCount,
- DataRenderBuffer::Cast(uvCoords.get())->vecs(),
- vertexCount,
- DataRenderBuffer::Cast(indices.get())->u16s(),
- indexCount,
- blendMode,
- opacity);
-}
-
-rcp<RenderBuffer> VelloFactory::makeRenderBuffer(RenderBufferType type,
- RenderBufferFlags flags,
- size_t sizeInBytes)
-{
- return make_rcp<DataRenderBuffer>(type, flags, sizeInBytes);
-}
-
-rcp<RenderShader> VelloFactory::makeLinearGradient(float sx,
- float sy,
- float ex,
- float ey,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- size_t count)
-{
- RawVelloGradient gradient = vello_gradient_new_linear(sx, sy, ex, ey, colors, stops, count);
- return rcp<RenderShader>(new VelloGradient(std::move(gradient)));
-}
-
-rcp<RenderShader> VelloFactory::makeRadialGradient(float cx,
- float cy,
- float radius,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- size_t count)
-{
- RawVelloGradient gradient = vello_gradient_new_radial(cx, cy, radius, colors, stops, count);
- return rcp<RenderShader>(new VelloGradient(std::move(gradient)));
-}
-
-std::unique_ptr<RenderPath> VelloFactory::makeRenderPath(RawPath& rawPath, FillRule fillRule)
-{
- std::unique_ptr<VelloPath> path = std::make_unique<VelloPath>();
-
- for (auto [verb, points] : rawPath)
- {
- switch (verb)
- {
- case PathVerb::move:
- path->move(points[0]);
- break;
- case PathVerb::line:
- path->line(points[1]);
- break;
- case PathVerb::cubic:
- path->cubic(points[1], points[2], points[3]);
- break;
- case PathVerb::close:
- path->close();
- break;
- }
- }
-
- return path;
-}
-
-std::unique_ptr<RenderPath> VelloFactory::makeEmptyRenderPath()
-{
- return std::make_unique<VelloPath>();
-}
-
-std::unique_ptr<RenderPaint> VelloFactory::makeRenderPaint()
-{
- return std::make_unique<VelloPaint>();
-}
-
-std::unique_ptr<RenderImage> VelloFactory::decodeImage(Span<const uint8_t> encoded)
-{
- return std::make_unique<VelloImage>(vello_image_new(encoded.data(), encoded.size()));
-}
-
-static VelloFactory factory;
-rive::Factory* ViewerContent::RiveFactory() { return &factory; }
diff --git a/vello/src/vello_renderer.hpp b/vello/src/vello_renderer.hpp
deleted file mode 100644
index ab8a0c6..0000000
--- a/vello/src/vello_renderer.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-#ifndef _RIVE_VELLO_RENDERER_HPP_
-#define _RIVE_VELLO_RENDERER_HPP_
-
-#include "rive/factory.hpp"
-#include "rive/math/mat2d.hpp"
-#include "rive/math/path_types.hpp"
-#include "rive/math/vec2d.hpp"
-#include "rive/renderer.hpp"
-#include "utils/factory_utils.hpp"
-#include "viewer/viewer_content.hpp"
-
-#include "vello_renderer.hpp"
-
-using namespace rive;
-
-typedef void* RawVelloPath;
-typedef void* RawVelloGradient;
-typedef void* RawVelloImage;
-typedef void* RawVelloPaint;
-typedef void* RawVelloRenderer;
-
-extern "C"
-{
- typedef void* RawVelloPath;
- typedef void* RawVelloGradient;
- typedef void* RawVelloImage;
- typedef void* RawVelloPaint;
- typedef void* RawVelloRenderer;
-
- const RawVelloPath vello_path_new();
- void vello_path_release(const RawVelloPath path);
- void vello_path_rewind(const RawVelloPath path);
- void vello_path_extend(const RawVelloPath path, void* other, const float* transform);
- void vello_path_set_fill_rule(const RawVelloPath path, FillRule fill_rule);
- void vello_path_move_to(const RawVelloPath path, float x, float y);
- void vello_path_line_to(const RawVelloPath path, float x, float y);
- void vello_path_cubic_to(const RawVelloPath path,
- float ox,
- float oy,
- float ix,
- float iy,
- float x,
- float y);
- void vello_path_close(const RawVelloPath path);
-
- const RawVelloGradient vello_gradient_new_linear(float sx,
- float sy,
- float ex,
- float ey,
- const uint32_t* colors_data,
- const float* stops_data,
- size_t len);
- const RawVelloGradient vello_gradient_new_radial(float cx,
- float cy,
- float radius,
- const uint32_t* colors_data,
- const float* stops_data,
- size_t len);
- void vello_gradient_release(const RawVelloGradient gradient);
-
- const RawVelloImage vello_image_new(const uint8_t* data, size_t len);
- void vello_image_release(const RawVelloImage image);
-
- const RawVelloPaint vello_paint_new();
- void vello_paint_release(const RawVelloPaint paint);
- void vello_paint_set_style(const RawVelloPaint paint, RenderPaintStyle style);
- void vello_paint_set_color(const RawVelloPaint paint, uint32_t color);
- void vello_paint_set_thickness(const RawVelloPaint paint, float thickness);
- void vello_paint_set_join(const RawVelloPaint paint, StrokeJoin join);
- void vello_paint_set_cap(const RawVelloPaint paint, StrokeCap cap);
- void vello_paint_set_blend_mode(const RawVelloPaint paint, BlendMode blend_mode);
- void vello_paint_set_gradient(const RawVelloPaint paint, const RawVelloGradient gradient);
-
- const RawVelloRenderer vello_renderer_new();
- void vello_renderer_release(const RawVelloRenderer renderer);
- void vello_renderer_save(const RawVelloRenderer renderer);
- void vello_renderer_restore(const RawVelloRenderer renderer);
- void vello_renderer_transform(const RawVelloRenderer renderer, const float* transform);
- void vello_renderer_clip_path(const RawVelloRenderer renderer, const RawVelloPath path);
- void vello_renderer_draw_path(const RawVelloRenderer renderer,
- const RawVelloPath path,
- const RawVelloPaint paint);
- void vello_renderer_draw_image(const RawVelloRenderer renderer,
- const RawVelloImage image,
- BlendMode blend_mode,
- float opacity);
- void vello_renderer_draw_image_mesh(const RawVelloRenderer renderer,
- const RawVelloImage image,
- const Vec2D* vertices_data,
- size_t vertices_len,
- const Vec2D* uvs_data,
- size_t uvs_len,
- const uint16_t* indices_data,
- size_t indices_len,
- BlendMode blend_mode,
- float opacity);
-}
-
-using namespace rive;
-
-class VelloPath : public RenderPath
-{
-private:
- RawVelloPath m_path;
-
-public:
- VelloPath() : m_path(vello_path_new()) {}
- VelloPath(RawVelloPath& path) : m_path(std::move(path)) {}
- ~VelloPath() override;
-
- const RawVelloPath& path() const { return m_path; }
-
- void rewind() override;
- void addRenderPath(RenderPath* path, const Mat2D& transform) override;
- void fillRule(FillRule value) override;
- void moveTo(float x, float y) override;
- void lineTo(float x, float y) override;
- void cubicTo(float ox, float oy, float ix, float iy, float x, float y) override;
- virtual void close() override;
-};
-
-class VelloGradient : public RenderShader
-{
-private:
- RawVelloGradient m_gradient;
-
-public:
- VelloGradient(RawVelloGradient gradient) : m_gradient(gradient) {}
- ~VelloGradient() override;
-
- const RawVelloGradient& gradient() const { return m_gradient; }
-};
-
-class VelloImage : public RenderImage
-{
-private:
- RawVelloImage m_image;
-
-public:
- VelloImage(RawVelloImage image) : m_image(image) {}
- ~VelloImage() override;
-
- const RawVelloImage& image() const { return m_image; }
-};
-
-class VelloPaint : public RenderPaint
-{
-private:
- RawVelloPaint m_paint;
-
-public:
- VelloPaint() : m_paint(vello_paint_new()) {}
- ~VelloPaint() override;
-
- const RawVelloPaint& paint() const { return m_paint; }
-
- void style(RenderPaintStyle style) override;
- void color(unsigned int value) override;
- void thickness(float value) override;
- void join(StrokeJoin value) override;
- void cap(StrokeCap value) override;
- void blendMode(BlendMode value) override;
- void shader(rcp<RenderShader>) override;
- void invalidateStroke() override {}
-};
-
-class VelloRenderer : public Renderer
-{
-protected:
- RawVelloRenderer m_renderer;
-
-public:
- VelloRenderer() : m_renderer(vello_renderer_new()) {}
- VelloRenderer(RawVelloRenderer renderer) : m_renderer(std::move(renderer)) {}
- ~VelloRenderer() override {}
-
- void save() override;
- void restore() override;
- void transform(const Mat2D& transform) override;
- void clipPath(RenderPath* path) override;
- void drawPath(RenderPath* path, RenderPaint* paint) override;
- void drawImage(const RenderImage*, BlendMode, float opacity) override;
- void drawImageMesh(const RenderImage*,
- rcp<RenderBuffer> vertices_f32,
- rcp<RenderBuffer> uvCoords_f32,
- rcp<RenderBuffer> indices_u16,
- uint32_t vertexCount,
- uint32_t indexCount,
- BlendMode,
- float opacity) override;
-};
-
-class VelloFactory : public Factory
-{
-public:
- rcp<RenderBuffer> makeRenderBuffer(RenderBufferType, RenderBufferFlags, size_t) override;
-
- rcp<RenderShader> makeLinearGradient(float sx,
- float sy,
- float ex,
- float ey,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- size_t count) override;
-
- rcp<RenderShader> makeRadialGradient(float cx,
- float cy,
- float radius,
- const ColorInt colors[], // [count]
- const float stops[], // [count]
- size_t count) override;
-
- std::unique_ptr<RenderPath> makeRenderPath(RawPath&, FillRule) override;
-
- std::unique_ptr<RenderPath> makeEmptyRenderPath() override;
-
- std::unique_ptr<RenderPaint> makeRenderPaint() override;
-
- std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) override;
-};
-
-#endif
diff --git a/vello/src/viewer.rs b/vello/src/viewer.rs
deleted file mode 100644
index 2b51a58..0000000
--- a/vello/src/viewer.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use std::{
- ffi::CString, fs::File, io::Read, os::unix::prelude::OsStrExt, path::Path, ptr::NonNull,
-};
-
-use vello::kurbo::Vec2;
-
-use crate::VelloRenderer;
-
-#[derive(Debug)]
-enum RawViewerContent {}
-
-extern "C" {
- fn viewer_content_new(raw_path: *const i8) -> Option<NonNull<RawViewerContent>>;
- fn viewer_content_release(raw_viewer_content: Option<NonNull<RawViewerContent>>);
- fn viewer_content_handle_resize(
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
- width: i32,
- height: i32,
- );
- // We're simply propagating the `VelloRender` pointer opaquely through the FFI.
- #[allow(improper_ctypes)]
- fn viewer_content_handle_draw(
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
- raw_vello_renderer: Option<NonNull<VelloRenderer>>,
- elapsed: f64,
- );
- fn viewer_content_handle_pointer_move(
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
- x: f32,
- y: f32,
- );
- fn viewer_content_handle_pointer_down(
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
- x: f32,
- y: f32,
- );
- fn viewer_content_handle_pointer_up(
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
- x: f32,
- y: f32,
- );
-}
-
-#[derive(Debug)]
-pub struct ViewerContent {
- raw_viewer_content: Option<NonNull<RawViewerContent>>,
-}
-
-impl ViewerContent {
- pub fn new<P: AsRef<Path>>(path: P) -> Option<Self> {
- let path = path.as_ref();
-
- let header = {
- let mut file = File::open(path).ok()?;
- let mut buffer = [0; 4];
-
- file.read_exact(&mut buffer).ok()?;
-
- buffer
- };
-
- if &header != b"RIVE" {
- return None;
- }
-
- let c_str = CString::new(path.as_os_str().as_bytes()).unwrap();
- let raw_viewer_content = Some(unsafe { viewer_content_new(c_str.as_ptr())? });
-
- Some(Self { raw_viewer_content })
- }
-
- pub fn handle_resize(&self, width: u32, height: u32) {
- unsafe {
- viewer_content_handle_resize(self.raw_viewer_content, width as i32, height as i32);
- }
- }
-
- pub fn handle_draw(&mut self, renderer: &mut VelloRenderer, elapsed: f64) {
- unsafe {
- viewer_content_handle_draw(
- self.raw_viewer_content,
- NonNull::new(renderer as *mut VelloRenderer),
- elapsed,
- )
- }
- }
-
- pub fn handle_pointer_move(&self, pos: Vec2) {
- unsafe {
- viewer_content_handle_pointer_move(self.raw_viewer_content, pos.x as f32, pos.y as f32);
- }
- }
-
- pub fn handle_pointer_down(&self, pos: Vec2) {
- unsafe {
- viewer_content_handle_pointer_down(self.raw_viewer_content, pos.x as f32, pos.y as f32);
- }
- }
-
- pub fn handle_pointer_up(&self, pos: Vec2) {
- unsafe {
- viewer_content_handle_pointer_up(self.raw_viewer_content, pos.x as f32, pos.y as f32);
- }
- }
-}
-
-impl Drop for ViewerContent {
- fn drop(&mut self) {
- unsafe {
- viewer_content_release(self.raw_viewer_content);
- }
- }
-}
diff --git a/vello/src/winit_viewer.cpp b/vello/src/winit_viewer.cpp
deleted file mode 100644
index 9406af1..0000000
--- a/vello/src/winit_viewer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "viewer/viewer_content.hpp"
-
-#include "vello_renderer.hpp"
-
-extern "C"
-{
- typedef void* RawViewerContent;
-
- const RawViewerContent viewer_content_new(const char* filename)
- {
- return static_cast<void*>(ViewerContent::findHandler(filename).release());
- }
-
- void viewer_content_release(const RawViewerContent viewer_content)
- {
- std::unique_ptr<ViewerContent> val(std::move(static_cast<ViewerContent*>(viewer_content)));
- }
-
- void viewer_content_handle_resize(const RawViewerContent viewer_content,
- int32_t width,
- int32_t height)
- {
- static_cast<ViewerContent*>(viewer_content)->handleResize(width, height);
- }
-
- void viewer_content_handle_draw(const RawViewerContent viewer_content,
- RawVelloRenderer raw_renderer,
- double elapsed)
- {
- VelloRenderer renderer = VelloRenderer(raw_renderer);
- static_cast<ViewerContent*>(viewer_content)->handleDraw(&renderer, elapsed);
- }
-
- void viewer_content_handle_pointer_move(const RawViewerContent viewer_content, float x, float y)
- {
- static_cast<ViewerContent*>(viewer_content)->handlePointerMove(x, y);
- }
-
- void viewer_content_handle_pointer_down(const RawViewerContent viewer_content, float x, float y)
- {
- static_cast<ViewerContent*>(viewer_content)->handlePointerDown(x, y);
- }
-
- void viewer_content_handle_pointer_up(const RawViewerContent viewer_content, float x, float y)
- {
- static_cast<ViewerContent*>(viewer_content)->handlePointerUp(x, y);
- }
-}
