Merge branch 'main' of https://github.com/aws-lumberyard/o3de into LYN-2726-ProjectRoot

Code/Framework/AzCore/AzCore/Serialization/Json/ByteStreamSerializer.cpp

@@ -0,0 +1,100 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include "ByteStreamSerializer.h"
+
+#include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/Serialization/Json/JsonSerialization.h>
+#include <AzCore/StringFunc/StringFunc.h>
+
+namespace AZ
+{
+    namespace ByteSerializerInternal
+    {
+        static JsonSerializationResult::Result Load(void* outputValue, const rapidjson::Value& inputValue, JsonDeserializerContext& context)
+        {
+            using JsonSerializationResult::Outcomes;
+            using JsonSerializationResult::Tasks;
+
+            AZ_Assert(outputValue, "Expected a valid pointer to load from json value.");
+
+            switch (inputValue.GetType())
+            {
+            case rapidjson::kStringType: {
+                JsonByteStream buffer;
+                if (AZ::StringFunc::Base64::Decode(buffer, inputValue.GetString(), inputValue.GetStringLength()))
+                {
+                    JsonByteStream* valAsByteStream = static_cast<JsonByteStream*>(outputValue);
+                    *valAsByteStream = AZStd::move(buffer);
+                    return context.Report(Tasks::ReadField, Outcomes::Success, "Successfully read ByteStream.");
+                }
+                return context.Report(Tasks::ReadField, Outcomes::Invalid, "Decode of Base64 encoded ByteStream failed.");
+            }
+            case rapidjson::kArrayType:
+            case rapidjson::kObjectType:
+            case rapidjson::kNullType:
+            case rapidjson::kFalseType:
+            case rapidjson::kTrueType:
+            case rapidjson::kNumberType:
+                return context.Report(
+                    Tasks::ReadField, Outcomes::Unsupported,
+                    "Unsupported type. ByteStream values cannot be read from arrays, objects, nulls, booleans or numbers.");
+            default:
+                return context.Report(Tasks::ReadField, Outcomes::Unknown, "Unknown json type encountered for ByteStream value.");
+            }
+        }
+
+        static JsonSerializationResult::Result StoreWithDefault(
+            rapidjson::Value& outputValue, const void* inputValue, const void* defaultValue, JsonSerializerContext& context)
+        {
+            using JsonSerializationResult::Outcomes;
+            using JsonSerializationResult::Tasks;
+
+            const JsonByteStream& valAsByteStream = *static_cast<const JsonByteStream*>(inputValue);
+            if (context.ShouldKeepDefaults() || !defaultValue || (valAsByteStream != *static_cast<const JsonByteStream*>(defaultValue)))
+            {
+                const auto base64ByteStream = AZ::StringFunc::Base64::Encode(valAsByteStream.data(), valAsByteStream.size());
+                outputValue.SetString(base64ByteStream.c_str(), base64ByteStream.size(), context.GetJsonAllocator());
+                return context.Report(Tasks::WriteValue, Outcomes::Success, "ByteStream successfully stored.");
+            }
+
+            return context.Report(Tasks::WriteValue, Outcomes::DefaultsUsed, "Default ByteStream used.");
+        }
+    } // namespace ByteSerializerInternal
+
+    AZ_CLASS_ALLOCATOR_IMPL(JsonByteStreamSerializer, SystemAllocator, 0);
+
+    JsonSerializationResult::Result JsonByteStreamSerializer::Load(
+        void* outputValue, [[maybe_unused]] const Uuid& outputValueTypeId, const rapidjson::Value& inputValue,
+        JsonDeserializerContext& context)
+    {
+        AZ_Assert(
+            azrtti_typeid<JsonByteStream>() == outputValueTypeId,
+            "Unable to deserialize AZStd::vector<AZ::u8>> to json because the provided type is %s",
+            outputValueTypeId.ToString<AZStd::string>().c_str());
+
+        return ByteSerializerInternal::Load(outputValue, inputValue, context);
+    }
+
+    JsonSerializationResult::Result JsonByteStreamSerializer::Store(
+        rapidjson::Value& outputValue, const void* inputValue, const void* defaultValue, [[maybe_unused]] const Uuid& valueTypeId,
+        JsonSerializerContext& context)
+    {
+        AZ_Assert(
+            azrtti_typeid<JsonByteStream>() == valueTypeId,
+            "Unable to serialize AZStd::vector<AZ::u8> to json because the provided type is %s",
+            valueTypeId.ToString<AZStd::string>().c_str());
+
+        return ByteSerializerInternal::StoreWithDefault(outputValue, inputValue, defaultValue, context);
+    }
+} // namespace AZ

Code/Framework/AzCore/AzCore/Serialization/Json/ByteStreamSerializer.h

@@ -0,0 +1,38 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
+#include <AzCore/std/containers/vector.h>
+
+namespace AZ
+{
+    using JsonByteStream = AZStd::vector<AZ::u8>; //!< Alias for AZStd::vector<AZ::u8>.
+
+    //! Serialize a stream of bytes (usually binary data) as a json string value.
+    //! @note Related to GenericClassByteStream (part of SerializeGenericTypeInfo<AZStd::vector<AZ::u8>> - see AZStdContainers.inl for more
+    //! details).
+    class JsonByteStreamSerializer : public BaseJsonSerializer
+    {
+    public:
+        AZ_RTTI(JsonByteStreamSerializer, "{30F0EA5A-CD13-4BA7-BAE1-D50D851CAC45}", BaseJsonSerializer);
+        AZ_CLASS_ALLOCATOR_DECL;
+
+        JsonSerializationResult::Result Load(
+            void* outputValue, const Uuid& outputValueTypeId, const rapidjson::Value& inputValue,
+            JsonDeserializerContext& context) override;
+        JsonSerializationResult::Result Store(
+            rapidjson::Value& outputValue, const void* inputValue, const void* defaultValue, const Uuid& valueTypeId,
+            JsonSerializerContext& context) override;
+    };
+} // namespace AZ

Code/Framework/AzCore/AzCore/Serialization/Json/JsonSystemComponent.cpp

@@ -14,6 +14,7 @@
 #include <AzCore/Serialization/Json/ArraySerializer.h>
 #include <AzCore/Serialization/Json/BasicContainerSerializer.h>
 #include <AzCore/Serialization/Json/BoolSerializer.h>
+#include <AzCore/Serialization/Json/ByteStreamSerializer.h>
 #include <AzCore/Serialization/Json/DoubleSerializer.h>
 #include <AzCore/Serialization/Json/IntSerializer.h>
 #include <AzCore/Serialization/Json/JsonSystemComponent.h>
@@ -68,6 +69,8 @@ namespace AZ
             jsonContext->Serializer<JsonStringSerializer>()->HandlesType<AZStd::string>();
             jsonContext->Serializer<JsonOSStringSerializer>()->HandlesType<OSString>();
 
+            jsonContext->Serializer<JsonByteStreamSerializer>()->HandlesType<JsonByteStream>();
+
             jsonContext->Serializer<JsonBasicContainerSerializer>()
                 ->HandlesType<AZStd::fixed_vector>()
                 ->HandlesType<AZStd::forward_list>()

Code/Framework/AzCore/AzCore/azcore_files.cmake

@@ -505,6 +505,8 @@ set(FILES
     Serialization/Json/BasicContainerSerializer.cpp
     Serialization/Json/BoolSerializer.h
     Serialization/Json/BoolSerializer.cpp
+    Serialization/Json/ByteStreamSerializer.h
+    Serialization/Json/ByteStreamSerializer.cpp
     Serialization/Json/CastingHelpers.h
     Serialization/Json/DoubleSerializer.h
     Serialization/Json/DoubleSerializer.cpp

Code/Framework/AzCore/Tests/Serialization/Json/ByteStreamSerializerTests.cpp

@@ -0,0 +1,59 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include <AzCore/Serialization/Json/ByteStreamSerializer.h>
+#include <Tests/Serialization/Json/BaseJsonSerializerFixture.h>
+#include <Tests/Serialization/Json/JsonSerializerConformityTests.h>
+
+namespace JsonSerializationTests
+{
+    class ByteStreamSerializerTestDescription : public JsonSerializerConformityTestDescriptor<AZ::JsonByteStream>
+    {
+    public:
+        AZStd::shared_ptr<AZ::BaseJsonSerializer> CreateSerializer() override
+        {
+            return AZStd::make_shared<AZ::JsonByteStreamSerializer>();
+        }
+
+        AZStd::shared_ptr<AZ::JsonByteStream> CreateDefaultInstance() override
+        {
+            return AZStd::make_shared<AZ::JsonByteStream>();
+        }
+
+        AZStd::shared_ptr<AZ::JsonByteStream> CreateFullySetInstance() override
+        {
+            // create a JsonByteStream (AZStd::vector<u8>) with ten 'a's
+            return AZStd::make_shared<AZ::JsonByteStream>(10, 'a');
+        }
+
+        AZStd::string_view GetJsonForFullySetInstance() override
+        {
+            // Base64 encoded version of 'aaaaaaaaaa' (see CreateFullySetInstance)
+            return R"("YWFhYWFhYWFhYQ==")";
+        }
+
+        void ConfigureFeatures(JsonSerializerConformityTestDescriptorFeatures& features) override
+        {
+            features.EnableJsonType(rapidjson::kStringType);
+            features.m_supportsPartialInitialization = false;
+            features.m_supportsInjection = false;
+        }
+
+        bool AreEqual(const AZ::JsonByteStream& lhs, const AZ::JsonByteStream& rhs) override
+        {
+            return lhs == rhs;
+        }
+    };
+
+    using ByteStreamConformityTestTypes = ::testing::Types<ByteStreamSerializerTestDescription>;
+    INSTANTIATE_TYPED_TEST_CASE_P(JsonByteStreamSerialzier, JsonSerializerConformityTests, ByteStreamConformityTestTypes);
+} // namespace JsonSerializationTests

Code/Framework/AzCore/Tests/azcoretests_files.cmake

@@ -98,6 +98,7 @@ set(FILES
     Serialization/Json/BaseJsonSerializerTests.cpp
     Serialization/Json/BasicContainerSerializerTests.cpp
     Serialization/Json/BoolSerializerTests.cpp
+    Serialization/Json/ByteStreamSerializerTests.cpp
     Serialization/Json/ColorSerializerTests.cpp
     Serialization/Json/DoubleSerializerTests.cpp
     Serialization/Json/IntSerializerTests.cpp

Code/Framework/AzFramework/AzFramework/Physics/ShapeConfiguration.cpp

@@ -142,6 +142,7 @@ namespace Physics
                 ->Field("PhysicsAsset", &PhysicsAssetShapeConfiguration::m_asset)
                 ->Field("AssetScale", &PhysicsAssetShapeConfiguration::m_assetScale)
                 ->Field("UseMaterialsFromAsset", &PhysicsAssetShapeConfiguration::m_useMaterialsFromAsset)
+                ->Field("SubdivisionLevel", &PhysicsAssetShapeConfiguration::m_subdivisionLevel)
                 ;
 
             if (auto editContext = serializeContext->GetEditContext())

Code/Framework/AzFramework/AzFramework/Physics/ShapeConfiguration.h

@@ -141,6 +141,7 @@ namespace Physics
         AZ::Data::Asset<AZ::Data::AssetData> m_asset{ AZ::Data::AssetLoadBehavior::PreLoad };
         AZ::Vector3 m_assetScale = AZ::Vector3::CreateOne();
         bool m_useMaterialsFromAsset = true;
+        AZ::u8 m_subdivisionLevel = 4; ///< The level of subdivision if a primitive shape is replaced with a convex mesh due to scaling.
     };
 
     class NativeShapeConfiguration : public ShapeConfiguration

Code/Framework/AzFramework/AzFramework/Physics/SystemBus.h

@@ -142,13 +142,6 @@ namespace Physics
 
         virtual AZStd::shared_ptr<Shape> CreateShape(const ColliderConfiguration& colliderConfiguration, const ShapeConfiguration& configuration) = 0;
 
-        /// Adds an appropriate collider component to the entity based on the provided shape configuration.
-        /// @param entity Entity where the component should be added to.
-        /// @param colliderConfiguration Configuration of the collider.
-        /// @param shapeConfiguration Configuration of the shape of the collider.
-        /// @param addEditorComponents Tells whether to add the Editor version of the collider component or the Game one.
-        virtual void AddColliderComponentToEntity(AZ::Entity* entity, const Physics::ColliderConfiguration& colliderConfiguration, const Physics::ShapeConfiguration& shapeConfiguration, bool addEditorComponents = false) = 0;
-
         /// Releases the mesh object created by the physics backend.
         /// @param nativeMeshObject Pointer to the mesh object.
         virtual void ReleaseNativeMeshObject(void* nativeMeshObject) = 0;

Code/Framework/AzNetworking/AzNetworking/DataStructures/FixedSizeBitset.h

@@ -115,7 +115,7 @@ namespace AzNetworking
 
         ContainerType m_container;
 
-        template <AZStd::size_t, typename ElementType>
+        template <AZStd::size_t, typename>
         friend class FixedSizeVectorBitset;
     };
 }