Implement basic rendering flow (#1322)

* Implement basic rendering flow

* Fix naming.

* Actually fix rename.

Author: tychedelia

Cargo.lock

@@ -1,5 +1,4 @@
-use std::env;
-use std::path::PathBuf;
+use std::{env, path::PathBuf};
 
 fn main() {
     let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -11,13 +10,18 @@ fn main() {
     let config_path = PathBuf::from(&crate_dir).join("cbindgen.toml");
 
     cbindgen::Builder::new()
-        .with_config(cbindgen::Config::from_file(&config_path).expect("Failed to load cbindgen.toml"))
+        .with_config(
+            cbindgen::Config::from_file(&config_path).expect("Failed to load cbindgen.toml"),
+        )
         .with_crate(&crate_dir)
         .generate()
         .expect("Unable to generate bindings")
         .write_to_file(&output_file);
 
     println!("cargo:rerun-if-changed=src/lib.rs");
     println!("cargo:rerun-if-changed=cbindgen.toml");
-    println!("cargo:warning=Generated header at: {}", output_file.display());
+    println!(
+        "cargo:warning=Generated header at: {}",
+        output_file.display()
+    );
 }

ffi/build.rs

@@ -1,5 +1,6 @@
 /// A sRGB (?) color
 #[repr(C)]
+#[derive(Debug, Clone, Copy)]
 pub struct Color {
     pub r: f32,
     pub g: f32,
@@ -11,4 +12,4 @@ impl From<Color> for bevy::color::Color {
     fn from(color: Color) -> Self {
         bevy::color::Color::srgba(color.r, color.g, color.b, color.a)
     }
-}
+}

ffi/src/color.rs

@@ -1,7 +1,10 @@
+use std::{
+    cell::RefCell,
+    ffi::{CString, c_char},
+    panic,
+};
+
 use renderer::error::ProcessingError;
-use std::cell::RefCell;
-use std::ffi::{CString, c_char};
-use std::panic;
 
 thread_local! {
     static LAST_ERROR: RefCell<Option<CString>> = RefCell::new(None);

ffi/src/error.rs

@@ -1,5 +1,7 @@
-use crate::color::Color;
 use bevy::prelude::Entity;
+use renderer::render::command::DrawCommand;
+
+use crate::color::Color;
 
 mod color;
 mod error;
@@ -72,15 +74,40 @@ pub extern "C" fn processing_background_color(window_id: u64, color: Color) {
     error::check(|| renderer::background_color(window_entity, color.into()));
 }
 
-/// Step the application forward.
+/// Begins the draw for the given window.
 ///
 /// SAFETY:
 /// - Init has been called and exit has not been called.
 /// - This is called from the same thread as init.
 #[unsafe(no_mangle)]
-pub extern "C" fn processing_update() {
+pub extern "C" fn processing_begin_draw(window_id: u64) {
     error::clear_error();
-    error::check(|| renderer::update());
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::begin_draw(window_entity));
+}
+
+/// Flushes recorded draw commands for the given window.
+///
+/// SAFETY:
+/// - Init has been called and exit has not been called.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_flush(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::flush(window_entity));
+}
+
+/// Ends the draw for the given window and presents the frame.
+///
+/// SAFETY:
+/// - Init has been called and exit has not been called.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_end_draw(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::end_draw(window_entity));
 }
 
 /// Shuts down internal resources with given exit code, but does *not* terminate the process.
@@ -93,3 +120,104 @@ pub extern "C" fn processing_exit(exit_code: u8) {
     error::clear_error();
     error::check(|| renderer::exit(exit_code));
 }
+
+/// Set the fill color.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_set_fill(window_id: u64, r: f32, g: f32, b: f32, a: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    let color = bevy::color::Color::srgba(r, g, b, a);
+    error::check(|| renderer::record_command(window_entity, DrawCommand::Fill(color)));
+}
+
+/// Set the stroke color.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_set_stroke_color(window_id: u64, r: f32, g: f32, b: f32, a: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    let color = bevy::color::Color::srgba(r, g, b, a);
+    error::check(|| renderer::record_command(window_entity, DrawCommand::StrokeColor(color)));
+}
+
+/// Set the stroke weight.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_set_stroke_weight(window_id: u64, weight: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::record_command(window_entity, DrawCommand::StrokeWeight(weight)));
+}
+
+/// Disable fill for subsequent shapes.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_no_fill(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::record_command(window_entity, DrawCommand::NoFill));
+}
+
+/// Disable stroke for subsequent shapes.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_no_stroke(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| renderer::record_command(window_entity, DrawCommand::NoStroke));
+}
+
+/// Draw a rectangle.
+///
+/// SAFETY:
+/// - Init and create_surface have been called.
+/// - window_id is a valid ID returned from create_surface.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_rect(
+    window_id: u64,
+    x: f32,
+    y: f32,
+    w: f32,
+    h: f32,
+    tl: f32,
+    tr: f32,
+    br: f32,
+    bl: f32,
+) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| {
+        renderer::record_command(
+            window_entity,
+            DrawCommand::Rect {
+                x,
+                y,
+                w,
+                h,
+                radii: [tl, tr, br, bl],
+            },
+        )
+    });
+}

ffi/src/lib.rs

@@ -4,11 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-tracing = "0.1"
-tracing-subscriber = "0.3"
 bevy = { workspace = true }
-thiserror = "2"
+lyon = "1.0"
 raw-window-handle = "0.6"
+thiserror = "2"
+tracing = "0.1"
+tracing-subscriber = "0.3"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = { version = "0.6", default-features = false }

renderer/Cargo.toml

@@ -2,7 +2,6 @@ use thiserror::Error;
 
 pub type Result<T> = std::result::Result<T, ProcessingError>;
 
-
 #[derive(Error, Debug)]
 pub enum ProcessingError {
     #[error("App was accessed from multiple threads")]
@@ -15,4 +14,4 @@ pub enum ProcessingError {
     HandleError(#[from] raw_window_handle::HandleError),
     #[error("Invalid window handle provided")]
     InvalidWindowHandle,
-}
+}