- fix warnings in examples + example cleanup

Author: polymonster

examples/bindless/main.rs

@@ -116,7 +116,6 @@ fn main() -> Result<(), hotline_rs::Error> {
 
     let fmt = swap_chain.get_backbuffer_pass().get_format_hash();
     let pso_pmfx = pmfx.get_render_pipeline_for_format("bindless", fmt)?;
-    let pso_compute = pmfx.get_compute_pipeline("compute_rw")?;
 
     let mut textures: Vec<gfx_platform::Texture> = Vec::new();
     let files = vec![
@@ -139,104 +138,13 @@ fn main() -> Result<(), hotline_rs::Error> {
         textures[3].get_srv_index().unwrap() as u32,
     ];
 
-    // render target
-    let rt_info = gfx::TextureInfo {
-        format: gfx::Format::RGBA8n,
-        tex_type: gfx::TextureType::Texture2D,
-        width: 512,
-        height: 512,
-        depth: 1,
-        array_layers: 1,
-        mip_levels: 1,
-        samples: 1,
-        usage: gfx::TextureUsage::SHADER_RESOURCE | gfx::TextureUsage::RENDER_TARGET,
-        initial_state: gfx::ResourceState::ShaderResource,
-    };
-    let render_target = dev.create_texture(&rt_info, data![]).unwrap();
-
-    // pass for render target with depth stencil
-    let render_target_pass = dev
-        .create_render_pass(&gfx::RenderPassInfo {
-            render_targets: vec![&render_target],
-            rt_clear: Some(gfx::ClearColour {
-                r: 1.0,
-                g: 0.0,
-                b: 1.0,
-                a: 1.0,
-            }),
-            depth_stencil: None, //Some(&depth_stencil),
-            ds_clear: Some(gfx::ClearDepthStencil {
-                depth: Some(1.0),
-                stencil: None,
-            }),
-            resolve: false,
-            discard: false,
-            array_slice: 0
-        })
-        .unwrap();
-
-    // unordered access rw texture
-    let rw_info = gfx::TextureInfo {
-        format: gfx::Format::RGBA8n,
-        tex_type: gfx::TextureType::Texture2D,
-        width: 512,
-        height: 512,
-        depth: 1,
-        array_layers: 1,
-        mip_levels: 1,
-        samples: 1,
-        usage: gfx::TextureUsage::SHADER_RESOURCE | gfx::TextureUsage::UNORDERED_ACCESS,
-        initial_state: gfx::ResourceState::ShaderResource,
-    };
-    let _rw_tex = dev.create_texture::<u8>(&rw_info, None).unwrap();
-
     // ..
     let mut ci = 0;
     while app.run() {
         win.update(&mut app);
         swap_chain.update::<os_platform::App>(&mut dev, &win, &mut cmdbuffer);
         cmdbuffer.reset(&swap_chain);
 
-        // compute pass
-        cmdbuffer.set_marker(0xff00ffff, "Frame Start");
-        
-        cmdbuffer.begin_event(0xff0000ff, "Compute Pass");
-        cmdbuffer.set_compute_pipeline(pso_compute);
-        cmdbuffer.set_heap(pso_compute, dev.get_shader_heap());
-        cmdbuffer.dispatch(
-            gfx::Size3 {
-                x: 512 / 16,
-                y: 512 / 16,
-                z: 1,
-            },
-            gfx::Size3 {
-                x: 512,
-                y: 512,
-                z: 1,
-            },
-        );
-        cmdbuffer.end_event();
-
-        // render target pass
-        cmdbuffer.begin_event(0xff0000ff, "Render Target Pass");
-        cmdbuffer.transition_barrier(&gfx::TransitionBarrier {
-            texture: Some(&render_target),
-            buffer: None,
-            state_before: gfx::ResourceState::ShaderResource,
-            state_after: gfx::ResourceState::RenderTarget,
-        });
-
-        cmdbuffer.begin_render_pass(&render_target_pass);
-        cmdbuffer.end_render_pass();
-
-        cmdbuffer.transition_barrier(&gfx::TransitionBarrier {
-            texture: Some(&render_target),
-            buffer: None,
-            state_before: gfx::ResourceState::RenderTarget,
-            state_after: gfx::ResourceState::ShaderResource,
-        });
-        cmdbuffer.end_event();
-
         // main pass
         cmdbuffer.begin_event(0xff0000ff, "Main Pass");
         let vp_rect = win.get_viewport_rect();

examples/imgui_demo/main.rs

@@ -1,17 +1,8 @@
-use hotline_rs::{*, prelude::*};
+use hotline_rs::*;
 
 use os::{App, Window};
 use gfx::{CmdBuf, Device, SwapChain};
 
-use std::fs;
-
-#[repr(C)]
-struct Vertex {
-    position: [f32; 2],
-    uv: [f32; 2],
-    color: [f32; 4],
-}
-
 fn main() -> Result<(), hotline_rs::Error> {
     // app
     let mut app = os_platform::App::create(os::AppInfo {
@@ -68,81 +59,6 @@ fn main() -> Result<(), hotline_rs::Error> {
     };
     let mut imgui = imgui::ImGui::create(&mut imgui_info).unwrap();
 
-    // dummy vb
-    let vertices = [
-        Vertex {
-            position: [-1.0, -1.0],
-            uv: [0.0, 0.0],
-            color: [0.0, 0.0, 0.0, 1.0],
-        },
-        Vertex {
-            position: [-1.0, 1.0],
-            uv: [0.0, 0.0],
-            color: [0.0, 1.0, 0.0, 1.0],
-        },
-        Vertex {
-            position: [1.0, 1.0],
-            uv: [0.0, 0.0],
-            color: [1.0, 1.0, 0.0, 1.0],
-        },
-        Vertex {
-            position: [1.0, -1.0],
-            uv: [0.0, 0.0],
-            color: [1.0, 0.0, 0.0, 1.0],
-        },
-    ];
-
-    
-    let info = gfx::BufferInfo {
-        usage: gfx::BufferUsage::VERTEX,
-        cpu_access: gfx::CpuAccessFlags::NONE,
-        format: gfx::Format::Unknown,
-        stride: std::mem::size_of::<Vertex>(),
-        num_elements: 4,
-        initial_state: gfx::ResourceState::VertexConstantBuffer
-    };
-
-    let vertex_buffer = dev.create_buffer(&info, Some(gfx::as_u8_slice(&vertices)))?;
-
-    // index buffer
-    let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
-    let info = gfx::BufferInfo {
-        usage: gfx::BufferUsage::INDEX,
-        cpu_access: gfx::CpuAccessFlags::NONE,
-        format: gfx::Format::R16u,
-        stride: std::mem::size_of::<u16>(),
-        num_elements: 6,
-        initial_state: gfx::ResourceState::IndexBuffer
-    };
-    let index_buffer = dev.create_buffer(&info, Some(gfx::as_u8_slice(&indices)))?;
-
-    // create imgui shader
-    let mut pmfx : pmfx::Pmfx<gfx_platform::Device> = pmfx::Pmfx::create(&mut dev, 0);
-    pmfx.load(&hotline_rs::get_data_path("shaders/imgui"))?;
-    pmfx.create_render_pipeline(&dev, "default", swap_chain.get_backbuffer_pass())?;
-    let fmt = swap_chain.get_backbuffer_pass().get_format_hash();
-    let pso_pmfx = pmfx.get_render_pipeline_for_format("default", fmt)?;
-
-    // create pipeline manually
-    let vsc_filepath = crate::get_data_path("shaders/imgui/vs_main.vsc");
-    let psc_filepath = crate::get_data_path("shaders/imgui/ps_main.psc");
-
-    let vsc_data = std::fs::read(vsc_filepath)?;
-    let psc_data = std::fs::read(psc_filepath)?;
-
-    let vs_info = gfx::ShaderInfo {
-        shader_type: gfx::ShaderType::Vertex,
-        compile_info: None
-    };
-
-    let ps_info = gfx::ShaderInfo {
-        shader_type: gfx::ShaderType::Fragment,
-        compile_info: None
-    };
-
-    let vs = dev.create_shader(&vs_info, &vsc_data)?;
-    let fs = dev.create_shader(&ps_info, &psc_data)?;
-
     // ..
     let mut ci = 0;
     while app.run() {

examples/play_video/main.rs

@@ -1,5 +1,4 @@
 use hotline_rs::prelude::*;
-use hotline_rs::*;
 
 fn main() -> Result<(), hotline_rs::Error> {
     // app

examples/raytraced_triangle/main.rs

@@ -5,7 +5,6 @@ use gfx::RaytracingInstanceInfo;
 use gfx::RaytracingTLASInfo;
 use hotline_rs::gfx::RaytracingTLAS;
 use hotline_rs::gfx::Texture;
-use hotline_rs::gfx::Pipeline;
 use hotline_rs::*;
 
 use gfx::CmdBuf;

examples/resource_tests/main.rs

@@ -1,4 +1,4 @@
-use hotline_rs::{*, prelude::{Pipeline, Texture}};
+use hotline_rs::{*, prelude::{Texture}};
 
 use os::{App, Window};
 use gfx::{CmdBuf, Device, SwapChain, RenderPass};

examples/swap_chain/main.rs

@@ -1,5 +1,4 @@
 use hotline_rs::*;
-use hotline_rs::prelude::*;
 use hotline_rs::gfx::CmdBuf;
 use hotline_rs::gfx::RenderPassInfo;
 use hotline_rs::gfx::SwapChain;
@@ -9,7 +8,6 @@ use os::Window;
 
 use gfx::Device;
 
-use maths_rs::Vec3f;
 use maths_rs::vec::vec3f;
 use maths_rs::cos;
 

plugins/ecs/src/lib.rs

@@ -534,6 +534,12 @@ impl BevyPlugin {
     }
 
     fn spawn_main_camera(&mut self) {
+        // despawn any existing so this is safe to call multiple times
+        let mut q = self.world.query::<(Entity, &MainCamera)>();
+        let existing: Vec<Entity> = q.iter(&self.world).map(|(e, _)| e).collect();
+        for e in existing {
+            self.world.despawn(e);
+        }
         let (cam, vp, pos) = self.setup_camera();
         self.world.spawn((
             ViewProjectionMatrix(vp),
@@ -708,11 +714,7 @@ impl Plugin<gfx_platform::Device, os_platform::App> for BevyPlugin {
 
         // run setup if requested, we did it here so hotline resources are inserted into World
         if self.run_setup {
-            // only spawn if resetup() hasn't already spawned it (ui() runs before update())
-            if self.world.query_filtered::<Entity, With<MainCamera>>().iter(&self.world).next().is_none() {
-                self.spawn_main_camera();
-            }
-
+            self.spawn_main_camera();
             self.setup_schedule.run(&mut self.world);
             self.run_setup = false;
         }

shaders/bindless.hlsl

@@ -60,12 +60,4 @@ ps_output ps_main(ps_input input) {
 
     output.colour = final;
     return output;
-}
-
-RWTexture2D<float4> rwtex[10] : register(u0);
-
-[numthreads(16, 16, 1)]
-void cs_main(uint3 did : SV_DispatchThreadID)
-{
-    rwtex[7][did.xy] = float4(0.0, 0.0, 0.0, 1.0);
 }

shaders/bindless.pmfx

@@ -23,8 +23,5 @@
             }
             topology: "TriangleList"
         }
-        compute_rw: {
-            cs: "cs_main"
-        }
     }
 }