Cargo.lock

@@ -3075,6 +3075,16 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "shadows"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-std",
+ "lyra-engine",
+ "tracing",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"

Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 
 [workspace]
 members = [
-    "examples/testbed",
     "lyra-resource",
     "lyra-ecs",
     "lyra-reflect",
@@ -14,10 +13,12 @@ members = [
     "lyra-math",
     "lyra-scene",
 
+    "examples/testbed",
     "examples/many-lights",
     "examples/fixed-timestep-rotating-model",
     "examples/lua-scripting",
-    "examples/simple_scene"
+    "examples/simple_scene",
+    "examples/shadows",
 ]
 
 [features]

examples/shadows/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "shadows"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+lyra-engine = { path = "../../", features = ["tracy"] }
+anyhow = "1.0.75"
+async-std = "1.12.0"
+tracing = "0.1.37"

examples/shadows/scripts/test.lua

@@ -0,0 +1,59 @@
+---Return the userdata's name from its metatable
+---@param val userdata
+---@return string
+function udname(val)
+    return getmetatable(val).__name
+end
+
+function on_init()
+    local cube = world:request_res("../assets/cube-texture-embedded.gltf")
+    print("Loaded textured cube (" .. udname(cube) .. ")")
+
+    cube:wait_until_loaded()
+    local scenes = cube:scenes()
+    local cube_scene = scenes[1]
+
+    local pos = Transform.from_translation(Vec3.new(0, 0, -8.0))
+
+    local e = world:spawn(pos, cube_scene)
+    print("spawned entity " .. tostring(e))
+end
+
+--[[ function on_first()
+    print("Lua's first function was called")
+end
+
+function on_pre_update()
+    print("Lua's pre-update function was called")
+end ]]
+
+function on_update()
+    --[[ ---@type number
+    local dt = world:resource(DeltaTime)
+    local act = world:resource(ActionHandler)
+    ---@type number
+    local move_objs = act:get_axis("ObjectsMoveUpDown")
+
+    world:view(function (t)
+        if move_objs ~= nil then
+            t:translate(0, move_objs * 0.35 * dt, 0)
+            return t
+        end
+    end, Transform) ]]
+
+    ---@type number
+    local dt = world:resource(DeltaTime)
+
+    world:view(function (t)
+        t:translate(0, 0.15 * dt, 0)
+        return t
+    end, Transform)
+end
+
+--[[ function on_post_update()
+    print("Lua's post-update function was called")
+end
+
+function on_last()
+    print("Lua's last function was called")
+end ]]

examples/shadows/src/main.rs

@@ -0,0 +1,165 @@
+use lyra_engine::{
+    assets::{gltf::Gltf, ResourceManager},
+    game::Game,
+    input::{
+        Action, ActionHandler, ActionKind, ActionMapping, ActionMappingId, ActionSource,
+        InputActionPlugin, KeyCode, LayoutId, MouseAxis, MouseInput,
+    },
+    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,
+    },
+};
+
+#[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(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 cube_gltf = resman
+        .request::<Gltf>("../assets/cube-texture-embedded.gltf")
+        .unwrap();
+
+    cube_gltf.wait_recurse_dependencies_load();
+    let cube_mesh = &cube_gltf.data_ref().unwrap().scenes[0];
+
+    let platform_gltf = resman
+        .request::<Gltf>("../assets/wood-platform.glb")
+        .unwrap();
+
+    platform_gltf.wait_recurse_dependencies_load();
+    let platform_mesh = &platform_gltf.data_ref().unwrap().scenes[0];
+
+    drop(resman);
+
+    world.spawn((
+        cube_mesh.clone(),
+        WorldTransform::default(),
+        Transform::from_xyz(0.0, -2.0, -5.0),
+    ));
+
+    world.spawn((
+        platform_mesh.clone(),
+        WorldTransform::default(),
+        Transform::from_xyz(0.0, -5.0, -5.0),
+    ));
+
+    {
+        let mut light_tran = Transform::from_xyz(-5.5, 2.5, -3.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(-35.0));
+        world.spawn((
+            cube_mesh.clone(),
+            DirectionalLight {
+                enabled: true,
+                color: Vec3::new(1.0, 0.95, 0.9),
+                intensity: 1.0,
+            },
+            light_tran,
+        ));
+    }
+
+    let mut camera = CameraComponent::new_3d();
+    camera.transform.translation += math::Vec3::new(0.0, 2.0, 10.5);
+    camera.transform.rotate_x(math::Angle::Degrees(-17.0));
+    world.spawn((camera, FreeFlyCamera::default()));
+}