Milestone "Resources, Assets and UI"

.editorconfig

@@ -5,9 +5,17 @@
 # top-most EditorConfig file
 root = true
 
+[*.{natvis,xml}]
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
 [*.{c++,cc,cpp,cppm,cxx,h,h++,hh,hpp,hxx,inl,ipp,ixx,tlh,tli}]
 indent_style = space
 insert_final_newline = true
+trim_trailing_whitespace =  true
+
 
 # Visual C++ Code Style settings
 

source/code/core/collections/natvis/collections.natvis

@@ -29,11 +29,13 @@
 
   <!-- Native Visualization for the ice::pod::Hash::Entry type -->
   <Type Name="ice::pod::Hash&lt;*&gt;::Entry">
+    <DisplayString IncludeView="ValueOnly">{value}</DisplayString>
     <DisplayString>Hash::Entry {{ key={key,X}, value={value} }} : {"$T1",sb}</DisplayString>
     <Expand>
-      <Item Name="[key]">key,X</Item>
-      <Item Name="[next]" Condition="next != 0xffffffff">next</Item>
-      <Item Name="[value]">value</Item>
+      <Item ExcludeView="ValueOnly" Name="[key]">key,X</Item>
+      <Item ExcludeView="ValueOnly" Name="[next]" Condition="next != 0xffffffff">next</Item>
+      <Item ExcludeView="ValueOnly" Name="[value]">value</Item>
+      <ExpandedItem IncludeView="ValueOnly">value</ExpandedItem>
     </Expand>
   </Type>
 

source/code/core/collections/public/ice/heap_string.hxx

@@ -191,12 +191,6 @@ namespace ice
         return *this;
     }
 
-    template<typename CharType>
-    inline HeapString<CharType>::operator ice::BasicString<CharType>() const noexcept
-    {
-        return { _data, _size };
-    }
-
     template<typename CharType>
     inline auto operator==(HeapString<CharType> const& left, CharType const* right) noexcept
     {
@@ -215,6 +209,24 @@ namespace ice
         return ice::string::equals(left.operator ice::String(), right.operator ice::String());
     }
 
+    template<typename CharType>
+    inline auto HeapString<CharType>::operator[](uint32_t index) noexcept -> CharType&
+    {
+        return _data[index];
+    }
+
+    template<typename CharType>
+    inline auto HeapString<CharType>::operator[](uint32_t index) const noexcept -> CharType const&
+    {
+        return _data[index];
+    }
+
+    template<typename CharType>
+    inline HeapString<CharType>::operator ice::BasicString<CharType>() const noexcept
+    {
+        return { _data, _size };
+    }
+
     namespace string
     {
 
@@ -272,7 +284,7 @@ namespace ice
         template<typename CharType>
         inline void resize(ice::HeapString<CharType>& str, uint32_t new_size) noexcept
         {
-            if (new_size > str._capacity - 1)
+            if ((new_size + 1) > str._capacity)
             {
                 ice::string::grow(str, new_size + 1);
             }
@@ -328,7 +340,7 @@ namespace ice
                     ice::string::grow(str, new_size + 1);
                 }
 
-                ice::memcpy(ice::string::end(str), ice::string::data(other), ice::string::size(other));
+                ice::memcpy(ice::string::end(str), ice::string::data(other), ice::string::size(other) * sizeof(CharType));
                 str._size = new_size;
                 str._data[str._size] = 0;
             }
@@ -445,7 +457,7 @@ namespace ice
         template<typename CharType>
         inline auto substr(ice::HeapString<CharType> const& str, uint32_t pos, uint32_t len) noexcept -> ice::BasicString<CharType>
         {
-            return ice::string::substr(str.operator ice::String(), pos, len);
+            return ice::string::substr(ice::BasicString<CharType>{ str }, pos, len);
         }
 
         template<typename CharType>

source/code/core/collections/public/ice/pod/array.hxx

@@ -282,14 +282,14 @@ namespace ice::pod
         template<typename T>
         inline void push_back(ice::pod::Array<T>& arr, ice::Span<T const> items) noexcept
         {
-            uint32_t const required_capacity = arr._size + items.size(); // #todo free-function APi
+            uint32_t const required_capacity = arr._size + ice::size(items);
             if (required_capacity > arr._capacity)
             {
                 ice::pod::array::grow(arr, required_capacity);
             }
 
-            ice::memcpy(ice::pod::array::end(arr), items.data(), items.size_bytes()); // #todo free-function API
-            arr._size += items.size(); // #todo free-function API
+            ice::memcpy(ice::pod::array::end(arr), items.data(), items.size_bytes());
+            arr._size += ice::size(items);
         }
 
         template<typename T>
@@ -357,7 +357,7 @@ namespace ice::pod
         template<typename T>
         inline auto span(ice::pod::Array<T> const& arr, ice::u32 offset, ice::u32 count) noexcept -> ice::Span<T const>
         {
-            return ice::Span<T const>{ arr }.subspan(offset, (count == ~0) ? std::dynamic_extent : size_t{ count });
+            return ice::Span<T const>{ arr }.subspan(offset, (count == ~ice::u32{}) ? (arr._size - offset) : size_t{ count });
         }
 
         template<typename T>

source/code/core/collections/public/ice/pod/collections.hxx

@@ -8,6 +8,11 @@ namespace ice::pod
     template<typename T>
     struct Array final
     {
+        static_assert(
+            ::std::is_trivially_copyable_v<T>,
+            "ice::pod::Hash only accepts trivially copyable objects."
+        );
+
         using ValueType = T;
         using Iterator = T*;
         using ReverSeIterator = std::reverse_iterator<T*>;
@@ -37,6 +42,11 @@ namespace ice::pod
     template<typename T>
     struct Queue final
     {
+        static_assert(
+            ::std::is_trivially_copyable_v<T>,
+            "ice::pod::Hash only accepts trivially copyable objects."
+        );
+
         using ValueType = T;
 
         explicit Queue(ice::Allocator& alloc) noexcept;
@@ -53,6 +63,11 @@ namespace ice::pod
     template<typename T>
     struct Hash final
     {
+        static_assert(
+            ::std::is_trivially_copyable_v<T>,
+            "ice::pod::Hash only accepts trivially copyable objects."
+        );
+
         struct Entry
         {
             uint64_t key;

source/code/core/collections/public/ice/pod/hash.hxx

@@ -21,6 +21,9 @@ namespace ice::pod
         inline void remove(ice::pod::Hash<T>& hsh, uint64_t key) noexcept;
 
 
+        template<typename T>
+        inline bool empty(ice::pod::Hash<T> const& hsh) noexcept;
+
         template<typename T>
         inline bool has(ice::pod::Hash<T> const& hsh, uint64_t key) noexcept;
 
@@ -276,7 +279,7 @@ namespace ice::pod
         {
             ice::pod::Hash<T> nh{ *hsh._hash._allocator };
             ice::pod::array::resize(nh._hash, new_size);
-            ice::pod::array::reserve(nh._data, ice::pod::array::size(nh._hash) * (Constant_MaxLoadFactor + 0.05f));
+            ice::pod::array::reserve(nh._data, static_cast<ice::u32>(ice::pod::array::size(nh._hash) * (Constant_MaxLoadFactor + 0.05f)));
             for (uint32_t i = 0; i < new_size; ++i)
             {
                 nh._hash[i] = Constant_EndOfList;
@@ -345,6 +348,12 @@ namespace ice::pod
         }
 
 
+        template<typename T>
+        inline bool empty(ice::pod::Hash<T> const& hsh) noexcept
+        {
+            return ice::pod::array::empty(hsh._data);
+        }
+
         template<typename T>
         inline bool has(ice::pod::Hash<T> const& hsh, uint64_t key) noexcept
         {

source/code/core/collections/public/ice/span.hxx

@@ -1,12 +1,13 @@
 #pragma once
 #include <ice/base.hxx>
+#include <ice/data.hxx>
 #include <span>
 
 namespace ice
 {
 
-    template<typename T, std::size_t Extent = std::dynamic_extent>
-    using Span = std::span<T, Extent>;
+    template<typename T, ::std::size_t Extent = ::std::dynamic_extent>
+    using Span = ::std::span<T, Extent>;
 
     template<typename T>
     constexpr auto size(ice::Span<T> const& span) noexcept -> ice::u32
@@ -20,10 +21,36 @@ namespace ice
         return { cont.data(), cont.size() };
     }
 
-    template<typename T, std::size_t Size, template<typename, std::size_t> typename Container>
+    template<typename T, ::std::size_t Size, template<typename, ::std::size_t> typename Container>
     constexpr auto make_span(Container<T, Size> const& cont) noexcept -> ice::Span<T const, Size>
     {
         return cont;
     }
 
+    template<typename T, ::std::size_t Size>
+    constexpr auto make_span(T(&array_obj)[Size]) noexcept -> ice::Span<T const, Size>
+    {
+        return { array_obj };
+    }
+
+    template<typename T>
+    constexpr auto data_view(ice::Span<T> span, ice::u32 alignment = alignof(T)) noexcept -> ice::Data
+    {
+        return Data{
+            .location = span.data(),
+            .size = static_cast<ice::u32>(span.size_bytes()),
+            .alignment = alignment,
+        };
+    }
+
+    template<typename T>
+    constexpr auto data_view(ice::Span<T const> span, ice::u32 alignment = alignof(T)) noexcept -> ice::Data
+    {
+        return Data{
+            .location = span.data(),
+            .size = static_cast<ice::u32>(span.size_bytes()),
+            .alignment = alignment,
+        };
+    }
+
 } // namespace ice

source/code/core/collections/public/ice/string_types.hxx

@@ -10,6 +10,13 @@ namespace ice
 
     using String = BasicString<char>;
 
+    using Utf8String = BasicString<char8_t>;
+    using AsciiString = BasicString<char>;
+
+#if ISP_WINDOWS
+    using WString = BasicString<wchar_t>;
+#endif
+
     template<typename CharType = char>
     struct HeapString
     {
@@ -79,4 +86,9 @@ namespace ice
 
     static constexpr uint32_t string_npos = std::numeric_limits<uint32_t>::max();
 
+    static constexpr auto operator""_str(char8_t const* str, std::size_t size) noexcept
+    {
+        return ice::Utf8String{ str, size };
+    }
+
 } // namespace ice

source/code/core/collections/tests/test_data_memory.cxx

@@ -0,0 +1,49 @@
+#include <catch2/catch.hpp>
+#include <ice/data.hxx>
+#include <ice/span.hxx>
+
+SCENARIO("ice :: Data")
+{
+    ice::Data data{ };
+
+    WHEN("Empty")
+    {
+        CHECK(data.location == nullptr);
+        CHECK(data.size == 0);
+        CHECK(data.alignment == 0);
+    }
+
+    WHEN("Creating a view to a regular value")
+    {
+        ice::u64 const value = 0x42069;
+
+        data = ice::data_view(value);
+
+        CHECK(data.location == &value);
+        CHECK(data.size == sizeof(ice::u64));
+        CHECK(data.alignment == alignof(ice::u64));
+    }
+
+    WHEN("Creating a view to a span")
+    {
+        ice::u64 const values[]{
+            0,
+            0x32,
+            0x42069,
+            0,
+            0x32,
+            0x42069,
+            0,
+            0x32,
+            0x42069,
+        };
+
+        ice::Span<ice::u64 const> values_span = ice::make_span(values);
+
+        data = ice::data_view(values_span);
+
+        CHECK(data.location == values_span.data());
+        CHECK(data.size == values_span.size_bytes());
+        CHECK(data.alignment == alignof(ice::u64));
+    }
+}

source/code/core/collections/tests/test_shard_container.cxx

@@ -101,11 +101,11 @@ SCENARIO("ice :: shard :: ShardContainer")
             constexpr ice::i32 test_i32_payload_value1 = 0x103232;
             constexpr ice::i32 test_i32_payload_value2 = -0x103232;
             constexpr ice::u32 test_u32_payload_value1 = 0x103232;
-            constexpr ice::u32 test_u32_payload_value2 = -0x103232;
+            constexpr ice::u32 test_u32_payload_value2 = ~0x103232u;
             constexpr ice::i64 test_i64_payload_value1 = 0x7f000000'000000ff;
             constexpr ice::i64 test_i64_payload_value2 = 0xff000000'000000ff;
-            constexpr ice::vec2f test_vec2f_payload_value1 = { 0.16, -0.32 };
-            constexpr ice::vec2f test_vec2f_payload_value2 = { 0.32, -0.16 };
+            constexpr ice::vec2f test_vec2f_payload_value1 = { 0.16f, -0.32f };
+            constexpr ice::vec2f test_vec2f_payload_value2 = { 0.32f, -0.16f };
 
             static constexpr ice::Shard test_shard_3 = "shard_3"_shard;
             static constexpr ice::Shard test_shard_4 = "shard_4"_shard;

source/code/core/core/private/clock.cxx

@@ -83,7 +83,7 @@ namespace ice
         void update(CustomClock& c) noexcept
         {
             c.previous_timestamp = c.latest_timestamp;
-            c.latest_timestamp += (c.base_clock->latest_timestamp - c.base_clock->previous_timestamp) * c.modifier;
+            c.latest_timestamp += static_cast<ice::i64>((c.base_clock->latest_timestamp - c.base_clock->previous_timestamp) * c.modifier);
         }
 
         void update_max_delta(CustomClock& c, float max_elapsed_seconds)

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

@@ -39,3 +39,18 @@ namespace ice
     using clean_type = clear_type_t<T>;
 
 } // namespace ice
+
+//! \brief This macro is required for a bug apprearing in the MSVC compile when generating optimized code with /O2
+//!     It code affected is generally tied to coroutine functions / methods and seems to only occur when working with loops.
+//!     A workaround for this problem is to separate the logic of such a coroutine into a separate function and mark it as 'noinline'
+//!     Once the bug is fixed this macro should be removed.
+//!
+//! GitHub Issue: #108
+#define ISATTR_NOINLINE
+
+#if ISP_WINDOWS
+
+#undef ISATTR_NOINLINE
+#define ISATTR_NOINLINE __declspec(noinline)
+
+#endif // #if ISP_WINDOWS

source/code/core/core/public/ice/build/platform.hxx

@@ -215,6 +215,8 @@ namespace ice::build
             return "msvc";
         case Compiler::Clang:
             return "clang";
+        case Compiler::GCC:
+            return "gcc";
         default:
             return "<invalid>";
         }