chore(f3d): update version (#32)

Cargo.toml

@@ -11,11 +11,11 @@ crate-type = ["lib", "staticlib"]
 default = ["f3dex2", "wgpu_renderer"]
 
 # Graphics Features
-f3dex2 = ["fast3d/f3dex2"]
-f3dex2e = ["gbifloats", "f3dex2", "fast3d/f3dex2e"]
+f3dex2 = ["fast3d/f3dex2", "fast3d-gbi/f3dex2"]
+f3dex2e = ["gbifloats", "f3dex2", "fast3d/f3dex2e", "fast3d-gbi/f3dex2e"]
 f3dzex2 = ["f3dex2", "fast3d/f3dzex2"]
 
-gbifloats = ["fast3d/gbifloats"]
+gbifloats = ["fast3d/gbifloats", "fast3d-gbi/gbifloats"]
 
 # Renderer Backend
 wgpu_renderer = ["wgpu", "imgui-wgpu", "fast3d-wgpu-renderer"]
@@ -44,12 +44,14 @@ glutin = { version = "0.29.1", optional = true }
 wgpu = { version = "0.16", optional = true }
 spin_sleep = "1.1.1"
 arie = "0.2.0"
-fast3d = { version = "0.4.2", default-features = false }
-fast3d-glium-renderer = { version = "0.4.2", optional = true }
-fast3d-wgpu-renderer = { version = "0.4.2", optional = true }
+fast3d = { version = "0.4.3", default-features = false }
+fast3d-gbi = { version = "0.4.3", default-features = false }
+fast3d-glium-renderer = { version = "0.4.3", optional = true }
+fast3d-wgpu-renderer = { version = "0.4.3", optional = true }
 rustc-hash = "1.1.0"
 
 [patch.crates-io]
 #fast3d = { path = "../../fast3d-rs/fast3d" }
+#fast3d-gbi = { path = "../../fast3d-rs/fast3d-gbi" }
 #fast3d-glium-renderer = { path = "../../fast3d-rs/fast3d-glium-renderer" }
 #fast3d-wgpu-renderer = { path = "../../fast3d-rs/fast3d-wgpu-renderer" }

cpp/helix.c

@@ -35,7 +35,7 @@ void HLXAudioPlayBuffer(const uint8_t* buf, size_t len) {
 }
 
 // Window & Graphics
-void HLXDisplaySetup(const char* title, void (*draw_menu)(void*), void (*draw_windows)(void*)) {
+void HLXDisplaySetup(const char* title, void (*draw_menu)(void*), void (*draw_windows)(void*, void*)) {
     _gui = GUICreate(title, _event_loop, draw_menu, draw_windows, _gamepad_manager); // pass in a possible keyboard observing object
 }
 
@@ -55,6 +55,6 @@ f32 HLXDisplayGetAspectRatio() {
     return GUIGetAspectRatio(_gui);
 }
 
-void HLXShowProfilerWindow(void* ui, bool* opened) {
-    GUIShowProfilerWindow(ui, _gui, opened);
+void HLXShowProfilerWindow(void* ui, void* render_data, bool* opened) {
+    GUIShowProfilerWindow(ui, _gui, render_data, opened);
 }

include/helix/gui.h

@@ -16,7 +16,7 @@ void HLXDisplayProcessDrawLists(u64* commands);
 void HLXDisplayEndFrame();
 float HLXDisplayGetAspectRatio();
 
-void HLXShowProfilerWindow(void* ui, bool* opened);
+void HLXShowProfilerWindow(void* ui, void* render_data, bool* opened);
 
 #ifdef __cplusplus
 }

include/helix/internal.h

@@ -30,14 +30,14 @@ void AudioPlayerQueueBuffer(void* player, const uint8_t* buf, size_t len);
 
 // GUI
 void* GUICreateEventLoop(void);
-void* GUICreate(const char* title, void* event_loop, void (*draw_menu_callback)(void*), void (*draw_windows_callback)(void*), void* gamepad_manager);
+void* GUICreate(const char* title, void* event_loop, void (*draw_menu_callback)(void*), void (*draw_windows_callback)(void*, void*), void* gamepad_manager);
 void GUIStartFrame(void* gui, void* event_loop);
 void GUIDrawLists(void* gui, uint64_t* commands);
 void GUIEndFrame(void* gui);
 
 f32 GUIGetAspectRatio(void* gui);
 
-void GUIShowProfilerWindow(void* ui, void* gui, bool* opened);
+void GUIShowProfilerWindow(void* ui, void* gui, void* render_data, bool* opened);
 
 // Gamepad
 

src/gui.rs

@@ -1,6 +1,6 @@
 use crate::gamepad::manager::GamepadManager;
 use fast3d::rdp::OutputDimensions;
-use fast3d::{RCPOutputCollector, RCP};
+use fast3d::{RenderData, RCP};
 use winit::platform::run_return::EventLoopExtRunReturn;
 
 pub mod windows;
@@ -55,14 +55,13 @@ pub struct Gui<'a> {
 
     // draw callbacks
     draw_menu_callback: Box<dyn Fn(&imgui::Ui) + 'a>,
-    draw_windows_callback: Box<dyn Fn(&imgui::Ui) + 'a>,
+    draw_windows_callback: Box<dyn Fn(&imgui::Ui, &RenderData) + 'a>,
 
     // gamepad
     gamepad_manager: Option<&'a mut GamepadManager>,
 
     // game renderer
     rcp: RCP,
-    rcp_output_collector: RCPOutputCollector,
     gfx_renderer: Renderer<'a>,
 }
 
@@ -76,7 +75,7 @@ impl<'a> Gui<'a> {
     ) -> anyhow::Result<Self>
     where
         D: Fn(&imgui::Ui) + 'static,
-        W: Fn(&imgui::Ui) + 'static,
+        W: Fn(&imgui::Ui, &RenderData) + 'static,
     {
         // Setup ImGui
         let mut imgui = imgui::Context::create();
@@ -122,7 +121,6 @@ impl<'a> Gui<'a> {
             draw_windows_callback: Box::new(draw_windows),
             gamepad_manager,
             rcp: RCP::new(),
-            rcp_output_collector: RCPOutputCollector::new(),
             gfx_renderer: renderer,
         })
     }
@@ -228,15 +226,15 @@ impl<'a> Gui<'a> {
         self.rcp.rdp.output_dimensions = dimensions;
 
         // Run the RCP
-        self.rcp.run(&mut self.rcp_output_collector, commands);
+        let mut render_data = self.rcp.process_dl(commands);
 
         // Grab the frame
         let mut frame = self.gfx_renderer.get_current_texture().unwrap();
 
         // Draw the UI
         let ui = self.imgui.new_frame();
         ui.main_menu_bar(|| (self.draw_menu_callback)(ui));
-        (self.draw_windows_callback)(ui);
+        (self.draw_windows_callback)(ui, &render_data);
 
         if self.ui_state.last_cursor != ui.mouse_cursor() {
             self.ui_state.last_cursor = ui.mouse_cursor();
@@ -246,10 +244,7 @@ impl<'a> Gui<'a> {
         // Render RCPOutput and ImGui content
         let draw_data = self.imgui.render();
         self.gfx_renderer
-            .draw_content(&mut frame, &mut self.rcp_output_collector, draw_data)?;
-
-        // Clear the draw calls
-        self.rcp_output_collector.clear_draw_calls();
+            .draw_content(&mut frame, &mut render_data, draw_data)?;
 
         // Swap buffers
         self.gfx_renderer.finish_render(frame)?;
@@ -264,7 +259,8 @@ impl<'a> Gui<'a> {
 
 // MARK: - C API
 
-type OnDraw = unsafe extern "C" fn(ui: &imgui::Ui);
+type OnDrawMenu = unsafe extern "C" fn(ui: &imgui::Ui);
+type OnDrawWindows = unsafe extern "C" fn(ui: &imgui::Ui, render_data: &RenderData);
 
 #[no_mangle]
 pub extern "C" fn GUICreateEventLoop() -> Box<EventLoopWrapper> {
@@ -276,8 +272,8 @@ pub extern "C" fn GUICreateEventLoop() -> Box<EventLoopWrapper> {
 pub unsafe extern "C" fn GUICreate<'a>(
     title_raw: *const i8,
     event_loop: Option<&'a mut EventLoopWrapper>,
-    draw_menu: Option<OnDraw>,
-    draw_windows: Option<OnDraw>,
+    draw_menu: Option<OnDrawMenu>,
+    draw_windows: Option<OnDrawWindows>,
     gamepad_manager: Option<&'a mut GamepadManager>,
 ) -> Box<Gui<'a>> {
     let title_str: &std::ffi::CStr = unsafe { std::ffi::CStr::from_ptr(title_raw) };
@@ -292,9 +288,9 @@ pub unsafe extern "C" fn GUICreate<'a>(
                 draw_menu(ui);
             }
         },
-        move |ui| unsafe {
+        move |ui, render_data| unsafe {
             if let Some(draw_windows) = draw_windows {
-                draw_windows(ui);
+                draw_windows(ui, render_data);
             }
         },
         gamepad_manager,

src/gui/glium_renderer.rs

@@ -1,6 +1,5 @@
 use crate::gui::{EventLoopWrapper, Frame};
-use fast3d::rdp::OutputDimensions;
-use fast3d::RCPOutputCollector;
+use fast3d::RenderData;
 use fast3d_glium_renderer::GliumRenderer;
 
 pub struct Renderer<'a> {
@@ -114,15 +113,15 @@ impl<'a> Renderer<'a> {
     pub fn draw_content(
         &mut self,
         frame: &mut Frame,
-        rcp_output_collector: &mut RCPOutputCollector,
+        render_data: &mut RenderData,
         imgui_draw_data: &imgui::DrawData,
     ) -> anyhow::Result<()> {
         // Prepare the context device
         self.fast3d_renderer.start_frame(frame);
 
         // Process the RCP output
         self.fast3d_renderer
-            .render_rcp_output(rcp_output_collector, &self.display, frame);
+            .render_rcp_output(render_data, &self.display, frame);
 
         // Render the ImGui content
         self.renderer.render(frame, imgui_draw_data)?;

src/gui/wgpu_renderer.rs

@@ -1,5 +1,5 @@
 use crate::gui::{EventLoopWrapper, Frame};
-use fast3d::RCPOutputCollector;
+use fast3d::RenderData;
 
 use fast3d_wgpu_renderer::WgpuRenderer;
 
@@ -202,7 +202,7 @@ impl<'a> Renderer<'a> {
     pub fn draw_content(
         &mut self,
         frame: &mut Frame,
-        rcp_output_collector: &mut RCPOutputCollector,
+        render_data: &mut RenderData,
         imgui_draw_data: &imgui::DrawData,
     ) -> anyhow::Result<()> {
         let frame_texture = frame
@@ -217,7 +217,7 @@ impl<'a> Renderer<'a> {
             &self.device,
             &self.queue,
             self.surface_config.format,
-            rcp_output_collector,
+            render_data,
         );
 
         let mut encoder: wgpu::CommandEncoder =

src/gui/windows.rs

@@ -1,14 +1,15 @@
-use fast3d::gbi::defines::GeometryModes;
+use fast3d::fast3d_gbi::defines::GeometryModes;
+use fast3d::RenderData;
 use imgui::{CollapsingHeader, Ui};
 
 use crate::gui::Gui;
 
 pub trait HelixWindows {
-    fn show_profiler_window(&self, opened: &mut bool, gui: &mut Gui);
+    fn show_profiler_window(&self, opened: &mut bool, gui: &mut Gui, render_data: &RenderData);
 }
 
 impl HelixWindows for Ui {
-    fn show_profiler_window(&self, opened: &mut bool, gui: &mut Gui) {
+    fn show_profiler_window(&self, opened: &mut bool, gui: &mut Gui, render_data: &RenderData) {
         self.window("Profiler")
             .opened(opened)
             .always_auto_resize(true)
@@ -22,15 +23,14 @@ impl HelixWindows for Ui {
                     self.io().framerate
                 ));
 
-                let total_tris = gui
-                    .rcp_output_collector
+                let total_tris = render_data
                     .draw_calls
                     .iter()
                     .fold(0, |acc, draw_call| acc + draw_call.vbo.num_tris);
 
                 self.text(format!(
                     "{} draw calls, {} vertices ({} triangles)",
-                    gui.rcp_output_collector.draw_calls.len(),
+                    render_data.draw_calls.len(),
                     total_tris * 3,
                     total_tris,
                 ));
@@ -39,7 +39,7 @@ impl HelixWindows for Ui {
 
                 if CollapsingHeader::new("Draw Calls").build(self) {
                     self.indent();
-                    for (i, dc) in gui.rcp_output_collector.draw_calls.iter().enumerate() {
+                    for (i, dc) in render_data.draw_calls.iter().enumerate() {
                         self.tree_node_config(format!("Draw Call: {}", i))
                             .build(|| {
                                 self.text(format!("Viewport: {}", dc.viewport));
@@ -118,12 +118,18 @@ impl HelixWindows for Ui {
 // MARK: - C API
 
 #[no_mangle]
-pub extern "C" fn GUIShowProfilerWindow(ui: &Ui, gui: Option<&mut Gui>, opened: Option<&mut bool>) {
+pub extern "C" fn GUIShowProfilerWindow(
+    ui: &Ui,
+    gui: Option<&mut Gui>,
+    render_data: Option<&RenderData>,
+    opened: Option<&mut bool>,
+) {
     let opened = opened.unwrap();
     let gui = gui.unwrap();
+    let render_data = render_data.unwrap();
     if !*opened {
         return;
     }
 
-    ui.show_profiler_window(opened, gui);
+    ui.show_profiler_window(opened, gui, render_data);
 }