More changes to the InputAction builder API.

* Fixed handling of multiple keys bound to a single input source.
* Fixed button events fighting over source status. (Pressed takes priority over others)
* Fixed action runtimes to create way to many source storage objects.

Author: Dandielo

source/code/core/core/public/ice/concept/pimpl_type.hxx

@@ -26,9 +26,9 @@ namespace ice::concepts
 
         // TODO: Move this somewhere else!
         PimplType(PimplType&& other) noexcept = delete;
-        auto operator=(PimplType&& other) noexcept -> PimplType & = delete;
+        auto operator=(PimplType&& other) noexcept -> PimplType& = delete;
         PimplType(PimplType const& other) noexcept = delete;
-        auto operator=(PimplType const& other) noexcept -> PimplType & = delete;
+        auto operator=(PimplType const& other) noexcept -> PimplType& = delete;
 
     protected:
         template<typename Self>
@@ -51,4 +51,4 @@ namespace ice::concepts
         return *reinterpret_cast<Internal<Self>*>(self._internal);
     }
 
-}
+} // namespace ice::concepts

source/code/core/memsys/private/mem_allocator.cxx

@@ -194,6 +194,7 @@ namespace ice
 
     AllocatorBase<true>::~AllocatorBase() noexcept
     {
+        // TODO: Introduce low-level logger just for debug and dev builds.
         ICE_ASSERT_CORE(allocation_count() == 0);
     }
 

source/code/systems/input_action_system/private/input_action_dsl_layer_builder.cxx

@@ -61,7 +61,8 @@ namespace ice
         }
 
         ice::InputActionBuilder::Source source = _builder->define_source(node.data().name, type);
-        if (arctic::SyntaxNode const binding = node.child<ice::syntax::LayerInputBinding>(); binding)
+        arctic::SyntaxNode binding = node.child<ice::syntax::LayerInputBinding>();
+        while (binding)
         {
             using ice::input::DeviceType;
             using ice::input::KeyboardKey;
@@ -103,6 +104,9 @@ namespace ice
                     source.add_button(mouseinput);
                 }
             }
+
+            // TODO: We need to fix building layers with sources having multiple inputs, before enabling this.
+            binding = binding.sibling<ice::syntax::LayerInputBinding>();
         }
 
         ICE_LOG(LogSeverity::Info, LogTag::Engine, "Source: {}", node.data().name);
@@ -135,17 +139,8 @@ namespace ice
         {
             if (child.type() == ice::syntax::SyntaxEntity_LayerActionCondition)
             {
-                visit_cond(action, child.to<ice::syntax::LayerActionWhen>());
-
-                arctic::SyntaxNode<> steps = child.child();
-                while (steps != false)
-                {
-                    if (steps.type() == ice::syntax::SyntaxEntity_LayerActionStep)
-                    {
-                        visit_step(action, steps.to<ice::syntax::LayerActionStep>());
-                    }
-                    steps = steps.sibling();
-                }
+                // Returns the final node of the series. The next sibling is either a: modifier, condition_series or action
+                child = visit_cond(action.add_condition_series(), child.to<ice::syntax::LayerActionWhen>());
             }
             else if (child.type() == ice::syntax::SyntaxEntity_LayerActionModifier)
             {
@@ -155,72 +150,98 @@ namespace ice
         }
     }
 
-    void InputActionDSLLayerBuilder::visit_cond(
-        ice::InputActionBuilder::Action& action,
+    auto InputActionDSLLayerBuilder::visit_cond(
+        ice::InputActionBuilder::ConditionSeries series,
         arctic::SyntaxNode<ice::syntax::LayerActionWhen> node
-    ) noexcept
+    ) noexcept -> arctic::SyntaxNode<>
     {
         using enum ice::InputActionCondition;
 
-        ice::syntax::LayerActionWhen const& cond = node.to<ice::syntax::LayerActionWhen>().data();
-        ICE_LOG(LogSeverity::Debug, LogTag::Tool, "- {} {}.{} {} {}", cond.type.value, cond.source_type.value, cond.source_name, cond.condition.value, cond.param.value);
-
-        bool const from_action = cond.source_type.type == grammar::UCT_Action
-            || (cond.source_type.type == arctic::TokenType::Invalid && cond.source_name.empty()); // "self"
-        ice::InputActionCondition const condition = detail::condition_from_dsl(cond.condition, from_action);
-        ice::InputActionConditionFlags flags = InputActionConditionFlags::None;
+        arctic::SyntaxNode<ice::syntax::LayerActionWhen> cond_node = node;
+        ICE_ASSERT_CORE(cond_node.data().type.type == grammar::UCT_When);
 
-        // No siblings or next sibling: "when" == "final" condition.
-        if (auto sib = node.sibling<ice::syntax::LayerActionWhen>(); !sib || sib.data().type.type == grammar::UCT_When)
-        {
-            flags |= InputActionConditionFlags::Final;
-        }
-        if (node.child<syntax::LayerActionStep>()) // Only steps can introduce children.
-        {
-            flags |= InputActionConditionFlags::RunSteps;
-        }
-        if (cond.flag_series)
-        {
-            flags |= InputActionConditionFlags::SeriesCheck;
-        }
-        if (cond.type.type == grammar::UCT_WhenAnd) // Only steps can introduce children.
-        {
-            flags |= InputActionConditionFlags::SeriesAnd;
-        }
-        else // if (cond.type.type == grammar::UCT_WhenOr) // Only steps can introduce children.
+        ICE_LOG(LogSeverity::Debug, LogTag::Tool, "New condition series");
+        do
         {
-            flags |= InputActionConditionFlags::SeriesOr;
-        }
+            node = cond_node; // Set the node to the current cond_node, necessary to return a valid node
+            ice::syntax::LayerActionWhen const& cond = cond_node.data();
+            ICE_LOG(LogSeverity::Debug, LogTag::Tool, "- {} {}.{} {} {}", cond.type.value, cond.source_type.value, cond.source_name, cond.condition.value, cond.param.value);
+
+            bool const from_action = cond.source_type.type == grammar::UCT_Action
+                || (cond.source_type.type == arctic::TokenType::Invalid && cond.source_name.empty()); // "self"
+            ice::InputActionCondition const condition = detail::condition_from_dsl(cond.condition, from_action);
+
+            ice::InputActionConditionFlags flags = InputActionConditionFlags::None;
+            if (cond_node.child<syntax::LayerActionStep>())
+            {
+                flags |= InputActionConditionFlags::RunSteps;
+            }
+            if (cond.flag_series)
+            {
+                flags |= InputActionConditionFlags::SeriesCheck;
+            }
 
-        // TODO: SeriesCheck
-        // TODO: non-Final
+            if (cond.type.type == grammar::UCT_WhenAnd)
+            {
+                flags |= InputActionConditionFlags::SeriesAnd;
+            }
+            // If we are When or WhenOr, we default to 'SeriesOr'
+            else
+            {
+                flags |= InputActionConditionFlags::SeriesOr;
+            }
 
-        ice::f32 param = 0.0f;
-        bool const is_param_condition = condition == Equal || condition == NotEqual
-            || condition == Greater || condition == GreaterOrEqual
-            || condition == Lower || condition == LowerOrEqual;
-        if (is_param_condition)
+            ice::f32 param = 0.0f;
+            bool const is_param_condition = condition == Equal || condition == NotEqual
+                || condition == Greater || condition == GreaterOrEqual
+                || condition == Lower || condition == LowerOrEqual;
+            if (is_param_condition)
+            {
+                ice::from_chars(cond.param.value, param);
+            }
+
+            // Adds the new condition
+            series.add_condition(
+                cond.source_name, condition, flags, param, from_action
+            );
+
+            // Move over all steps defined for this condition
+            arctic::SyntaxNode<> steps = cond_node.child();
+            while (steps != false)
+            {
+                if (steps.type() == ice::syntax::SyntaxEntity_LayerActionStep)
+                {
+                    visit_step(series, steps.to<ice::syntax::LayerActionStep>());
+                }
+                steps = steps.sibling();
+            }
+
+            cond_node = cond_node.sibling<ice::syntax::LayerActionWhen>();
+        } while (cond_node && cond_node.data().type.type != grammar::UCT_When);
+
+        // TODO: Check for '.continue' flag to skip setting 'Final' flag here
+        //if (/* DOES NOT HAVE '.continue' flag */)
         {
-            ice::from_chars(cond.param.value, param);
+            series.set_finished();
         }
 
-        action.add_condition(cond.source_name, condition, flags, param, from_action);
+        return node;
     }
 
     void InputActionDSLLayerBuilder::visit_step(
-        ice::InputActionBuilder::Action& action,
+        ice::InputActionBuilder::ConditionSeries& condition_series,
         arctic::SyntaxNode<ice::syntax::LayerActionStep> node
     ) noexcept
     {
         ice::syntax::LayerActionStep const& info = node.data();
         ice::InputActionStep const step = detail::step_from_dsl(info.step);
         if (step == InputActionStep::Set || step == InputActionStep::Add || step == InputActionStep::Sub)
         {
-            action.add_step(info.source, step, info.destination);
+            condition_series.add_step(info.source, step, info.destination);
         }
         else
         {
-            action.add_step(step);
+            condition_series.add_step(step);
         }
     }
 
@@ -275,19 +296,19 @@ namespace ice
         {
             result = KeyboardKey::Space;
         }
-        else if (value == "up")
+        else if (ice::compare(value, "up") == CompareResult::Equal)
         {
             result = KeyboardKey::Up;
         }
-        else if (value == "down")
+        else if (ice::compare(value, "down") == CompareResult::Equal)
         {
             result = KeyboardKey::Down;
         }
-        else if (value == "left")
+        else if (ice::compare(value, "left") == CompareResult::Equal)
         {
             result = KeyboardKey::Left;
         }
-        else if (value == "right")
+        else if (ice::compare(value, "right") == CompareResult::Equal)
         {
             result = KeyboardKey::Right;
         }
@@ -328,57 +349,6 @@ namespace ice
         return result;
     }
 
-#if 0
-    auto detail::mod_from_dsl(arctic::String value) noexcept -> ice::input::KeyboardMod
-    {
-        using ice::input::KeyboardMod;
-
-        if (strnicmp(value.data(), "mode", 4) == 0)
-        {
-            return KeyboardMod::Mode;
-        }
-        else if (strnicmp(value.data(), "numlock", 4) == 0)
-        {
-            return KeyboardMod::NumLock;
-        }
-        else if (strnicmp(value.data(), "capslock", 4) == 0)
-        {
-            return KeyboardMod::CapsLock;
-        }
-
-        // If left == 2, if right == 1, else 0
-        KeyboardMod result = KeyboardMod::None;
-        ICE_ASSERT_CORE(value.size() >= 3);
-
-        ice::u8 const mod_side = (value[0] == 'l' ? 2 : (value[0] == 'r' ? 1 : 0));
-        value = value.substr(ice::u32(mod_side != 0)); // We remove the prefix ('l' or 'r') from the remaining value.
-
-        switch (value[0])
-        {
-        case 's':
-        case 'S':
-            result = static_cast<KeyboardMod>(3 ^ mod_side);
-            break;
-        case 'c':
-        case 'C':
-            result = static_cast<KeyboardMod>((3 ^ mod_side) << 2);
-            break;
-        case 'a':
-        case 'A':
-            result = static_cast<KeyboardMod>((3 ^ mod_side) << 4);
-            break;
-        case 'g':
-        case 'G':
-            result = static_cast<KeyboardMod>((3 ^ mod_side) << 8);
-            break;
-        default:
-            break;
-        }
-
-        return result;
-    }
-#endif
-
     auto detail::mouse_from_dsl(arctic::String value) noexcept -> ice::input::MouseInput
     {
         using ice::input::MouseInput;

source/code/systems/input_action_system/private/input_action_dsl_layer_builder.hxx

@@ -17,13 +17,13 @@ namespace ice
         void visit_source(arctic::SyntaxNode<ice::syntax::LayerSource> node) noexcept;
         void visit_layer(arctic::SyntaxNode<ice::syntax::LayerAction> node) noexcept;
 
-        void visit_cond(
-            ice::InputActionBuilder::Action& action,
+        auto visit_cond(
+            ice::InputActionBuilder::ConditionSeries series,
             arctic::SyntaxNode<ice::syntax::LayerActionWhen> node
-        ) noexcept;
+        ) noexcept -> arctic::SyntaxNode<>;
 
         void visit_step(
-            ice::InputActionBuilder::Action& action,
+            ice::InputActionBuilder::ConditionSeries& condition_series,
             arctic::SyntaxNode<ice::syntax::LayerActionStep> node
         ) noexcept;
 

source/code/systems/input_action_system/private/input_action_layer.cxx

@@ -128,6 +128,18 @@ namespace ice
             ice::ucount count_processed = 0;
             ice::ucount const count_events = ice::count(input_events);
 
+            // Reset the temporary events.
+            for (ice::InputActionSourceInputInfo const& src : _sources)
+            {
+                ice::InputActionSource* const values = source_values[src.storage_offset];
+                ice::u32 const count_values = 1 + ice::u32(src.type == InputActionSourceType::Axis2d);
+
+                for (ice::u32 idx = 0; idx < count_values; ++idx)
+                {
+                    values[idx].temp_event = InputActionSourceEvent::None;
+                }
+            }
+
             for (ice::InputActionSourceInputInfo const& src : _sources)
             {
                 ice::InputActionSource* const values = source_values[src.storage_offset];
@@ -160,36 +172,48 @@ namespace ice
 
                 if (ev.value_type == ice::input::InputValueType::Trigger)
                 {
-                    value = { InputActionSourceEvent::Trigger, ev.value.axis.value_f32 };
+                    value = { ev.value.axis.value_f32, InputActionSourceEvent::Trigger };
                 }
                 else if (ev.value_type == ice::input::InputValueType::AxisInt)
                 {
-                    value = { InputActionSourceEvent::Axis, ice::f32(ev.value.axis.value_i32) };
+                    value = { ice::f32(ev.value.axis.value_i32), InputActionSourceEvent::Axis };
                 }
                 else if (ev.value_type == ice::input::InputValueType::AxisFloat)
                 {
                     // Check for deadzone values
                     if (src.param < ev.value.axis.value_f32)
                     {
-                        value = { InputActionSourceEvent::Axis, ev.value.axis.value_f32 };
+                        value = { ev.value.axis.value_f32, InputActionSourceEvent::Axis };
                     }
                     else
                     {
-                        value = { InputActionSourceEvent::AxisDeadzone, ev.value.axis.value_f32 };
+                        value = { ev.value.axis.value_f32, InputActionSourceEvent::AxisDeadzone };
                     }
                 }
-                else
+                else if (value.temp_event != InputActionSourceEvent::KeyPress)
                 {
                     value = {
+                        ev.value.button.state.released
+                            ? 0.0f : 1.0f,
                         ev.value.button.state.released
                             ? InputActionSourceEvent::KeyRelease
                             : InputActionSourceEvent::KeyPress,
-                        ev.value.button.state.released
-                            ? 0.0f : 1.0f,
                     };
                 }
             }
 
+            // Select the final events.
+            for (ice::InputActionSourceInputInfo const& src : _sources)
+            {
+                ice::InputActionSource* const values = source_values[src.storage_offset];
+                ice::u32 const count_values = 1 + ice::u32(src.type == InputActionSourceType::Axis2d);
+
+                for (ice::u32 idx = 0; idx < count_values; ++idx)
+                {
+                    values[idx].event = ice::exchange(values[idx].temp_event, InputActionSourceEvent::None);
+                }
+            }
+
             // Clear the end of the events list
             for (ice::u32 idx = 1; idx <= count_processed; ++idx)
             {
@@ -308,7 +332,7 @@ namespace ice
                     // If the series is not successful, just continue
                     if (series_success == false || runtime->enabled == false)
                     {
-                        // If the action finaly failes, we reset the state so we can again start counting from 0
+                        // If the action finaly fails, we reset the state so we can again start counting from 0
                         runtime->state = 0;
                         runtime->active = false;
                         continue;