Draw OffscreenTextures to ViewportWidget

editor/src/main.rs

@@ -64,12 +64,9 @@ impl Application {
 
         let egui_state = egui_winit::State::new(4096, &window);
         let egui_ctx = egui::Context::default();
-        let egui_rp = egui_wgpu_backend::RenderPass::new(&device, config.format, 1);
-
-        let render_state = render::RenderState::new(device.clone(), queue.clone(), config.format);
-
-        let image = egui::ColorImage::example();
-        let viewport_texture = egui_ctx.load_texture("example_viewport", image);
+        let mut egui_rp = egui_wgpu_backend::RenderPass::new(&device, config.format, 1);
+        let render_state = render::RenderState::new(device.clone(), queue.clone(), config.format, &mut egui_rp);
+        let viewport_texture = render_state.resources.get::<render::ViewportStore>().unwrap().viewport.egui_texture;
 
         Self {
             window,

editor/src/render.rs

@@ -4,12 +4,12 @@ use cyborg::viewport::{Viewport, ViewportInfo, ViewportViews};
 use std::sync::Arc;
 
 pub struct OffscreenTextures {
-    width: u32,
-    height: u32,
-    output_texture: wgpu::Texture,
-    output_view: wgpu::TextureView,
-    depth_texture: wgpu::Texture,
-    depth_view: wgpu::TextureView,
+    pub width: u32,
+    pub height: u32,
+    pub output_texture: wgpu::Texture,
+    pub output_view: wgpu::TextureView,
+    pub depth_texture: wgpu::Texture,
+    pub depth_view: wgpu::TextureView,
 }
 
 impl OffscreenTextures {
@@ -60,10 +60,11 @@ impl OffscreenTextures {
 }
 
 pub struct OffscreenViewport {
-    device: Arc<wgpu::Device>,
-    queue: Arc<wgpu::Queue>,
-    output_format: wgpu::TextureFormat,
-    textures: OffscreenTextures,
+    pub device: Arc<wgpu::Device>,
+    pub queue: Arc<wgpu::Queue>,
+    pub output_format: wgpu::TextureFormat,
+    pub textures: OffscreenTextures,
+    pub egui_texture: egui::TextureId,
 }
 
 impl OffscreenViewport {
@@ -71,14 +72,22 @@ impl OffscreenViewport {
         device: Arc<wgpu::Device>,
         queue: Arc<wgpu::Queue>,
         output_format: wgpu::TextureFormat,
+        render_pass: &mut egui_wgpu_backend::RenderPass,
     ) -> Self {
         let textures = OffscreenTextures::new(&device, 640, 480, output_format);
 
+        let egui_texture = render_pass.egui_texture_from_wgpu_texture(
+            &device,
+            &textures.output_view,
+            wgpu::FilterMode::Nearest,
+        );
+
         Self {
             device,
             queue,
             output_format,
             textures,
+            egui_texture,
         }
     }
 
@@ -111,9 +120,9 @@ impl Viewport for OffscreenViewport {
 }
 
 pub struct ViewportStore {
-    device: Arc<wgpu::Device>,
-    output_format: wgpu::TextureFormat,
-    viewport: OffscreenViewport,
+    pub device: Arc<wgpu::Device>,
+    pub output_format: wgpu::TextureFormat,
+    pub viewport: OffscreenViewport,
 }
 
 impl ViewportStore {
@@ -121,11 +130,12 @@ impl ViewportStore {
         device: Arc<wgpu::Device>,
         queue: Arc<wgpu::Queue>,
         output_format: wgpu::TextureFormat,
+        render_pass: &mut egui_wgpu_backend::RenderPass,
     ) -> Self {
         Self {
             device: device.clone(),
             output_format,
-            viewport: OffscreenViewport::new(device, queue, output_format),
+            viewport: OffscreenViewport::new(device, queue, output_format, render_pass),
         }
     }
 }
@@ -149,12 +159,14 @@ impl RenderState {
         device: Arc<wgpu::Device>,
         queue: Arc<wgpu::Queue>,
         output_format: wgpu::TextureFormat,
+        render_pass: &mut egui_wgpu_backend::RenderPass,
     ) -> Self {
         use cyborg::shader::{ShaderStore, ShaderWatcher};
 
         let mut world = legion::World::default();
         let mut resources = legion::Resources::default();
-        let viewport_store = ViewportStore::new(device.clone(), queue.clone(), output_format);
+        let viewport_store =
+            ViewportStore::new(device.clone(), queue.clone(), output_format, render_pass);
 
         let renderer = cyborg::Renderer::new(device.clone(), queue.clone());
         resources.insert(renderer);

editor/src/ui.rs

@@ -8,7 +8,7 @@ pub struct UserInterface {
 }
 
 impl UserInterface {
-    pub fn new(viewport_texture: egui::TextureHandle) -> Self {
+    pub fn new(viewport_texture: egui::TextureId) -> Self {
         Self {
             developer_mode: true,
             show_profiler: false,
@@ -127,11 +127,11 @@ impl UserInterface {
 }
 
 pub struct ViewportWidget {
-    texture: egui::TextureHandle,
+    texture: egui::TextureId,
 }
 
 impl ViewportWidget {
-    pub fn new(texture: egui::TextureHandle) -> Self {
+    pub fn new(texture: egui::TextureId) -> Self {
         Self { texture }
     }
 }
@@ -145,7 +145,7 @@ impl egui::Widget for &mut ViewportWidget {
         let response = ui.interact(rect, id, sense);
 
         use egui::{pos2, Mesh, Rect, Color32, Shape};
-        let mut mesh = Mesh::with_texture(self.texture.id());
+        let mut mesh = Mesh::with_texture(self.texture);
         let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
         let tint = Color32::WHITE;
         mesh.add_rect_with_uv(rect, uv, tint);