lyra-engine/examples/lua-scripting/src/main.rs

use std::ptr::NonNull;

use lyra_engine::{
    assets::{gltf::Gltf, ResourceManager}, ecs::{
        query::{Res, ResMut, View},
        system::{BatchedSystem, Criteria, CriteriaSchedule, IntoSystem},
        World,
    }, game::Game, input::{
        Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource,
        InputActionPlugin, KeyCode, LayoutId, MouseAxis, MouseInput,
    }, lua::{LuaScript, LuaScriptingPlugin}, math::{self, Transform, Vec3}, render::light::directional::DirectionalLight, scene::{
        CameraComponent, FreeFlyCamera, FreeFlyCameraPlugin, WorldTransform,
        ACTLBL_LOOK_LEFT_RIGHT, ACTLBL_LOOK_ROLL, ACTLBL_LOOK_UP_DOWN,
        ACTLBL_MOVE_FORWARD_BACKWARD, ACTLBL_MOVE_LEFT_RIGHT, ACTLBL_MOVE_UP_DOWN,
    }, DeltaTime, Script, ScriptList
};
use tracing::info;

#[async_std::main]
async fn main() {
    let action_handler_plugin = |game: &mut Game| {
        let action_handler = ActionHandler::builder()
            .add_layout(LayoutId::from(0))
            .add_action(ACTLBL_MOVE_FORWARD_BACKWARD, Action::new(ActionKind::Axis))
            .add_action(ACTLBL_MOVE_LEFT_RIGHT, Action::new(ActionKind::Axis))
            .add_action(ACTLBL_MOVE_UP_DOWN, Action::new(ActionKind::Axis))
            .add_action(ACTLBL_LOOK_LEFT_RIGHT, Action::new(ActionKind::Axis))
            .add_action(ACTLBL_LOOK_UP_DOWN, Action::new(ActionKind::Axis))
            .add_action(ACTLBL_LOOK_ROLL, Action::new(ActionKind::Axis))
            .add_action("Debug", Action::new(ActionKind::Button))
            .add_mapping(
                ActionMapping::builder(LayoutId::from(0), ActionMappingId::from(0))
                    .bind(
                        ACTLBL_MOVE_FORWARD_BACKWARD,
                        &[
                            ActionSource::Keyboard(KeyCode::W).into_binding_modifier(1.0),
                            ActionSource::Keyboard(KeyCode::S).into_binding_modifier(-1.0),
                        ],
                    )
                    .bind(
                        ACTLBL_MOVE_LEFT_RIGHT,
                        &[
                            ActionSource::Keyboard(KeyCode::A).into_binding_modifier(-1.0),
                            ActionSource::Keyboard(KeyCode::D).into_binding_modifier(1.0),
                        ],
                    )
                    .bind(
                        ACTLBL_MOVE_UP_DOWN,
                        &[
                            ActionSource::Keyboard(KeyCode::C).into_binding_modifier(1.0),
                            ActionSource::Keyboard(KeyCode::Z).into_binding_modifier(-1.0),
                        ],
                    )
                    .bind(
                        ACTLBL_LOOK_LEFT_RIGHT,
                        &[
                            ActionSource::Mouse(MouseInput::Axis(MouseAxis::X)).into_binding(),
                            ActionSource::Keyboard(KeyCode::Left).into_binding_modifier(-1.0),
                            ActionSource::Keyboard(KeyCode::Right).into_binding_modifier(1.0),
                        ],
                    )
                    .bind(
                        ACTLBL_LOOK_UP_DOWN,
                        &[
                            ActionSource::Mouse(MouseInput::Axis(MouseAxis::Y)).into_binding(),
                            ActionSource::Keyboard(KeyCode::Up).into_binding_modifier(-1.0),
                            ActionSource::Keyboard(KeyCode::Down).into_binding_modifier(1.0),
                        ],
                    )
                    .bind(
                        ACTLBL_LOOK_ROLL,
                        &[
                            ActionSource::Keyboard(KeyCode::E).into_binding_modifier(-1.0),
                            ActionSource::Keyboard(KeyCode::Q).into_binding_modifier(1.0),
                        ],
                    )
                    .bind(
                        "Debug",
                        &[ActionSource::Keyboard(KeyCode::B).into_binding()],
                    )
                    .finish(),
            )
            .finish();

        let world = game.world_mut();
        world.add_resource(action_handler);
        game.with_plugin(InputActionPlugin);
    };

    Game::initialize()
        .await
        .with_plugin(lyra_engine::DefaultPlugins)
        .with_plugin(setup_scene_plugin)
        .with_plugin(action_handler_plugin)
        .with_plugin(setup_script_plugin)
        //.with_plugin(camera_debug_plugin)
        .with_plugin(FreeFlyCameraPlugin)
        .run()
        .await;
}

fn setup_scene_plugin(game: &mut Game) {
    let world = game.world_mut();
    let resman = world.get_resource_mut::<ResourceManager>();
    let camera_gltf = resman
        .request::<Gltf>("../assets/AntiqueCamera.glb")
        .unwrap();

    camera_gltf.wait_recurse_dependencies_load();
    let camera_mesh = &camera_gltf.data_ref().unwrap().scenes[0];
    drop(resman);

    world.spawn((
        camera_mesh.clone(),
        WorldTransform::default(),
        Transform::from_xyz(0.0, -5.0, -2.0),
    ));

    {
        let mut light_tran = Transform::from_xyz(1.5, 2.5, 0.0);
        light_tran.scale = Vec3::new(0.5, 0.5, 0.5);
        light_tran.rotate_x(math::Angle::Degrees(-45.0));
        light_tran.rotate_y(math::Angle::Degrees(25.0));
        world.spawn((
            DirectionalLight {
                enabled: true,
                color: Vec3::ONE,
                intensity: 0.15, //..Default::default()
            },
            light_tran,
        ));
    }

    let mut camera = CameraComponent::new_3d();
    camera.transform.translation += math::Vec3::new(0.0, 0.0, 5.5);
    world.spawn((camera, FreeFlyCamera::default()));
}

fn setup_script_plugin(game: &mut Game) {
    game.with_plugin(LuaScriptingPlugin);

    let world = game.world_mut();
    let res_man = world.get_resource_mut::<ResourceManager>();
    let script = res_man.request::<LuaScript>("scripts/test.lua").unwrap();
    res_man.watch("scripts/test.lua", false).unwrap();
    drop(res_man);

    let script = Script::new("test.lua", script);
    let scripts = ScriptList::new(vec![script]);
    world.spawn((scripts,));
}