Merge branch 'topic/#80-player-animation' into develop

conan/conanfile.py

@@ -23,7 +23,7 @@ class SnacmanConan(ConanFile):
 
     requires = (
         ("entity/29ce7b6ff0@adnn/develop"),
-        ("graphics/a50be37658@adnn/develop"),
+        ("graphics/3a9a713cde@adnn/develop"),
         ("handy/5fb4067c56@adnn/develop"),
         ("math/a165ef4960@adnn/develop"),
         ("MarkovJunior.cpp/1c8bd4662f@adnn/develop"),

conan/workspaces/complete.yml

@@ -3,7 +3,7 @@ editables:
         path: ../../../MarkovJunior.cpp/conan
     entity/29ce7b6ff0@adnn/develop:
         path: ../../../entity/conan
-    graphics/a50be37658@adnn/develop:
+    graphics/3a9a713cde@adnn/develop:
         path: ../../../graphics/conan
     handy/5fb4067c56@adnn/develop:
         path: ../../../handy/conan

conan/workspaces/linux_complete.yml

@@ -3,7 +3,7 @@ editables:
         path: ../../../MarkovJunior.cpp/conan
     entity/29ce7b6ff0@adnn/develop:
         path: ../../../entity/conan
-    graphics/a50be37658@adnn/develop:
+    graphics/3a9a713cde@adnn/develop:
         path: ../../../graphics/conan
     handy/5fb4067c56@adnn/develop:
         path: ../../../handy/conan

src/apps/skinning_sandbox/skinning_sandbox/main.cpp

@@ -69,7 +69,7 @@ void runApplication()
     Scene scene{
         glfwApp,
         //finder.pathFor("models/anim/SimpleSkin/glTF/SimpleSkin.gltf"),
-        finder.pathFor("models/anim/anim.gltf"),
+        finder.pathFor("models/donut/donut.gltf"),
         DebugRenderer{pass(TechniqueLoader{finder}),
                       freetype.load(finder.pathFor("fonts/FiraMono-Regular.ttf"))},
         finder,

src/apps/snacman/snacman/CMakeLists.txt

@@ -39,6 +39,7 @@ set(${TARGET_NAME}_HEADERS
     simulations/snacgame/component/Collision.h
     simulations/snacgame/component/Context.h
     simulations/snacgame/component/Controller.h
+    simulations/snacgame/component/Explosion.h
     simulations/snacgame/component/Geometry.h
     simulations/snacgame/component/GlobalPose.h
     simulations/snacgame/component/LevelData.h
@@ -67,9 +68,11 @@ set(${TARGET_NAME}_HEADERS
 
     simulations/snacgame/system/AdvanceAnimations.h
     simulations/snacgame/system/AllowMovement.h
+    simulations/snacgame/system/AnimationManager.h
     simulations/snacgame/system/ConsolidateGridMovement.h
     simulations/snacgame/system/Debug_BoundingBoxes.h
     simulations/snacgame/system/EatPill.h
+    simulations/snacgame/system/Explosion.h
     simulations/snacgame/system/IntegratePlayerMovement.h
     simulations/snacgame/system/MovementIntegration.h
     simulations/snacgame/system/LevelCreator.h
@@ -112,9 +115,11 @@ set(${TARGET_NAME}_SOURCES
 
     simulations/snacgame/system/AdvanceAnimations.cpp
     simulations/snacgame/system/AllowMovement.cpp
+    simulations/snacgame/system/AnimationManager.cpp
     simulations/snacgame/system/ConsolidateGridMovement.cpp
     simulations/snacgame/system/Debug_BoundingBoxes.cpp
     simulations/snacgame/system/EatPill.cpp
+    simulations/snacgame/system/Explosion.cpp
     simulations/snacgame/system/IntegratePlayerMovement.cpp
     simulations/snacgame/system/MovementIntegration.cpp
     simulations/snacgame/system/LevelCreator.cpp

src/apps/snacman/snacman/simulations/snacgame/Entities.cpp

@@ -3,6 +3,7 @@
 #include "component/AllowedMovement.h"
 #include "component/Collision.h"
 #include "component/Controller.h"
+#include "component/Explosion.h"
 #include "component/Geometry.h"
 #include "component/LevelTags.h"
 #include "component/MenuItem.h"
@@ -20,6 +21,7 @@
 #include "component/VisualModel.h"
 #include "GameContext.h"
 #include "scene/MenuScene.h"
+#include "snacman/simulations/snacgame/component/Explosion.h"
 #include "snacman/simulations/snacgame/component/PlayerHud.h"
 #include "snacman/simulations/snacgame/component/PlayerModel.h"
 #include "snacman/simulations/snacgame/component/PlayerPortalData.h"
@@ -196,7 +198,7 @@ createPowerUp(GameContext & aContext,
     Entity powerUp = *handle.get(aPhase);
     component::PowerUpType baseType = component::PowerUpType::Dog;
     component::PowerUpBaseInfo info =
-        component::gPowerupPathByType.at(static_cast<unsigned int>(baseType));
+        component::gPowerupInfoByType.at(static_cast<unsigned int>(baseType));
     addMeshGeoNode(aContext, powerUp, info.mPath,
                    "effects/MeshTextures.sefx",
                    {static_cast<float>(aGridPos.x()),
@@ -222,7 +224,7 @@ EntHandle createPlayerPowerUp(GameContext & aContext,
     auto handle = aContext.mWorld.addEntity();
     Entity powerUp = *handle.get(init);
     component::PowerUpBaseInfo info =
-        component::gPowerupPathByType.at(static_cast<unsigned int>(aType));
+        component::gPowerupInfoByType.at(static_cast<unsigned int>(aType));
     addMeshGeoNode(aContext, powerUp, info.mPath,
                    "effects/MeshTextures.sefx", {1.f, 1.f, 0.f},
                    info.mPlayerScaling, info.mPlayerInstanceScale,
@@ -435,15 +437,27 @@ ent::Handle<ent::Entity> fillSlotWithPlayer(GameContext & aContext,
         Entity model = *playerModel.get(sceneInit);
 
         addGeoNode(aContext, player, {0.f, 0.f, gPlayerHeight});
-        addMeshGeoNode(aContext, model,
-                       "models/donut/donut.gltf", "effects/MeshTextures.sefx",
-                       {0.f, 0.f, 0.f}, 1.f,
-                       {0.2f, 0.2f, 0.2f},
-                       Quat_f{math::UnitVec<3, float>{{0.f, 0.f, 1.f}},
-                              math::Turn<float>{0.25f}}
-                           * Quat_f{math::UnitVec<3, float>{{1.f, 0.f, 0.f}},
-                                    math::Turn<float>{0.25f}},
-                       playerSlot.mColor);
+        std::shared_ptr<snac::Model> modelData = addMeshGeoNode(
+            aContext, model, "models/donut/donut.gltf",
+            "effects/MeshRiggingTextures.sefx", {0.f, 0.f, 0.f}, 1.f,
+            {0.2f, 0.2f, 0.2f},
+            Quat_f{math::UnitVec<3, float>{{0.f, 0.f, 1.f}},
+                   math::Turn<float>{0.25f}}
+                * Quat_f{math::UnitVec<3, float>{{1.f, 0.f, 0.f}},
+                         math::Turn<float>{0.25f}},
+            playerSlot.mColor);
+        std::string animName = "idle";
+        const snac::NodeAnimation & animation =
+            modelData->mAnimations.at(animName);
+        model.add(component::RigAnimation{
+            .mAnimName = animName,
+            .mAnimation = &animation,
+            .mAnimationMap = &modelData->mAnimations,
+            .mStartTime = snac::Clock::now(),
+            .mParameter =
+                decltype(component::RigAnimation::mParameter){
+                    animation.mEndTime},
+        });
     }
 
     insertEntityInScene(playerModel, aSlot);
@@ -646,8 +660,8 @@ EntHandle createTargetArrow(GameContext & aContext, const HdrColor_f & aColor)
         Phase createTargetArrow;
         Entity stageEntity = *result.get(createTargetArrow);
 
-        addMeshGeoNode(aContext, stageEntity,
-                       "models/arrow/arrow.gltf", "effects/MeshTextures.sefx", {0.f, 0.f, 2.f}, 0.4f,
+        addMeshGeoNode(aContext, stageEntity, "models/arrow/arrow.gltf",
+                       "effects/MeshTextures.sefx", {0.f, 0.f, 2.f}, 0.4f,
                        {1.f, 1.f, 1.f},
                        Quat_f{math::UnitVec<3, float>{{1.f, 0.f, 0.f}},
                               math::Turn<float>{0.25f}},
@@ -661,5 +675,24 @@ EntHandle createTargetArrow(GameContext & aContext, const HdrColor_f & aColor)
     return result;
 }
 
+EntHandle createExplosion(GameContext & aContext,
+                          math::Position<3, float> & aPos, const snac::Time & aTime)
+{
+    EntHandle explosion = aContext.mWorld.addEntity();
+    {
+        Phase createExplosion;
+        Entity explosionEnt = *explosion.get(createExplosion);
+        addMeshGeoNode(aContext, explosionEnt, "models/boom/boom.gltf",
+                       "effects/MeshTextures.sefx", aPos, 0.1f);
+        explosionEnt
+            .add(component::Explosion{
+                .mStartTime = aTime.mTimepoint,
+                .mParameter = math::ParameterAnimation<
+                    float, math::AnimationResult::Clamp>(0.5f)})
+            .add(component::LevelEntity{});
+    }
+    return explosion;
+}
+
 } // namespace snacgame
 } // namespace ad

src/apps/snacman/snacman/simulations/snacgame/Entities.h

@@ -146,5 +146,7 @@ ent::Handle<ent::Entity> removePlayerFromGame(ent::Phase & aPhase,
 ent::Handle<ent::Entity> createTargetArrow(GameContext & aContext,
                                            const math::hdr::Rgba_f & aColor);
 
+ent::Handle<ent::Entity> createExplosion(GameContext & aContext, math::Position<3, float> & aPosition, const snac::Time & aTime);
+
 } // namespace snacgame
 } // namespace ad

src/apps/snacman/snacman/simulations/snacgame/InputCommandConverter.h

@@ -1,20 +1,21 @@
 #pragma once
 
 #include "InputConstants.h"
-#include "component/Controller.h"
-#include "snacman/Logging.h"
+#include "LevelHelper.h"
+
+#include <snacman/Input.h>
+#include <snacman/Logging.h>
 
 #include <platform/Filesystem.h>
 
 #define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>
 #undef GLFW_INCLUDE_NONE
 
-#include <nlohmann/json.hpp>
-
 #include <concepts>
 #include <fstream>
 #include <initializer_list>
+#include <nlohmann/json.hpp>
 #include <unordered_map>
 
 using json = nlohmann::json;
@@ -98,8 +99,6 @@ const inline BidirectionalMap<std::string, int> gCommandFlags{
     {"gRightJoyDown", gRightJoyDown},
     {"gRightJoyLeft", gRightJoyLeft},
     {"gRightJoyRight", gRightJoyRight},
-    {"gNextPowerUpTarget", gNextPowerUpTarget},
-    {"gPrevPowerUpTarget", gPrevPowerUpTarget},
 
     {"gJoin", gJoin | gPositiveEdge},
 
@@ -220,7 +219,10 @@ class KeyMapping
                 }
                 else
                 {
-                    SELOG(error)("Missing command name \"{}\" present in \"{}\" in command flags", commandName, aPath.string());
+                    SELOG(error)
+                    ("Missing command name \"{}\" present in \"{}\" in command "
+                     "flags",
+                     commandName, aPath.string());
                 }
             }
         }
@@ -256,17 +258,28 @@ using GamepadMapping = KeyMapping<GamepadAtomicInput>;
 
 using KeyboardMapping = KeyMapping<int>;
 
-struct ControllerCommand {
-    int mCommand;
+struct GameInput
+{
+    // input flags
+    int mCommand = 0;
+    // Left joystick and zqsd
+    math::Vec<2, float> mLeftDirection = math::Vec<2, float>::Zero();
+    // Right joystick and up, down, left, right
+    math::Vec<2, float> mRightDirection = math::Vec<2, float>::Zero();
+};
+
+struct ControllerCommand
+{
     int mId;
     ControllerType mControllerType;
+    GameInput mInput;
 };
 
-inline int convertKeyboardInput(const std::string & aGroup,
-                                const KeyboardState & aKeyboardState,
-                                const KeyboardMapping & aKeyboardMapping)
+inline GameInput convertKeyboardInput(const std::string & aGroup,
+                                      const KeyboardState & aKeyboardState,
+                                      const KeyboardMapping & aKeyboardMapping)
 {
-    int commandFlags = 0;
+    GameInput keyboardInput{};
 
     for (const auto & [input, command] : aKeyboardMapping.mKeymaps.at(aGroup))
     {
@@ -275,21 +288,33 @@ inline int convertKeyboardInput(const std::string & aGroup,
         ButtonStatus stateWanted = command & gPositiveEdge
                                        ? ButtonStatus::PositiveEdge
                                        : ButtonStatus::Pressed;
-        commandFlags |= (static_cast<InputState::Enum_t>(
-                             std::get<ButtonStatus>(state.mState))
-                         >= static_cast<InputState::Enum_t>(stateWanted))
-                            ? (command & ~gPositiveEdge)
-                            : 0;
+        keyboardInput.mCommand |=
+            (static_cast<InputState::Enum_t>(
+                 std::get<ButtonStatus>(state.mState))
+             >= static_cast<InputState::Enum_t>(stateWanted))
+                ? (command & ~gPositiveEdge)
+                : 0;
     }
 
-    return commandFlags;
+    keyboardInput.mLeftDirection = 
+        gDirections_f.at(Direction::Up) * (keyboardInput.mCommand & gPlayerMoveFlagUp) / gPlayerMoveFlagUp
+        + gDirections_f.at(Direction::Down) * (keyboardInput.mCommand & gPlayerMoveFlagDown) / gPlayerMoveFlagDown
+        + gDirections_f.at(Direction::Left) * (keyboardInput.mCommand & gPlayerMoveFlagLeft) / gPlayerMoveFlagLeft
+        + gDirections_f.at(Direction::Right) * (keyboardInput.mCommand & gPlayerMoveFlagRight) / gPlayerMoveFlagRight;
+    keyboardInput.mRightDirection = 
+        gDirections_f.at(Direction::Up) * (keyboardInput.mCommand & gRightJoyUp) / gRightJoyUp
+        + gDirections_f.at(Direction::Down) * (keyboardInput.mCommand & gRightJoyDown) / gRightJoyDown
+        + gDirections_f.at(Direction::Left) * (keyboardInput.mCommand & gRightJoyLeft) / gRightJoyLeft
+        + gDirections_f.at(Direction::Right) * (keyboardInput.mCommand & gRightJoyRight) / gRightJoyRight;
+
+    return keyboardInput;
 }
 
-inline int convertGamepadInput(const std::string & aGroup,
-                               const GamepadState & aGamepadState,
-                               const GamepadMapping & aGamepadMapping)
+inline GameInput convertGamepadInput(const std::string & aGroup,
+                                     const GamepadState & aGamepadState,
+                                     const GamepadMapping & aGamepadMapping)
 {
-    int commandFlags = 0;
+    GameInput gamepadInput{};
 
     for (const auto & [input, command] : aGamepadMapping.mKeymaps.at(aGroup))
     {
@@ -300,36 +325,54 @@ inline int convertGamepadInput(const std::string & aGroup,
             ButtonStatus stateWanted = command & gPositiveEdge
                                            ? ButtonStatus::PositiveEdge
                                            : ButtonStatus::Pressed;
-            commandFlags |= (static_cast<InputState::Enum_t>(
-                                 std::get<ButtonStatus>(state.mState))
-                             >= static_cast<InputState::Enum_t>(stateWanted))
-                                ? (command & ~gPositiveEdge)
-                                : 0;
+            gamepadInput.mCommand |=
+                (static_cast<InputState::Enum_t>(
+                     std::get<ButtonStatus>(state.mState))
+                 >= static_cast<InputState::Enum_t>(stateWanted))
+                    ? (command & ~gPositiveEdge)
+                    : 0;
         }
         else
         {
             int index = static_cast<int>(input)
-                & ~static_cast<int>(GamepadAtomicInput::axisFlag)
-                & ~static_cast<int>(GamepadAtomicInput::positiveFlag);
+                        & ~static_cast<int>(GamepadAtomicInput::axisFlag)
+                        & ~static_cast<int>(GamepadAtomicInput::positiveFlag);
             const AxisStatus & state = aGamepadState.mAxis.at(index);
 
             if (static_cast<int>(input)
                 & static_cast<int>(GamepadAtomicInput::positiveFlag))
             {
-                commandFlags |= (static_cast<float>(state) > gJoystickDeadzone)
-                                    ? (command & ~gPositiveEdge)
-                                    : 0;
+                gamepadInput.mCommand |=
+                    (static_cast<float>(state) > gJoystickDeadzone)
+                        ? (command & ~gPositiveEdge)
+                        : 0;
             }
             else
             {
-                commandFlags |= (static_cast<float>(state) < -gJoystickDeadzone)
-                                    ? (command & ~gPositiveEdge)
-                                    : 0;
+                gamepadInput.mCommand |=
+                    (static_cast<float>(state) < -gJoystickDeadzone)
+                        ? (command & ~gPositiveEdge)
+                        : 0;
             }
         }
     }
 
-    return commandFlags;
+    gamepadInput.mLeftDirection = {
+        -std::get<AxisStatus>(
+            aGamepadState.mAxis.at(GLFW_GAMEPAD_AXIS_LEFT_X).mState)
+            .mCurrent,
+        -std::get<AxisStatus>(
+            aGamepadState.mAxis.at(GLFW_GAMEPAD_AXIS_LEFT_Y).mState)
+            .mCurrent};
+    gamepadInput.mRightDirection = {
+        -std::get<AxisStatus>(
+            aGamepadState.mAxis.at(GLFW_GAMEPAD_AXIS_RIGHT_X).mState)
+            .mCurrent,
+        -std::get<AxisStatus>(
+            aGamepadState.mAxis.at(GLFW_GAMEPAD_AXIS_RIGHT_Y).mState)
+            .mCurrent};
+
+    return gamepadInput;
 }
 
 } // namespace snacgame

src/apps/snacman/snacman/simulations/snacgame/LevelHelper.h

@@ -29,10 +29,21 @@ inline Position<2, int> getLevelPosition_i(const Position<2, float> & aPos)
                             static_cast<int>(aPos.y() + gCellSize / 2)};
 }
 
+enum Direction {
+    Up,
+    Down,
+    Left,
+    Right
+};
+
 constexpr std::array<Vec<2, int>, 4> gDirections{
     Vec<2, int>{0, 1}, Vec<2, int>{0, -1},
     Vec<2, int>{1, 0}, Vec<2, int>{-1, 0}};
 
+constexpr std::array<Vec<2, float>, 4> gDirections_f{
+    Vec<2, float>{0.f, 1.f}, Vec<2, float>{0.f, -1.f},
+    Vec<2, float>{1.f, 0.f}, Vec<2, float>{-1.f, 0.f}};
+
 constexpr std::array<const int, 4> gAllowedMovement{
     gAllowedMovementUp, gAllowedMovementDown,
     gAllowedMovementRight, gAllowedMovementLeft};