Add pulsing effect when invulnerable/intangible, make airdodge make the player intangible. (#75)

Reviewed-on: #75
Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>

src/materials/fighter_material.rs

@@ -0,0 +1,77 @@
+use bevy::{gltf::GltfMaterialName, pbr::{ExtendedMaterial, MaterialExtension}, prelude::*, render::render_resource::AsBindGroup, shader::ShaderRef, world_serialization::WorldInstanceReady};
+
+pub type FighterMaterial = ExtendedMaterial<StandardMaterial, FighterMaterialExtension>;
+
+#[derive(Component)]
+pub struct FighterMesh {
+    pub fighter: Entity
+}
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone, Default)]
+pub struct FighterMaterialExtension {
+    #[uniform(100)]
+    status_color: LinearRgba,
+    #[uniform(100)]
+    status_color_intensity: f32,
+}
+
+const SHADER_ASSET_PATH: &str = "embedded://shinespark/shaders/fighter.wgsl";
+
+impl FighterMaterialExtension {
+    pub fn new(status_color: Color) -> Self {
+        Self {
+            status_color: status_color.into(),
+            status_color_intensity: 0.0,
+            ..default()
+        }
+    }
+
+    pub fn update_status_color(&mut self, status_color: LinearRgba, intensity: f32) {
+        self.status_color = status_color;
+        self.status_color_intensity = intensity;
+    }
+}
+
+impl MaterialExtension for FighterMaterialExtension {
+    fn fragment_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+
+    fn deferred_fragment_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+}
+
+pub fn bind_fighter_material(
+    scene_ready: On<WorldInstanceReady>,
+    mut commands: Commands,
+    children: Query<&Children>,
+    //color_override: Query<&ColorOverride>,
+    mesh_materials: Query<(Entity, &MeshMaterial3d<StandardMaterial>, &GltfMaterialName)>,
+    mut asset_materials: ResMut<Assets<FighterMaterial>>,
+    original_materials: Res<Assets<StandardMaterial>>,
+) {
+    for descendant in children.iter_descendants(scene_ready.entity) {
+        let Ok((entity, id, material_name)) = mesh_materials.get(descendant) else {
+            continue;
+        };
+
+        dbg!(material_name);
+
+        if !material_name.starts_with("Fighter_") {
+            continue;
+        }
+
+        let Some(original_material) = original_materials.get(id.id()) else {
+            continue;
+        };
+
+        commands.entity(entity).insert((MeshMaterial3d(asset_materials.add(ExtendedMaterial {
+            base: StandardMaterial {
+                // can be used in forward or deferred mode
+                ..original_material.clone()
+            },
+            extension: FighterMaterialExtension::new(bevy::color::palettes::css::BLUE.into())
+        })), FighterMesh { fighter: scene_ready.entity  }));
+    }
+}

src/materials/mod.rs

@@ -0,0 +1,24 @@
+use bevy::{
+    asset::embedded_asset, prelude::*,
+};
+
+
+
+pub mod fighter_material;
+
+pub struct ShinesparkMaterialPlugin;
+
+pub fn startup_test(asset_server: Res<AssetServer>) {
+    let test: Handle<Shader> = asset_server.load("embedded://shinespark/shaders/fighter.wgsl");
+    dbg!(test);
+}
+
+impl Plugin for ShinesparkMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        let omit_prefix = "";
+        embedded_asset!(app, omit_prefix, "shaders/fighter.wgsl");
+        app.add_systems(Startup, startup_test)
+            .add_observer(fighter_material::bind_fighter_material)
+            .add_plugins(MaterialPlugin::<fighter_material::FighterMaterial>::default());
+    }
+}

src/materials/shaders/fighter.wgsl

@@ -0,0 +1,67 @@
+#import bevy_pbr::{
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::alpha_discard,
+}
+
+#ifdef PREPASS_PIPELINE
+#import bevy_pbr::{
+    prepass_io::{VertexOutput, FragmentOutput},
+    pbr_deferred_functions::deferred_output,
+}
+#else
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+}
+#endif
+
+struct FighterExtendedMaterial {
+    status_color: vec4<f32>,
+    status_color_intensity: f32,
+#ifdef SIXTEEN_BYTE_ALIGNMENT
+    // Web examples WebGL2 support: structs must be 16 byte aligned.
+    _webgl2_padding_8b: u32,
+    _webgl2_padding_12b: u32,
+    _webgl2_padding_16b: u32,
+#endif
+}
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(100)
+var<uniform> fighter_material: FighterExtendedMaterial;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+) -> FragmentOutput {
+    // generate a PbrInput struct from the StandardMaterial bindings
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+
+    // we can optionally modify the input before lighting and alpha_discard is applied
+    //pbr_input.material.base_color.b = pbr_input.material.base_color.r;
+
+    // alpha discard
+    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+#ifdef PREPASS_PIPELINE
+    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
+    let out = deferred_output(in, pbr_input);
+#else
+    var out: FragmentOutput;
+    // apply lighting
+    out.color = apply_pbr_lighting(pbr_input);
+
+    // we can optionally modify the lit color before post-processing is applied
+    var quantize_steps: i32 = 2;
+    out.color = vec4<f32>(vec4<u32>(out.color * f32(quantize_steps))) / f32(quantize_steps);
+
+    // apply in-shader post processing (fog, alpha-premultiply, and also tonemapping, debanding if the camera is non-hdr)
+    // note this does not include fullscreen postprocessing effects like bloom.
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+
+    out.color = mix(out.color, fighter_material.status_color, fighter_material.status_color_intensity * 0.5);
+
+#endif
+
+    return out;
+}