- move imgui to use loaded shader from disk instead of embedded shader source in code

Author: GBDixonAlex

examples/imgui_demo/main.rs

@@ -3,6 +3,8 @@ use hotline_rs::{*, prelude::*};
 use os::{App, Window};
 use gfx::{CmdBuf, Device, SwapChain};
 
+use std::fs;
+
 #[repr(C)]
 struct Vertex {
     position: [f32; 2],
@@ -53,21 +55,13 @@ fn main() -> Result<(), hotline_rs::Error> {
     let mut swap_chain = dev.create_swap_chain::<os_platform::App>(&swap_chain_info, &win)?;
     let mut cmdbuffer = dev.create_cmd_buf(2);
 
-    let exe_path = std::env::current_exe().ok().unwrap();
-    let asset_path = exe_path.parent().unwrap().join("../..");
-
-    let font_path = asset_path
-        .join("data/fonts/roboto_medium.ttf")
-        .to_str()
-        .unwrap()
-        .to_string();
-
+    let roboto = get_data_path("fonts/roboto_medium.ttf");
     let mut imgui_info = imgui::ImGuiInfo {
         device: &mut dev,
         swap_chain: &mut swap_chain,
         main_window: &win,
         fonts: vec![imgui::FontInfo {
-            filepath: font_path,
+            filepath: roboto,
             glyph_ranges: None
         }],
         monitors: app.enumerate_display_monitors()

shaders/imgui.hlsl

@@ -21,7 +21,7 @@ struct PS_INPUT
 PS_INPUT vs_main(VS_INPUT input)
 {
     PS_INPUT output;
-    output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.0, 1.0));
+    output.pos = mul(float4(input.pos.xy, 0.0, 1.0), ProjectionMatrix);
     output.col = input.col;
     output.uv  = input.uv;
     return output;

src/imgui.rs

@@ -14,10 +14,11 @@ use crate::gfx::Device;
 use crate::gfx::SwapChain;
 use crate::gfx::Texture;
 
+use maths_rs::Vec4f;
+
 use std::ffi::CStr;
 use std::ffi::CString;
-
-use maths_rs::Vec4f;
+use std::fs;
 
 use crate::static_ref;
 use crate::static_ref_mut;
@@ -240,64 +241,24 @@ fn create_render_pipeline<D: Device, A: App>(info: &ImGuiInfo<D, A>) -> Result<D
     let device = &info.device;
     let swap_chain = &info.swap_chain;
 
-    // TODO: temp: compile shaders
-    let src = "
-        cbuffer vertexBuffer : register(b0)
-        {
-            float4x4 ProjectionMatrix;
-        };
-        struct VS_INPUT
-        {
-            float2 pos : POSITION;
-            float4 col : COLOR0;
-            float2 uv  : TEXCOORD0;
-        };
+    let vsc_filepath = crate::get_data_path("shaders/imgui/vs_main.vsc");
+    let psc_filepath = crate::get_data_path("shaders/imgui/ps_main.psc");
 
-        struct PS_INPUT
-        {
-            float4 pos : SV_POSITION;
-            float4 col : COLOR0;
-            float2 uv  : TEXCOORD0;
-        };
-
-        PS_INPUT VSMain(VS_INPUT input)
-        {
-            PS_INPUT output;
-            output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.0, 1.0));
-            output.col = input.col;
-            output.uv  = input.uv;
-            return output;
-        }
-
-        SamplerState sampler0 : register(s0);
-        Texture2D texture0 : register(t0);
-
-        float4 PSMain(PS_INPUT input) : SV_Target
-        {
-            float4 out_col = input.col * texture0.Sample(sampler0, input.uv);
-            return out_col;
-        }";
+    let vsc_data = fs::read(vsc_filepath)?;
+    let psc_data = fs::read(psc_filepath)?;
 
     let vs_info = gfx::ShaderInfo {
         shader_type: gfx::ShaderType::Vertex,
-        compile_info: Some(gfx::ShaderCompileInfo {
-            entry_point: String::from("VSMain"),
-            target: String::from("vs_5_0"),
-            flags: gfx::ShaderCompileFlags::NONE,
-        }),
+        compile_info: None
     };
 
-    let fs_info = gfx::ShaderInfo {
+    let ps_info = gfx::ShaderInfo {
         shader_type: gfx::ShaderType::Fragment,
-        compile_info: Some(gfx::ShaderCompileInfo {
-            entry_point: String::from("PSMain"),
-            target: String::from("ps_5_0"),
-            flags: gfx::ShaderCompileFlags::NONE,
-        }),
+        compile_info: None
     };
 
-    let vs = device.create_shader(&vs_info, src.as_bytes())?;
-    let fs = device.create_shader(&fs_info, src.as_bytes())?;
+    let vs = device.create_shader(&vs_info, &vsc_data)?;
+    let fs = device.create_shader(&ps_info, &psc_data)?;
 
     device.create_render_pipeline(&gfx::RenderPipelineInfo {
         vs: Some(&vs),