outfly/src/visual.rs

//   ▄████████▄      +        ███ +  ▄█████████ ███     +
//  ███▀    ▀███ +         +  ███    ███▀  +    ███ +       +
//  ███  +   ███ ███   ███ █████████ ███        ███  ███   ███
//  ███     +███ ███   ███    ███    ███▐██████ ███  ███   ███
//  ███ +    ███ ███+  ███   +███    ███     +  ███  ███ + ███
//  ███▄    ▄███ ███▄  ███    ███ +  ███  +     ███  ███▄  ███
//   ▀████████▀ + ▀███████    ███▄   ███▄       ▀████ ▀███████
//       +                  +                +             ███
//  +   ▀████████████████████████████████████████████████████▀
//
// This module manages visual effects.

use crate::prelude::*;
use bevy::prelude::*;
use std::time::Duration;

pub struct VisualPlugin;

impl Plugin for VisualPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, setup.after(menu::setup).after(hud::setup));
        app.add_systems(
            Startup,
            spawn_effects.after(setup).after(camera::setup_camera),
        );
        app.add_systems(Update, spawn_effects);
        app.add_systems(Update, update_fadein);
        app.add_systems(Update, update_fadeout);
        app.add_systems(Update, play_animations);
        // Blackout disabled for now
        //app.add_systems(Update, update_blackout);
        app.add_event::<SpawnEffectEvent>();
    }
}

#[derive(Clone)]
pub enum Effects {
    FadeIn(Color),
    FadeOut(Color),
}

// Blackout disabled for now
//#[derive(Component)] pub struct BlackOutOverlay;

#[derive(Component)]
pub struct FadeIn;
#[derive(Component)]
pub struct FadeOut;
#[derive(Component)]
pub struct Effect {
    pub class: Effects,
    pub duration: f64,
    pub start_time: f64,
}
#[derive(Event)]
pub struct SpawnEffectEvent {
    pub class: Effects,
    pub duration: f64,
}

#[derive(Resource)]
pub struct SuitAnimation {
    index: AnimationNodeIndex,
    graph: Handle<AnimationGraph>
}

pub fn setup(
    settings: Res<var::Settings>,
    asset_server: Res<AssetServer>,
    mut commands: Commands,
    mut ew_effect: EventWriter<SpawnEffectEvent>,
    mut graphs: ResMut<Assets<AnimationGraph>>,
) {
    if !settings.dev_mode {
        ew_effect.send(SpawnEffectEvent {
            class: Effects::FadeIn(Color::BLACK),
            duration: 4.0,
        });
    }

    let mut graph = AnimationGraph::new();
    let index = graph.add_clip(
        asset_server.load(GltfAssetLabel::Animation(0).from_asset("models/suit_v2/suit_v2.glb")),
        1.0,
        graph.root,
    );

    let graph = graphs.add(graph);
    commands.insert_resource(SuitAnimation { index, graph });

    // Blackout disabled for now
    //    commands.spawn((
    //        BlackOutOverlay,
    //        NodeBundle {
    //            style: Style {
    //                width: Val::Vw(100.0),
    //                height: Val::Vh(100.0),
    //                position_type: PositionType::Absolute,
    //                top: Val::Px(0.0),
    //                left: Val::Px(0.0),
    //                ..default()
    //            },
    //            background_color: Color::BLACK.into(),
    //            ..default()
    //        },
    //    ));
}

pub fn spawn_effects(
    mut commands: Commands,
    mut er_effect: EventReader<SpawnEffectEvent>,
    time: Res<Time>,
) {
    let now = time.elapsed_seconds_f64();
    for effect in er_effect.read() {
        match effect.class {
            Effects::FadeIn(color) => {
                commands.spawn((
                    Effect {
                        class: effect.class.clone(),
                        duration: effect.duration,
                        start_time: now,
                    },
                    FadeIn,
                    NodeBundle {
                        style: style_fullscreen(),
                        background_color: color.into(),
                        ..default()
                    },
                ));
            }
            Effects::FadeOut(color) => {
                commands.spawn((
                    Effect {
                        class: effect.class.clone(),
                        duration: effect.duration,
                        start_time: now,
                    },
                    FadeOut,
                    NodeBundle {
                        style: style_fullscreen(),
                        background_color: color.with_alpha(0.0).into(),
                        ..default()
                    },
                ));
            }
        }
    }
}

pub fn update_fadein(
    mut commands: Commands,
    mut q_effect: Query<(Entity, &Effect, &mut BackgroundColor), With<FadeIn>>,
    time: Res<Time>,
) {
    for (entity, effect, mut bgcolor) in &mut q_effect {
        let now = time.elapsed_seconds_f64();
        if effect.start_time + effect.duration < now {
            commands.entity(entity).despawn();
            continue;
        }
        let alpha = (1.3 - 1.3 * (now - effect.start_time) / effect.duration).clamp(0.0, 1.0);
        bgcolor.0.set_alpha(alpha as f32);
    }
}

pub fn update_fadeout(
    mut commands: Commands,
    mut q_effect: Query<(Entity, &Effect, &mut BackgroundColor), With<FadeOut>>,
    time: Res<Time>,
) {
    for (entity, effect, mut bgcolor) in &mut q_effect {
        let now = time.elapsed_seconds_f64();
        if effect.start_time + effect.duration < now {
            commands.entity(entity).despawn();
            continue;
        }
        let alpha = ((now - effect.start_time) / effect.duration).clamp(0.0, 1.0);
        bgcolor.0.set_alpha(alpha as f32);
    }
}

fn play_animations(
    mut commands: Commands,
    mut players: Query<(Entity, &mut AnimationPlayer), Added<AnimationPlayer>>,
    suit_animation: Res<SuitAnimation>,
) {
    for (entity, mut player) in &mut players {
        let mut transitions = AnimationTransitions::new();
        transitions
            .play(&mut player, suit_animation.index, Duration::ZERO)
            .repeat();
        commands.entity(entity).insert(suit_animation.graph.clone()).insert(transitions);
        //player.play(suit_ani_node_index.0).repeat();
    }
}

// Blackout disabled for now
//pub fn update_blackout(
//    mut q_effect: Query<&mut BackgroundColor, With<BlackOutOverlay>>,
//    q_player: Query<&actor::ExperiencesGForce, With<actor::Player>>
//) {
//    if let (Ok(gforce), Ok(mut bgcolor)) = (q_player.get_single(), q_effect.get_single_mut()) {
//        let threshold = 0.3;
//        let factor = 1.0 / (1.0 - threshold);
//        let alpha = (factor * (gforce.blackout - threshold)).clamp(0.0, 1.0);
//        bgcolor.0.set_alpha(alpha as f32);
//    }
//}