Parial cleanup of action layers.

Author: Dandielo

source/code/core/core/public/ice/error_codes.hxx

@@ -16,6 +16,8 @@ namespace ice
     static constexpr ice::ErrorCode E_InvalidArgument{ "E.0002:General:Invalid argument provided" };
     static constexpr ice::ErrorCode E_OutOfRange{ "E.0003:General:Accessing value out of range" };
     static constexpr ice::ErrorCode E_NotImplemented{ "E.0004:General:Function or method is not implemented" };
+    static constexpr ice::ErrorCode E_NullPointerData{ "E.0005:General:Passed 'Data{nullptr}' object to function expecting valid data." };
+    static constexpr ice::ErrorCode E_NullPointerMemory{ "E.0006:General:Passed 'Memory{nullptr}' object to function expecting valid memory." };
     static constexpr ice::ErrorCode E_TaskCanceled{ "E.1001:Tasks:Task canceled" };
 
     // Aliases are comparable

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

@@ -32,6 +32,7 @@ namespace ice
     void InputActionDSLLayerBuilder::visit(arctic::SyntaxNode<ice::syntax::Layer> node) noexcept
     {
         ICE_LOG(LogSeverity::Info, LogTag::Engine, "Layer: {}", node.data().name);
+        _builder->set_name(node.data().name);
 
         arctic::SyntaxNode<> child = node.child();
         while(child != false)

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

@@ -5,6 +5,19 @@
 namespace ice
 {
 
+    //! \brief Header-like structure for binarized version of an InputActionLayer.
+    //! \note This structure will be used for storing input actions in binary format for release builds.
+    struct InputActionLayerInfoHeader
+    {
+        ice::u16 size_name;
+        ice::u16 count_sources;
+        ice::u16 count_actions;
+        ice::u16 count_conditions;
+        ice::u16 count_steps;
+        ice::u16 count_modifiers;
+        ice::u32 offset_strings;
+    };
+
     struct InputActionIndex
     {
         static constexpr ice::u16 SelfIndex = 8191;

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

@@ -17,8 +17,9 @@
 namespace ice
 {
 
-    struct StandardInputActionLayerParams
+    struct InputActionLayerInfo
     {
+        ice::String name;
         ice::Span<ice::InputActionSourceInputInfo const> sources;
         ice::Span<ice::InputActionInfo const> actions;
         ice::Span<ice::InputActionConditionData const> conditions;
@@ -27,30 +28,37 @@ namespace ice
         ice::String strings;
     };
 
-    auto params_from_data(ice::Data memory) noexcept -> ice::Expected<ice::StandardInputActionLayerParams>
+    template<typename T>
+    auto load_field_from_data(ice::Span<T const>& out_span, ice::Data data, ice::usize offset, ice::ucount count) noexcept
     {
-        ice::InputActionLayerInfo const* layer_info = reinterpret_cast<ice::InputActionLayerInfo const*>(memory.location);
-        if (layer_info == nullptr)
+        out_span = ice::span::from_data<T>(data, count, offset);
+        return ice::span::data_view(out_span).size;
+    }
+
+    auto load_from_data(ice::Data data) noexcept -> ice::Expected<ice::InputActionLayerInfo>
+    {
+        if (data.location == nullptr)
         {
-            return E_Fail;
+            return E_NullPointerData;
         }
 
-        ice::usize offset = ice::size_of<ice::InputActionLayerInfo>;
-        ice::StandardInputActionLayerParams result{};
-
-        result.sources = ice::span::from_data<ice::InputActionSourceInputInfo>(memory, layer_info->count_sources, offset);
-        offset += ice::span::data_view(result.sources).size;
-        result.actions = ice::span::from_data<ice::InputActionInfo>(memory, layer_info->count_actions, offset);
-        offset += ice::span::data_view(result.actions).size;
-        result.conditions = ice::span::from_data<ice::InputActionConditionData>(memory, layer_info->count_conditions, offset);
-        offset += ice::span::data_view(result.conditions).size;
-        result.steps = ice::span::from_data<ice::InputActionStepData>(memory, layer_info->count_steps, offset);
-        offset += ice::span::data_view(result.steps).size;
-        result.modifiers = ice::span::from_data<ice::InputActionModifierData>(memory, layer_info->count_modifiers, offset);
-        offset += ice::span::data_view(result.modifiers).size;
-
-        ICE_ASSERT_CORE(offset == ice::usize{ layer_info->offset_strings });
-        result.strings = ice::string::from_data(memory, { layer_info->offset_strings }, ice::ucount(memory.size.value - layer_info->offset_strings));
+        ice::InputActionLayerInfoHeader const& header = *reinterpret_cast<ice::InputActionLayerInfoHeader const*>(data.location);
+        ice::usize offset = ice::size_of<ice::InputActionLayerInfoHeader>;
+
+        ice::InputActionLayerInfo result{};
+        offset += load_field_from_data(result.sources, data, offset, header.count_sources);
+        offset += load_field_from_data(result.actions, data, offset, header.count_actions);
+        offset += load_field_from_data(result.conditions, data, offset, header.count_conditions);
+        offset += load_field_from_data(result.steps, data, offset, header.count_steps);
+        offset += load_field_from_data(result.modifiers, data, offset, header.count_modifiers);
+
+        ICE_ASSERT_CORE(offset == ice::usize{ header.offset_strings });
+        result.strings = ice::string::from_data(
+            data,
+            ice::usize{ header.offset_strings },
+            ice::ucount( data.size.value - header.offset_strings )
+        );
+        result.name = ice::string::substr(result.strings, 0, header.size_name);
         return result;
     }
 
@@ -60,21 +68,18 @@ namespace ice
         StandardInputActionLayer(
             ice::Allocator& alloc,
             ice::Memory memory,
-            ice::StandardInputActionLayerParams const& params
+            ice::InputActionLayerInfo const& info
         ) noexcept
             : _allocator{ alloc }
             , _rawdata{ memory }
-            , _sources{ params.sources }
-            , _actions{ params.actions }
-            , _conditions{ params.conditions }
-            , _steps{ params.steps }
-            , _modifiers{ params.modifiers }
-            , _strings{ params.strings }
-            , _runtime_sources{ alloc }
-        {
-            ice::array::resize(_runtime_sources, ice::count(_sources));
-            ice::array::memset(_runtime_sources, 0);
-        }
+            , _name{ info.name }
+            , _sources{ info.sources }
+            , _actions{ info.actions }
+            , _conditions{ info.conditions }
+            , _steps{ info.steps }
+            , _modifiers{ info.modifiers }
+            , _strings{ info.strings }
+        { }
 
         ~StandardInputActionLayer() noexcept override
         {
@@ -83,7 +88,7 @@ namespace ice
 
         auto name() const noexcept -> ice::String override
         {
-            return "Default";
+            return _name;
         }
 
         auto sources() const noexcept -> ice::Span<ice::InputActionSourceInputInfo const> override
@@ -106,14 +111,15 @@ namespace ice
             return ice::string::substr(_strings, action.name);
         }
 
-        bool process_inputs(
-            ice::Span<ice::input::InputEvent const> input_events,
+        auto process_inputs(
+            ice::Span<ice::input::InputEvent> input_events,
             ice::Span<ice::InputActionSource* const> source_values
-        ) const noexcept override
+        ) const noexcept -> ice::ucount override
         {
             IPT_ZONE_SCOPED;
 
             ice::ucount event_index = 0;
+            ice::ucount processed_count = 0;
             ice::ucount const event_count = ice::count(input_events);
 
             while(event_index < event_count)
@@ -170,20 +176,15 @@ namespace ice
                         };
                     }
 
-                    // ICE_LOG(LogSeverity::Debug, LogTag::Engine, "SRC: '{}', VAL = {}", ice::string::substr(_strings, src.name_offset, src.name_length), value.value);
-
-                    // Remove the processed input
-                    // if (ice::exchange(removed, true) == false)
-                    // {
-                    //     ice::array::remove_at(inputs, index);
-                    //     count -= 1;
-                    // }
+                    // Clear the processed event
+                    input_events[event_index] = ice::input::InputEvent{};
+                    processed_count += 1;
                 }
 
                 event_index += 1;
             }
 
-            return event_count != ice::count(input_events);
+            return processed_count;
         }
 
         bool update_actions(
@@ -366,14 +367,13 @@ namespace ice
         ice::Allocator& _allocator;
         ice::Memory _rawdata;
 
+        ice::String _name;
         ice::Span<ice::InputActionSourceInputInfo const> _sources;
         ice::Span<ice::InputActionInfo const> _actions;
         ice::Span<ice::InputActionConditionData const> _conditions;
         ice::Span<ice::InputActionStepData const> _steps;
         ice::Span<ice::InputActionModifierData const> _modifiers;
         ice::String _strings;
-
-        ice::Array<ice::InputActionSource> _runtime_sources;
     };
 
     auto create_input_action_layer(
@@ -384,7 +384,7 @@ namespace ice
         ice::Memory const data_copy = alloc.allocate({ layer_data.size, layer_data.alignment });
         ice::memcpy(data_copy, layer_data);
 
-        ice::Expected<ice::StandardInputActionLayerParams> params = ice::params_from_data(ice::data_view(data_copy));
+        ice::Expected<ice::InputActionLayerInfo> params = ice::load_from_data(ice::data_view(data_copy));
         if (params.succeeded() == false)
         {
             return {};
@@ -398,7 +398,7 @@ namespace ice
         ice::Memory layer_data
     ) noexcept -> ice::UniquePtr<ice::InputActionLayer>
     {
-        ice::Expected<ice::StandardInputActionLayerParams> params = ice::params_from_data(ice::data_view(layer_data));
+        ice::Expected<ice::InputActionLayerInfo> params = ice::load_from_data(ice::data_view(layer_data));
         if (params.succeeded() == false)
         {
             return {};
@@ -412,7 +412,7 @@ namespace ice
         ice::String definition
     ) noexcept -> ice::UniquePtr<ice::InputActionLayer>
     {
-        InputActionDSLLayerBuilder dsl_builder{ ice::create_input_action_layer_builder(alloc) };
+        InputActionDSLLayerBuilder dsl_builder{ ice::create_input_action_layer_builder(alloc, "") };
         if (ice::parse_action_input_definition(definition, dsl_builder))
         {
             return dsl_builder.finalize(alloc);

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

@@ -107,15 +107,27 @@ namespace ice
     class SimpleInputActionLayerBuilder : public ice::InputActionLayerBuilder
     {
     public:
-        SimpleInputActionLayerBuilder(ice::Allocator& alloc) noexcept
+        SimpleInputActionLayerBuilder(
+            ice::Allocator& alloc,
+            ice::String name
+        ) noexcept
             : _allocator{ alloc }
             , _sources{ alloc }
             , _actions{ alloc }
+            , _name{ alloc, name }
         {
             ice::hashmap::reserve(_sources, 16);
             ice::hashmap::reserve(_actions, 10);
         }
 
+        auto set_name(
+            ice::String name
+        ) noexcept -> ice::InputActionLayerBuilder& override
+        {
+            _name = name;
+            return *this;
+        }
+
         auto define_source(ice::String name, ice::InputActionSourceType type) noexcept -> SourceBuilder override
         {
             ice::hashmap::set(_sources, ice::hash(name), {_allocator, name, type});
@@ -142,6 +154,10 @@ namespace ice
             ice::Array<ice::InputActionModifierData> final_modifiers{ _allocator };
             ice::Array<ice::InputActionInfo> final_actions{ _allocator };
 
+            // Insert layer name as the first string
+            ice::string::push_back(strings, _name);
+            ice::string::push_back(strings, '\0');
+
             // Prepare data of all sources
             for (SourceBuilder::Internal const& source : _sources)
             {
@@ -307,7 +323,8 @@ namespace ice
                 condition_offset += ice::exchange(condition_count, ice::u16_0);
             }
 
-            ice::InputActionLayerInfo final_info{
+            ice::InputActionLayerInfoHeader final_info{
+                .size_name = ice::u16(ice::size(_name)),
                 .count_sources = ice::u16(ice::count(final_sources)),
                 .count_actions = ice::u16(ice::count(final_actions)),
                 .count_conditions = ice::u16(ice::count(final_conditions)),
@@ -317,7 +334,7 @@ namespace ice
             };
 
             // Allocate memory and copy all data
-            ice::meminfo minfo_layer = ice::meminfo_of<ice::InputActionLayerInfo>;
+            ice::meminfo minfo_layer = ice::meminfo_of<ice::InputActionLayerInfoHeader>;
             ice::usize const offset_sources = minfo_layer += ice::array::meminfo(final_sources);
             ice::usize const offset_actions = minfo_layer += ice::array::meminfo(final_actions);
             ice::usize const offset_conditions = minfo_layer += ice::array::meminfo(final_conditions);
@@ -341,6 +358,7 @@ namespace ice
         ice::Allocator& _allocator;
         ice::HashMap<SourceBuilder::Internal> _sources;
         ice::HashMap<ActionBuilder::Internal> _actions;
+        ice::HeapString<> _name;
     };
 
 
@@ -550,9 +568,12 @@ namespace ice
         return *this;
     }
 
-    auto create_input_action_layer_builder(ice::Allocator& alloc) noexcept -> ice::UniquePtr<ice::InputActionLayerBuilder>
+    auto create_input_action_layer_builder(
+        ice::Allocator& alloc,
+        ice::String name
+    ) noexcept -> ice::UniquePtr<ice::InputActionLayerBuilder>
     {
-        return ice::make_unique<SimpleInputActionLayerBuilder>(alloc, alloc);
+        return ice::make_unique<SimpleInputActionLayerBuilder>(alloc, alloc, name);
     }
 
 } // namespace ice

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

@@ -278,6 +278,7 @@ namespace ice
     {
         IPT_ZONE_SCOPED;
 
+        ice::ucount remaining_events = ice::count(events);
         ice::Array<ice::input::InputEvent> events_copy{ _allocator, events };
         ice::Array<ice::InputActionSource*> source_values{ _allocator };
 
@@ -295,7 +296,15 @@ namespace ice
                 ice::array::push_back(source_values, ice::addressof(_sources_values[offset]));
             }
 
-            layer.layer->process_inputs(events_copy, source_values);
+            ice::ucount const processed_events = layer.layer->process_inputs(events_copy, source_values);
+            ICE_ASSERT_CORE(processed_events <= remaining_events);
+            remaining_events -= processed_events;
+
+            // TODO: further cleanup.
+            if (remaining_events == 0)
+            {
+                break;
+            }
         }
 
         ice::InputActionExecutor ex{};

source/code/systems/input_action_system/public/ice/input_action_definitions.hxx

@@ -61,8 +61,10 @@ namespace ice
     //! \brief Developer defined "input source" for activating actions and processing their values.
     //! \details A source represents a single device input event. This can be a Button, Axis, Trigger, Key, Position on
     //!   any input device like a mouse, keyboard, controller or anything else.
+    //!
     //! \note When represeting an axis, only a single component is set each source.
     //!   So for a 2d axis you will need to define two sources.
+    //! \todo Try to remove the 23bit padding.
     struct InputActionSource
     {
         //! \brief The type of the event that triggered a value change for this source.
@@ -73,6 +75,8 @@ namespace ice
         //! \note Since multiple events can trigger a value change, we want to act only once for multiple buttons.
         bool changed;
 
+        // 2 bytes of padding (23 bits in reality due to unused bool bits, 7 + 16)
+
         //! \brief The value of the input source.
         //! \details See \see InputActionSourceInfo::type for details.
         ice::f32 value;

source/code/systems/input_action_system/public/ice/input_action_executor.hxx

@@ -43,19 +43,31 @@ namespace ice
             ice::f32 param
         ) const noexcept;
 
+        //! \brief Executes a step over the current actions runtime object, this is generally called for '.activate', '.toggle' and
+        //!   simmilar actions.
+        //! \param[in] step Action step to be executed.
+        //! \param[out] runtime Object to be modifed from the action step taken.
         void execute_step(
             ice::InputActionStep step,
             ice::InputActionRuntime& runtime
         ) const noexcept;
 
+        //! \brief Executes a step by taking a value from an input source and storing it at a specific input action value.
+        //! \param[in] step Action step to be executed.
+        //! \param[in] source_value Input source from which we want to take the new value.
+        //! \param[out] destination_value Destination value where we want to store the value from the input source.
         void execute_step(
             ice::InputActionStep step,
             ice::InputActionSource const& source_value,
             ice::f32& destination_value
         ) const noexcept;
 
+        //! \brief Executes an modifier with a user provided parameter over an action value.
+        //! \param modifier Modifier to be executed on the given value.
+        //! \param action_value The value to be modified (if necessary).
+        //! \param param User parameter that may be used by the selected modifier.
         void execute_modifier(
-            ice::InputActionModifier step,
+            ice::InputActionModifier modifier,
             ice::f32& action_value,
             ice::f32 param
         ) const noexcept;