Merge pull request #270 from StarArawn/bevy-shader-imports

Bevy shader imports

Cargo.toml

@@ -15,7 +15,7 @@ atlas = []
 render = []
 
 [dependencies]
-bevy = { version = "0.8", default-features = false, features=["bevy_core_pipeline", "bevy_render", "bevy_asset"] }
+bevy = { version = "0.8", default-features = false, features=["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_sprite"] }
 log = "0.4"
 regex = "1.5.4"
 

examples/mouse_to_tile.rs

@@ -265,7 +265,7 @@ fn swap_map_type(
                             -0.5 * window.width() / 2.0,
                             0.8 * window.height() / 2.0,
                         )
-                        .extend(0.0),
+                        .extend(1.0),
                         ..Default::default()
                     };
                     *label_text = Text::from_section(

src/render/mod.rs

@@ -1,8 +1,10 @@
 use std::marker::PhantomData;
 
 use bevy::{
+    asset::load_internal_asset,
     core_pipeline::core_2d::Transparent2d,
     prelude::*,
+    reflect::TypeUuid,
     render::{
         mesh::MeshVertexAttribute,
         render_phase::AddRenderCommand,
@@ -25,12 +27,7 @@ use crate::{
 use self::{
     chunk::{RenderChunk2dStorage, TilemapUniformData},
     draw::DrawTilemap,
-    pipeline::{
-        TilemapPipeline, HEX_COLUMN_EVEN_SHADER_HANDLE, HEX_COLUMN_ODD_SHADER_HANDLE,
-        HEX_COLUMN_SHADER_HANDLE, HEX_ROW_EVEN_SHADER_HANDLE, HEX_ROW_ODD_SHADER_HANDLE,
-        HEX_ROW_SHADER_HANDLE, ISO_DIAMOND_SHADER_HANDLE, ISO_STAGGERED_SHADER_HANDLE,
-        SQUARE_SHADER_HANDLE,
-    },
+    pipeline::{TilemapPipeline, TILEMAP_SHADER_FRAGMENT, TILEMAP_SHADER_VERTEX},
     prepare::MeshUniform,
     queue::ImageBindGroups,
 };
@@ -86,6 +83,31 @@ pub struct TilemapRenderingPlugin;
 #[derive(Default, Deref, DerefMut)]
 pub struct SecondsSinceStartup(f32);
 
+pub const COLUMN_EVEN_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 7704924705970804993);
+pub const COLUMN_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 11710877199891728627);
+pub const COLUMN_ODD_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 6706359414982022142);
+pub const COMMON: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 15420881977837458322);
+pub const DIAMOND_ISO: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 6710251300621614118);
+pub const MESH_OUTPUT: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 2707251459590872179);
+pub const ROW_EVEN_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 7149718726759672633);
+pub const ROW_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 5506589682629967569);
+pub const ROW_ODD_HEX: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 13608302855194400936);
+pub const STAGGERED_ISO: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 9802843761568314416);
+pub const SQUARE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 7333720254399106799);
+pub const TILEMAP_VERTEX_OUTPUT: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 6104533649830094529);
+
 impl Plugin for TilemapRenderingPlugin {
     fn build(&self, app: &mut App) {
         #[cfg(not(feature = "atlas"))]
@@ -104,66 +126,90 @@ impl Plugin for TilemapRenderingPlugin {
             }
         };
 
-        let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
+        load_internal_asset!(
+            app,
+            COLUMN_EVEN_HEX,
+            "shaders/column_even_hex.wgsl",
+            Shader::from_wgsl
+        );
 
-        #[cfg(not(feature = "atlas"))]
-        let tilemap_shader = include_str!("shaders/tilemap.wgsl");
-        #[cfg(feature = "atlas")]
-        let tilemap_shader = include_str!("shaders/tilemap-atlas.wgsl");
-
-        let square_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/square.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(SQUARE_SHADER_HANDLE, square_shader);
-
-        let iso_diamond_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/diamond_iso.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(ISO_DIAMOND_SHADER_HANDLE, iso_diamond_shader);
-
-        let iso_staggered_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/staggered_iso.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(ISO_STAGGERED_SHADER_HANDLE, iso_staggered_shader);
-
-        let hex_column_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/column_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_COLUMN_SHADER_HANDLE, hex_column_shader);
-
-        let hex_column_odd_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/column_odd_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_COLUMN_ODD_SHADER_HANDLE, hex_column_odd_shader);
-
-        let hex_column_even_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/column_even_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_COLUMN_EVEN_SHADER_HANDLE, hex_column_even_shader);
-
-        let hex_row_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/row_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_ROW_SHADER_HANDLE, hex_row_shader);
-
-        let hex_row_odd_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/row_odd_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_ROW_ODD_SHADER_HANDLE, hex_row_odd_shader);
-
-        let hex_row_even_shader = Shader::from_wgsl(include_shader::include_shader(
-            vec![include_str!("shaders/row_even_hex.wgsl")],
-            tilemap_shader,
-        ));
-        shaders.set_untracked(HEX_ROW_EVEN_SHADER_HANDLE, hex_row_even_shader);
+        load_internal_asset!(
+            app,
+            COLUMN_HEX,
+            "shaders/column_hex.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            COLUMN_ODD_HEX,
+            "shaders/column_odd_hex.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(app, COMMON, "shaders/common.wgsl", Shader::from_wgsl);
+
+        load_internal_asset!(
+            app,
+            DIAMOND_ISO,
+            "shaders/diamond_iso.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            ROW_EVEN_HEX,
+            "shaders/row_even_hex.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(app, ROW_HEX, "shaders/row_hex.wgsl", Shader::from_wgsl);
+
+        load_internal_asset!(
+            app,
+            ROW_ODD_HEX,
+            "shaders/row_odd_hex.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(app, ROW_HEX, "shaders/row_hex.wgsl", Shader::from_wgsl);
+
+        load_internal_asset!(
+            app,
+            MESH_OUTPUT,
+            "shaders/mesh_output.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(app, SQUARE, "shaders/square.wgsl", Shader::from_wgsl);
+
+        load_internal_asset!(
+            app,
+            STAGGERED_ISO,
+            "shaders/staggered_iso.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            TILEMAP_VERTEX_OUTPUT,
+            "shaders/tilemap_vertex_output.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            TILEMAP_SHADER_VERTEX,
+            "shaders/tilemap_vertex.wgsl",
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            TILEMAP_SHADER_FRAGMENT,
+            "shaders/tilemap_fragment.wgsl",
+            Shader::from_wgsl
+        );
 
         let render_app = app.sub_app_mut(RenderApp);
         render_app

src/render/pipeline.rs

@@ -21,24 +21,10 @@ use crate::map::{HexCoordSystem, IsoCoordSystem, TilemapType};
 
 use super::{chunk::TilemapUniformData, prepare::MeshUniform};
 
-pub const SQUARE_SHADER_HANDLE: HandleUntyped =
+pub const TILEMAP_SHADER_VERTEX: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 8094008129742001941);
-pub const ISO_DIAMOND_SHADER_HANDLE: HandleUntyped =
+pub const TILEMAP_SHADER_FRAGMENT: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 5716002228110903793);
-pub const ISO_STAGGERED_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 6571326172373592468);
-pub const HEX_COLUMN_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 12158158650956014109);
-pub const HEX_COLUMN_ODD_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 11472021184100190415);
-pub const HEX_COLUMN_EVEN_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 5336568075571462317);
-pub const HEX_ROW_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 15900471900964169180);
-pub const HEX_ROW_ODD_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 14864388685772956547);
-pub const HEX_ROW_EVEN_SHADER_HANDLE: HandleUntyped =
-    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 14433932828806852042);
 
 #[derive(Clone)]
 pub struct TilemapPipeline {
@@ -166,24 +152,30 @@ impl SpecializedRenderPipeline for TilemapPipeline {
     type Key = TilemapPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
-        let shader = match key.mesh_type {
-            TilemapType::Square { .. } => SQUARE_SHADER_HANDLE.typed::<Shader>(),
+        let mut shader_defs = Vec::new();
+
+        #[cfg(feature = "atlas")]
+        shader_defs.push("ATLAS".into());
+
+        let mesh_string = match key.mesh_type {
+            TilemapType::Square { .. } => "SQUARE",
             TilemapType::Isometric {
                 coord_system: iso_type,
                 ..
             } => match iso_type {
-                IsoCoordSystem::Diamond => ISO_DIAMOND_SHADER_HANDLE.typed::<Shader>(),
-                IsoCoordSystem::Staggered => ISO_STAGGERED_SHADER_HANDLE.typed::<Shader>(),
+                IsoCoordSystem::Diamond => "ISO_DIAMOND",
+                IsoCoordSystem::Staggered => "ISO_STAGGERED",
             },
             TilemapType::Hexagon(hex_type) => match hex_type {
-                HexCoordSystem::Column => HEX_COLUMN_SHADER_HANDLE.typed::<Shader>(),
-                HexCoordSystem::ColumnEven => HEX_COLUMN_EVEN_SHADER_HANDLE.typed::<Shader>(),
-                HexCoordSystem::ColumnOdd => HEX_COLUMN_ODD_SHADER_HANDLE.typed::<Shader>(),
-                HexCoordSystem::Row => HEX_ROW_SHADER_HANDLE.typed::<Shader>(),
-                HexCoordSystem::RowEven => HEX_ROW_EVEN_SHADER_HANDLE.typed::<Shader>(),
-                HexCoordSystem::RowOdd => HEX_ROW_ODD_SHADER_HANDLE.typed::<Shader>(),
+                HexCoordSystem::Column => "COLUMN_HEX",
+                HexCoordSystem::ColumnEven => "COLUMN_EVEN_HEX",
+                HexCoordSystem::ColumnOdd => "COLUMN_ODD_HEX",
+                HexCoordSystem::Row => "ROW_HEX",
+                HexCoordSystem::RowEven => "ROW_EVEN_HEX",
+                HexCoordSystem::RowOdd => "ROW_ODD_HEX",
             },
         };
+        shader_defs.push(mesh_string.into());
 
         let formats = vec![
             // Position
@@ -199,14 +191,14 @@ impl SpecializedRenderPipeline for TilemapPipeline {
 
         RenderPipelineDescriptor {
             vertex: VertexState {
-                shader: shader.clone(),
+                shader: TILEMAP_SHADER_VERTEX.typed::<Shader>(),
                 entry_point: "vertex".into(),
-                shader_defs: vec![],
+                shader_defs: shader_defs.clone(),
                 buffers: vec![vertex_layout],
             },
             fragment: Some(FragmentState {
-                shader,
-                shader_defs: vec![],
+                shader: TILEMAP_SHADER_FRAGMENT.typed::<Shader>(),
+                shader_defs,
                 entry_point: "fragment".into(),
                 targets: vec![Some(ColorTargetState {
                     format: TextureFormat::bevy_default(),

src/render/shaders/column_even_hex.wgsl

@@ -1,10 +1,10 @@
-struct Output {
-    world_position: vec4<f32>,
-    uv: vec2<f32>,
-};
+#define_import_path bevy_ecs_tilemap::column_even_hex
+
+#import bevy_ecs_tilemap::mesh_output
 
 let SQRT_3: f32 = 1.7320508;
 let HALF_SQRT_3: f32 = 0.8660254;
+
 let COL_BASIS_X: vec2<f32> = vec2<f32>(HALF_SQRT_3, 0.5);
 let COL_BASIS_Y: vec2<f32> = vec2<f32>(0.0, 1.0);
 
@@ -18,9 +18,8 @@ fn col_even_to_axial(offset_pos: vec2<f32>) -> vec2<f32> {
     let delta: f32 = ceil(offset_pos.x / 2.0);
     return vec2<f32>(offset_pos.x, offset_pos.y - delta);
 }
-
-fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> Output {
-    var out: Output;
+fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> MeshOutput {
+    var out: MeshOutput;
 
     var axial_pos = col_even_to_axial(vertex_position.xy);
     var center = hex_col_tile_pos_to_world_pos(axial_pos, tilemap_data.grid_size.x, tilemap_data.grid_size.y);

src/render/shaders/column_hex.wgsl

@@ -1,7 +1,6 @@
-struct Output {
-    world_position: vec4<f32>,
-    uv: vec2<f32>,
-};
+#define_import_path bevy_ecs_tilemap::column_hex
+
+#import bevy_ecs_tilemap::mesh_output
 
 let SQRT_3: f32 = 1.7320508;
 let HALF_SQRT_3: f32 = 0.8660254;
@@ -14,9 +13,10 @@ fn hex_col_tile_pos_to_world_pos(pos: vec2<f32>, grid_width: f32, grid_height: f
     return vec2<f32>(COL_BASIS_X.x * grid_width * unscaled_pos.x, grid_height * unscaled_pos.y);
 }
 
-fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> Output {
-    var out: Output;
-
+
+fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> MeshOutput {
+    var out: MeshOutput;
+
     var center = hex_col_tile_pos_to_world_pos(vertex_position.xy, tilemap_data.grid_size.x, tilemap_data.grid_size.y);
     var bot_left = center - 0.5 * tilemap_data.tile_size;
     var top_right = bot_left + tilemap_data.tile_size;

src/render/shaders/column_odd_hex.wgsl

@@ -1,7 +1,6 @@
-struct Output {
-    world_position: vec4<f32>,
-    uv: vec2<f32>,
-};
+#define_import_path bevy_ecs_tilemap::column_odd_hex
+
+#import bevy_ecs_tilemap::mesh_output
 
 let SQRT_3: f32 = 1.7320508;
 let HALF_SQRT_3: f32 = 0.8660254;
@@ -19,8 +18,8 @@ fn col_even_to_axial(offset_pos: vec2<f32>) -> vec2<f32> {
     return vec2<f32>(offset_pos.x, offset_pos.y - delta);
 }
 
-fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> Output {
-    var out: Output;
+fn get_mesh(v_index: u32, vertex_position: vec3<f32>) -> MeshOutput {
+    var out: MeshOutput;
 
     var axial_pos = col_even_to_axial(vertex_position.xy);
     var center = hex_col_tile_pos_to_world_pos(axial_pos, tilemap_data.grid_size.x, tilemap_data.grid_size.y);