birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #3309 from aws-lumberyard-dev/carlitosan/development

Browse Source 
JSON serialization of SC Editor Assets
This commit is contained in:
carlitosan
2021-08-24 11:45:18 -07:00
committed by GitHub
parent 40f41689ee 794c22c02e
commit 4e0399b283
86 changed files with 8079 additions and 11644 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AtomCore/AtomCore/atomcore_files.cmake
-2
View File
@@ -13,8 +13,6 @@ set(FILES
Instance/InstanceData.h
Instance/InstanceData.cpp
Instance/InstanceDatabase.h
Serialization/Json/JsonUtils.h
Serialization/Json/JsonUtils.cpp
std/containers/array_view.h
std/containers/fixed_vector_set.h
std/containers/lru_cache.h
Code/Framework/AtomCore/Tests/atomcore_tests_files.cmake
-1
View File
@@ -10,7 +10,6 @@ set(FILES
ArrayView.cpp
ConcurrencyCheckerTests.cpp
InstanceDatabase.cpp
JsonSerializationUtilsTests.cpp
lru_cache.cpp
Main.cpp
vector_set.cpp
Code/Framework/AzCore/AzCore/Serialization/AZStdAnyDataContainer.inl
+20 -24
View File
@@ -209,39 +209,35 @@ namespace AZ
//! performance sensitive code.
AZ_INLINE bool CompareAnyValue(const AZStd::any& lhs, const AZStd::any& rhs)
{
bool isEqual = false;
if (lhs.type() != rhs.type())
if (lhs.type() == rhs.type())
{
return false;
}
AZ::SerializeContext* serializeContext = nullptr;
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
AZ::SerializeContext* serializeContext = nullptr;
AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(lhs.type());
if (classData)
{
if (classData->m_serializer)
const AZ::SerializeContext::ClassData* classData = serializeContext->FindClassData(lhs.type());
if (classData)
{
isEqual = classData->m_serializer->CompareValueData(AZStd::any_cast<void>(&lhs), AZStd::any_cast<void>(&rhs));
}
else
{
AZStd::vector<AZ::u8> myData;
AZ::IO::ByteContainerStream<decltype(myData)> myDataStream(&myData);
if (classData->m_serializer)
{
return classData->m_serializer->CompareValueData(AZStd::any_cast<void>(&lhs), AZStd::any_cast<void>(&rhs));
}
else
{
AZStd::vector<AZ::u8> myData;
AZ::IO::ByteContainerStream<decltype(myData)> myDataStream(&myData);
AZ::Utils::SaveObjectToStream(myDataStream, AZ::ObjectStream::ST_BINARY, AZStd::any_cast<void>(&lhs), lhs.type());
AZ::Utils::SaveObjectToStream(myDataStream, AZ::ObjectStream::ST_BINARY, AZStd::any_cast<void>(&lhs), lhs.type());
AZStd::vector<AZ::u8> otherData;
AZ::IO::ByteContainerStream<decltype(otherData)> otherDataStream(&otherData);
AZStd::vector<AZ::u8> otherData;
AZ::IO::ByteContainerStream<decltype(otherData)> otherDataStream(&otherData);
AZ::Utils::SaveObjectToStream(otherDataStream, AZ::ObjectStream::ST_BINARY, AZStd::any_cast<void>(&rhs), rhs.type());
isEqual = (myData.size() == otherData.size()) && (memcmp(myData.data(), otherData.data(), myData.size()) == 0);
AZ::Utils::SaveObjectToStream(otherDataStream, AZ::ObjectStream::ST_BINARY, AZStd::any_cast<void>(&rhs), rhs.type());
return (myData.size() == otherData.size()) && (memcmp(myData.data(), otherData.data(), myData.size()) == 0);
}
}
}
return isEqual;
return false;
}
}
}
Code/Framework/AzCore/AzCore/Serialization/Json/BaseJsonSerializer.cpp
+15 -7
View File
@@ -213,9 +213,13 @@ namespace AZ
void* object, const Uuid& typeId, const rapidjson::Value& value, JsonDeserializerContext& context, ContinuationFlags flags)
{
bool loadAsNewInstance = (flags & ContinuationFlags::LoadAsNewInstance) == ContinuationFlags::LoadAsNewInstance;
JsonDeserializer::UseTypeDeserializer useCustom = (flags & ContinuationFlags::IgnoreTypeSerializer) == ContinuationFlags::IgnoreTypeSerializer
? JsonDeserializer::UseTypeDeserializer::No
: JsonDeserializer::UseTypeDeserializer::Yes;
return (flags & ContinuationFlags::ResolvePointer) == ContinuationFlags::ResolvePointer
? JsonDeserializer::LoadToPointer(object, typeId, value, context)
: JsonDeserializer::Load(object, typeId, value, loadAsNewInstance, context);
? JsonDeserializer::LoadToPointer(object, typeId, value, useCustom, context)
: JsonDeserializer::Load(object, typeId, value, loadAsNewInstance, useCustom, context);
}
JsonSerializationResult::ResultCode BaseJsonSerializer::ContinueStoring(
@@ -224,11 +228,15 @@ namespace AZ
{
using namespace JsonSerializationResult;
JsonSerializer::UseTypeSerializer useCustom = (flags & ContinuationFlags::IgnoreTypeSerializer) == ContinuationFlags::IgnoreTypeSerializer
? JsonSerializer::UseTypeSerializer::No
: JsonSerializer::UseTypeSerializer::Yes;
if ((flags & ContinuationFlags::ReplaceDefault) == ContinuationFlags::ReplaceDefault && !context.ShouldKeepDefaults())
{
if ((flags & ContinuationFlags::ResolvePointer) == ContinuationFlags::ResolvePointer)
{
return JsonSerializer::StoreFromPointer(output, object, nullptr, typeId, context);
return JsonSerializer::StoreFromPointer(output, object, nullptr, typeId, useCustom, context);
}
else
{
@@ -241,19 +249,19 @@ namespace AZ
{
return result;
}
return result.Combine(JsonSerializer::Store(output, object, nullptr, typeId, context));
return result.Combine(JsonSerializer::Store(output, object, nullptr, typeId, useCustom, context));
}
else
{
void* defaultObjectPtr = AZStd::any_cast<void>(&newDefaultObject);
return JsonSerializer::Store(output, object, defaultObjectPtr, typeId, context);
return JsonSerializer::Store(output, object, defaultObjectPtr, typeId, useCustom, context);
}
}
}
return (flags & ContinuationFlags::ResolvePointer) == ContinuationFlags::ResolvePointer ?
JsonSerializer::StoreFromPointer(output, object, defaultObject, typeId, context) :
JsonSerializer::Store(output, object, defaultObject, typeId, context);
JsonSerializer::StoreFromPointer(output, object, defaultObject, typeId, useCustom, context) :
JsonSerializer::Store(output, object, defaultObject, typeId, useCustom, context);
}
JsonSerializationResult::ResultCode BaseJsonSerializer::LoadTypeId(Uuid& typeId, const rapidjson::Value& input,
Code/Framework/AzCore/AzCore/Serialization/Json/BaseJsonSerializer.h
+7 -6
View File
@@ -159,12 +159,13 @@ namespace AZ
enum class ContinuationFlags
{
None = 0, //! No extra flags.
ResolvePointer = 1 << 0, //! The pointer passed in contains a pointer. The (de)serializer will attempt to resolve to an instance.
ReplaceDefault = 1 << 1, //! The default value provided for storing will be replaced with a newly created one.
LoadAsNewInstance = 1 << 2 //! Treats the value as if it's a newly created instance. This may trigger serializers marked with
//! OperationFlags::InitializeNewInstance. Used for instance by pointers or new instances added to
//! an array.
None = 0, //! No extra flags.
ResolvePointer = 1 << 0, //! The pointer passed in contains a pointer. The (de)serializer will attempt to resolve to an instance.
ReplaceDefault = 1 << 1, //! The default value provided for storing will be replaced with a newly created one.
LoadAsNewInstance = 1 << 2, //! Treats the value as if it's a newly created instance. This may trigger serializers marked with
//! OperationFlags::InitializeNewInstance. Used for instance by pointers or new instances added to
//! an array.
IgnoreTypeSerializer = 1 << 3, //! Ignore the custom/specific serializer for the TypeId
};
enum class OperationFlags
Code/Framework/AzCore/AzCore/Serialization/Json/JsonDeserializer.cpp
+13 -9
View File
@@ -38,7 +38,8 @@ namespace AZ
}
JsonSerializationResult::ResultCode JsonDeserializer::Load(
void* object, const Uuid& typeId, const rapidjson::Value& value, bool isNewInstance, JsonDeserializerContext& context)
void* object, const Uuid& typeId, const rapidjson::Value& value, bool isNewInstance, UseTypeDeserializer custom,
JsonDeserializerContext& context)
{
using namespace AZ::JsonSerializationResult;
@@ -48,8 +49,8 @@ namespace AZ
"Target object for Json Serialization is pointing to nothing during loading.");
}
BaseJsonSerializer* serializer = context.GetRegistrationContext()->GetSerializerForType(typeId);
if (serializer)
if (BaseJsonSerializer* serializer
= (custom == UseTypeDeserializer::Yes ? context.GetRegistrationContext()->GetSerializerForType(typeId) : nullptr))
{
return DeserializerDefaultCheck(serializer, object, typeId, value, isNewInstance, context);
}
@@ -70,8 +71,11 @@ namespace AZ
// type itself has not been reflected using EnumBuilder. Treat it as an enum.
return LoadEnum(object, *classData, value, context);
}
serializer = context.GetRegistrationContext()->GetSerializerForType(classData->m_azRtti->GetGenericTypeId());
if (serializer)
if (BaseJsonSerializer* serializer
= (custom == UseTypeDeserializer::Yes)
? context.GetRegistrationContext()->GetSerializerForType(classData->m_azRtti->GetGenericTypeId())
: nullptr)
{
return DeserializerDefaultCheck(serializer, object, typeId, value, isNewInstance, context);
}
@@ -101,7 +105,7 @@ namespace AZ
}
JsonSerializationResult::ResultCode JsonDeserializer::LoadToPointer(void* object, const Uuid& typeId,
const rapidjson::Value& value, JsonDeserializerContext& context)
const rapidjson::Value& value, UseTypeDeserializer useCustom, JsonDeserializerContext& context)
{
using namespace JsonSerializationResult;
@@ -134,7 +138,7 @@ namespace AZ
const SerializeContext::ClassData* resolvedClassData = context.GetSerializeContext()->FindClassData(resolvedTypeId);
if (resolvedClassData)
{
status = JsonDeserializer::Load(*objectPtr, resolvedTypeId, value, true, context);
status = JsonDeserializer::Load(*objectPtr, resolvedTypeId, value, true, useCustom, context);
*objectPtr = resolvedClassData->m_azRtti->Cast(*objectPtr, typeId);
@@ -171,11 +175,11 @@ namespace AZ
}
AZ_Assert(classElement.m_azRtti->GetTypeId() == classElement.m_typeId,
"Type id mismatch during deserialization of a json file. (%s vs %s)");
return LoadToPointer(object, classElement.m_typeId, value, context);
return LoadToPointer(object, classElement.m_typeId, value, UseTypeDeserializer::Yes, context);
}
else
{
return Load(object, classElement.m_typeId, value, false, context);
return Load(object, classElement.m_typeId, value, false, UseTypeDeserializer::Yes, context);
}
}
Code/Framework/AzCore/AzCore/Serialization/Json/JsonDeserializer.h
+8 -2
View File
@@ -28,6 +28,11 @@ namespace AZ
FullyProcessed,
ContinueProcessing
};
enum class UseTypeDeserializer : bool
{
No,
Yes
};
enum class TypeIdDetermination : u8
{
ExplicitTypeId, // Type id was explicitly defined using "$type".
@@ -55,10 +60,11 @@ namespace AZ
JsonDeserializer(JsonDeserializer&& rhs) = delete;
static JsonSerializationResult::ResultCode Load(
void* object, const Uuid& typeId, const rapidjson::Value& value, bool isNewInstance, JsonDeserializerContext& context);
void* object, const Uuid& typeId, const rapidjson::Value& value, bool isNewInstance, UseTypeDeserializer useCustom,
JsonDeserializerContext& context);
static JsonSerializationResult::ResultCode LoadToPointer(void* object, const Uuid& typeId, const rapidjson::Value& value,
JsonDeserializerContext& context);
UseTypeDeserializer useCustom, JsonDeserializerContext& context);
static JsonSerializationResult::ResultCode LoadWithClassElement(void* object, const rapidjson::Value& value,
const SerializeContext::ClassElement& classElement, JsonDeserializerContext& context);
Code/Framework/AzCore/AzCore/Serialization/Json/JsonSerialization.cpp
+2 -2
View File
@@ -245,7 +245,7 @@ namespace AZ
{
StackedString path(StackedString::Format::JsonPointer);
JsonDeserializerContext context(settings);
result = JsonDeserializer::Load(object, objectType, root, false, context);
result = JsonDeserializer::Load(object, objectType, root, false, JsonDeserializer::UseTypeDeserializer::Yes, context);
}
return result;
}
@@ -322,7 +322,7 @@ namespace AZ
JsonSerializerContext context(settings, allocator);
StackedString path(StackedString::Format::ContextPath);
result = JsonSerializer::Store(output, object, defaultObject, objectType, context);
result = JsonSerializer::Store(output, object, defaultObject, objectType, JsonSerializer::UseTypeSerializer::Yes, context);
}
return result;
}
Code/Framework/AzCore/AzCore/Serialization/Json/JsonSerializer.cpp
+16 -13
View File
@@ -20,7 +20,7 @@
namespace AZ
{
JsonSerializationResult::ResultCode JsonSerializer::Store(rapidjson::Value& output, const void* object, const void* defaultObject,
const Uuid& typeId, JsonSerializerContext& context)
const Uuid& typeId, UseTypeSerializer custom, JsonSerializerContext& context)
{
using namespace JsonSerializationResult;
@@ -32,8 +32,8 @@ namespace AZ
// First check if there's a generic serializer registered for this. This makes it possible to use serializers that
// are not (directly) registered with the Serialize Context.
auto serializer = context.GetRegistrationContext()->GetSerializerForType(typeId);
if (serializer)
if (BaseJsonSerializer* serializer
= (custom == UseTypeSerializer::Yes ? context.GetRegistrationContext()->GetSerializerForType(typeId) : nullptr))
{
// Start by setting the object to be an explicit default.
output.SetObject();
@@ -57,17 +57,18 @@ namespace AZ
"No factory available to create a default object for comparison.");
}
void* defaultObjectPtr = AZStd::any_cast<void>(&defaultObjectInstance);
ResultCode conversionResult = StoreWithClassData(output, object, defaultObjectPtr, *classData, StoreTypeId::No, context);
ResultCode conversionResult = StoreWithClassData(output, object, defaultObjectPtr, *classData, StoreTypeId::No
, UseTypeSerializer::Yes, context);
return ResultCode::Combine(result, conversionResult);
}
else
{
return StoreWithClassData(output, object, defaultObject, *classData, StoreTypeId::No, context);
return StoreWithClassData(output, object, defaultObject, *classData, StoreTypeId::No, custom, context);
}
}
JsonSerializationResult::ResultCode JsonSerializer::StoreFromPointer(rapidjson::Value& output, const void* object,
const void* defaultObject, const Uuid& typeId, JsonSerializerContext& context)
const void* defaultObject, const Uuid& typeId, UseTypeSerializer custom, JsonSerializerContext& context)
{
using namespace JsonSerializationResult;
@@ -85,19 +86,21 @@ namespace AZ
AZ_Assert(classData->m_azRtti->GetTypeId() == typeId, "Type id mismatch in '%s' during serialization to a json file. (%s vs %s)",
classData->m_name, classData->m_azRtti->GetTypeId().ToString<AZStd::string>().c_str(), typeId.ToString<AZStd::string>().c_str());
return StoreWithClassDataFromPointer(output, object, defaultObject, *classData, context);
return StoreWithClassDataFromPointer(output, object, defaultObject, *classData, custom, context);
}
JsonSerializationResult::ResultCode JsonSerializer::StoreWithClassData(rapidjson::Value& node, const void* object,
const void* defaultObject, const SerializeContext::ClassData& classData, StoreTypeId storeTypeId,
JsonSerializerContext& context)
UseTypeSerializer custom, JsonSerializerContext& context)
{
using namespace JsonSerializationResult;
// Start by setting the object to be an explicit default.
node.SetObject();
auto serializer = context.GetRegistrationContext()->GetSerializerForType(classData.m_typeId);
auto serializer = custom == UseTypeSerializer::Yes
? context.GetRegistrationContext()->GetSerializerForType(classData.m_typeId) : nullptr;
if (serializer)
{
ResultCode result = serializer->Store(node, object, defaultObject, classData.m_typeId, context);
@@ -153,7 +156,7 @@ namespace AZ
}
JsonSerializationResult::ResultCode JsonSerializer::StoreWithClassDataFromPointer(rapidjson::Value& output, const void* object,
const void* defaultObject, const SerializeContext::ClassData& classData, JsonSerializerContext& context)
const void* defaultObject, const SerializeContext::ClassData& classData, UseTypeSerializer custom, JsonSerializerContext& context)
{
using namespace JsonSerializationResult;
@@ -176,7 +179,7 @@ namespace AZ
}
else
{
return StoreWithClassData(output, object, defaultObject, *resolvedClassData, storeTypeId, context);
return StoreWithClassData(output, object, defaultObject, *resolvedClassData, storeTypeId, custom, context);
}
}
@@ -221,8 +224,8 @@ namespace AZ
{
rapidjson::Value value;
ResultCode result = classElement.m_flags & SerializeContext::ClassElement::FLG_POINTER ?
StoreWithClassDataFromPointer(value, object, defaultObject, *elementClassData, context):
StoreWithClassData(value, object, defaultObject, *elementClassData, StoreTypeId::No, context);
StoreWithClassDataFromPointer(value, object, defaultObject, *elementClassData, UseTypeSerializer::Yes, context):
StoreWithClassData(value, object, defaultObject, *elementClassData, StoreTypeId::No, UseTypeSerializer::Yes, context);
if (result.GetProcessing() != Processing::Halted)
{
if (parentNode.IsObject())
Code/Framework/AzCore/AzCore/Serialization/Json/JsonSerializer.h
+11 -4
View File
@@ -26,6 +26,11 @@ namespace AZ
No,
Yes
};
enum class UseTypeSerializer : bool
{
No,
Yes
};
enum class ResolvePointerResult
{
FullyProcessed,
@@ -41,16 +46,18 @@ namespace AZ
JsonSerializer(JsonSerializer&& rhs) = delete;
static JsonSerializationResult::ResultCode Store(rapidjson::Value& output, const void* object, const void* defaultObject,
const Uuid& typeId, JsonSerializerContext& context);
const Uuid& typeId, UseTypeSerializer useCustom, JsonSerializerContext& context);
static JsonSerializationResult::ResultCode StoreFromPointer(rapidjson::Value& output, const void* object, const void* defaultObject,
const Uuid& typeId, JsonSerializerContext& context);
const Uuid& typeId, UseTypeSerializer custom, JsonSerializerContext& context);
static JsonSerializationResult::ResultCode StoreWithClassData(rapidjson::Value& node, const void* object, const void* defaultObject,
const SerializeContext::ClassData& classData, StoreTypeId storeTypeId, JsonSerializerContext& context);
const SerializeContext::ClassData& classData, StoreTypeId storeTypeId, UseTypeSerializer custom,
JsonSerializerContext& context);
static JsonSerializationResult::ResultCode StoreWithClassDataFromPointer(rapidjson::Value& output, const void* object,
const void* defaultObject, const SerializeContext::ClassData& classData, JsonSerializerContext& context);
const void* defaultObject, const SerializeContext::ClassData& classData, UseTypeSerializer custom,
JsonSerializerContext& context);
static JsonSerializationResult::ResultCode StoreWithClassElement(rapidjson::Value& parentNode, const void* object,
const void* defaultObject, const SerializeContext::ClassElement& classElement, JsonSerializerContext& context);
Code/Framework/AtomCore/AtomCore/Serialization/Json/JsonUtils.cpp → Code/Framework/AzCore/AzCore/Serialization/Json/JsonUtils.cpp
+9 -3
View File
@@ -6,7 +6,6 @@
*
*/
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Utils/Utils.h>
#include <AzCore/base.h>
#include <AzCore/Component/ComponentApplicationBus.h>
@@ -23,6 +22,8 @@
#include <AzCore/Serialization/Utils.h>
#include <AzCore/Utils/Utils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
{
namespace JsonSerializationUtils
@@ -332,6 +333,11 @@ namespace AZ
// validate class name
auto classData = loadSettings.m_serializeContext->FindClassData(classId);
if (!classData)
{
return AZ::Failure(AZStd::string::format("Try to load class from Id %s", classId.ToString<AZStd::string>().c_str()));
}
if (azstricmp(classData->m_name, className) != 0)
{
return AZ::Failure(AZStd::string::format("Try to load class %s from class %s data", classData->m_name, className));
@@ -343,9 +349,9 @@ namespace AZ
{
return AZ::Failure(deserializeErrors);
}
return AZ::Success();
}
}
AZ::Outcome<AZStd::any, AZStd::string> LoadAnyObjectFromStream(IO::GenericStream& stream, const JsonDeserializerSettings* settings)
{
Code/Framework/AtomCore/AtomCore/Serialization/Json/JsonUtils.h → Code/Framework/AzCore/AzCore/Serialization/Json/JsonUtils.h
View File
Code/Framework/AzCore/AzCore/azcore_files.cmake
+2
View File
@@ -531,6 +531,8 @@ set(FILES
Serialization/Json/JsonStringConversionUtils.h
Serialization/Json/JsonSystemComponent.h
Serialization/Json/JsonSystemComponent.cpp
Serialization/Json/JsonUtils.h
Serialization/Json/JsonUtils.cpp
Serialization/Json/MapSerializer.h
Serialization/Json/MapSerializer.cpp
Serialization/Json/RegistrationContext.h
Code/Framework/AtomCore/Tests/JsonSerializationUtilsTests.cpp → Code/Framework/AzCore/Tests/Serialization/Json/JsonSerializationUtilsTests.cpp
+1 -1
View File
@@ -13,7 +13,7 @@
#include <AzTest/AzTest.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace UnitTest
{
Code/Framework/AzCore/Tests/azcoretests_files.cmake
+1
View File
@@ -104,6 +104,7 @@ set(FILES
Serialization/Json/JsonSerializationResultTests.cpp
Serialization/Json/JsonSerializationTests.h
Serialization/Json/JsonSerializationTests.cpp
Serialization/Json/JsonSerializationUtilsTests.cpp
Serialization/Json/JsonSerializerConformityTests.h
Serialization/Json/JsonSerializerMock.h
Serialization/Json/MapSerializerTests.cpp
Gems/Atom/Asset/ImageProcessingAtom/Code/Source/BuilderSettings/BuilderSettingManager.cpp
+1 -1
View File
@@ -37,7 +37,7 @@
#include <AzFramework/Application/Application.h>
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace ImageProcessingAtom
{
Gems/Atom/Asset/Shader/Code/Source/Editor/AtomShaderConfig.cpp
+1 -1
View File
@@ -12,7 +12,7 @@
#include <AzFramework/StringFunc/StringFunc.h>
#include <AzFramework/Platform/PlatformDefaults.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
Gems/Atom/Asset/Shader/Code/Source/Editor/AzslCompiler.cpp
+1 -1
View File
@@ -19,7 +19,7 @@
#include <Atom/RPI.Reflect/Shader/ShaderOptionGroupLayout.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzFramework/IO/LocalFileIO.h>
#include <AzFramework/IO/FileOperations.h> // [GFX TODO] Remove when [ATOM-15472]
Gems/Atom/Asset/Shader/Code/Source/Editor/CommonFiles/GlobalBuildOptions.cpp
+1 -1
View File
@@ -14,7 +14,7 @@
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
{
Gems/Atom/Asset/Shader/Code/Source/Editor/CommonFiles/Preprocessor.cpp
+1 -1
View File
@@ -24,7 +24,7 @@
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
{
Gems/Atom/Asset/Shader/Code/Source/Editor/PrecompiledShaderBuilder.cpp
+1 -1
View File
@@ -11,7 +11,7 @@
#include <AzFramework/IO/LocalFileIO.h>
#include <AzFramework/StringFunc/StringFunc.h>
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RHI.Edit/ShaderPlatformInterface.h>
#include <Atom/RPI.Edit/Common/AssetUtils.h>
#include <Atom/RPI.Reflect/Asset/AssetReference.h>
Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderAssetBuilder.cpp
+1 -1
View File
@@ -24,7 +24,7 @@
#include <Atom/RHI.Reflect/PipelineLayoutDescriptor.h>
#include <Atom/RHI.Reflect/ShaderStageFunction.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AzToolsFramework/Debug/TraceContext.h>
Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp
+1 -1
View File
@@ -21,7 +21,7 @@
#include <AzCore/IO/FileIO.h>
#include <AzCore/Settings/SettingsRegistryMergeUtils.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Edit/Common/JsonReportingHelper.h>
#include <Atom/RPI.Edit/Common/AssetUtils.h>
Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderVariantAssetBuilder.cpp
+1 -1
View File
@@ -18,7 +18,7 @@
#include <Atom/RPI.Edit/Shader/ShaderVariantTreeAssetCreator.h>
#include <Atom/RPI.Edit/Common/JsonUtils.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Reflect/Shader/ShaderVariantKey.h>
#include <Atom/RHI.Edit/Utils.h>
Gems/Atom/Feature/Common/Code/Source/FrameCaptureSystemComponent.cpp
+1 -1
View File
@@ -17,7 +17,7 @@
#include <Atom/Utils/DdsFile.h>
#include <Atom/Utils/PpmFile.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Jobs/JobFunction.h>
#include <AzCore/Jobs/JobCompletion.h>
Gems/Atom/Feature/Common/Code/Source/ProfilingCaptureSystemComponent.cpp
+1 -1
View File
@@ -20,7 +20,7 @@
#include <Atom/RPI.Public/Pass/Pass.h>
#include <Atom/RPI.Public/Pass/PassFilter.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/IO/SystemFile.h>
#include <AzCore/RTTI/BehaviorContext.h>
Gems/Atom/RHI/Code/Source/RHI.Edit/Utils.cpp
+1 -1
View File
@@ -8,7 +8,7 @@
#include <Atom/RHI.Edit/Utils.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzFramework/Process/ProcessCommunicator.h>
#include <AzFramework/Process/ProcessWatcher.h>
Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Common/JsonUtils.h
+2 -3
View File
@@ -10,9 +10,7 @@
#include <AzCore/JSON/document.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
#include <Atom/RPI.Edit/Common/JsonReportingHelper.h>
@@ -120,6 +118,7 @@ namespace AZ
AZ_Error("AZ::RPI::JsonUtils", false, "Failed to load object from json string: %s", loadResult.GetError().c_str());
return false;
}
} // namespace JsonUtils
} // namespace RPI
} // namespace AZ
Gems/Atom/RPI/Code/Source/RPI.Builders/Common/AnyAssetBuilder.cpp
+1 -1
View File
@@ -19,7 +19,7 @@
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Edit/Common/ConvertibleSource.h>
#include <Atom/RPI.Reflect/System/AnyAsset.h>
Gems/Atom/RPI/Code/Source/RPI.Builders/Material/MaterialBuilder.cpp
+1 -1
View File
@@ -13,7 +13,7 @@
#include <Atom/RPI.Edit/Common/AssetUtils.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
#include <Atom/RPI.Edit/Common/JsonReportingHelper.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
#include <Atom/RPI.Reflect/Material/MaterialAssetCreator.h>
Gems/Atom/RPI/Code/Source/RPI.Builders/Pass/PassBuilder.cpp
+1 -1
View File
@@ -11,7 +11,7 @@
#include <AzCore/Asset/AssetManagerBus.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Reflect/Asset/AssetReference.h>
#include <Atom/RPI.Reflect/Pass/PassAsset.h>
Gems/Atom/RPI/Code/Source/RPI.Builders/ResourcePool/ResourcePoolBuilder.cpp
+1 -1
View File
@@ -16,7 +16,7 @@
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RHI.Reflect/BufferPoolDescriptor.h>
#include <Atom/RHI.Reflect/ImagePoolDescriptor.h>
Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialFunctorSourceDataSerializer.cpp
+1 -1
View File
@@ -11,7 +11,7 @@
#include <Atom/RPI.Edit/Common/AssetUtils.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
#include <Atom/RPI.Edit/Material/MaterialFunctorSourceDataRegistration.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/Json/JsonSerializationResult.h>
Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialPropertyValueSerializer.cpp
+1 -1
View File
@@ -21,7 +21,7 @@
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/Json/StackedString.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
{
Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialSourceData.cpp
+1 -1
View File
@@ -22,7 +22,7 @@
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
#include <Atom/RPI.Public/Image/StreamingImage.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialSourceDataSerializer.cpp
+1 -1
View File
@@ -10,7 +10,7 @@
#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
#include <Atom/RPI.Edit/Common/AssetUtils.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/Json/JsonSerializationResult.h>
Gems/Atom/RPI/Code/Source/RPI.Edit/Material/MaterialUtils.cpp
+1 -1
View File
@@ -15,7 +15,7 @@
#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
#include <Atom/RPI.Edit/Common/JsonReportingHelper.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/std/string/string.h>
Gems/Atom/RPI/Code/Source/RPI.Public/Pass/AttachmentReadback.cpp
+1 -1
View File
@@ -23,7 +23,7 @@
#include <Atom/RHI/RHISystemInterface.h>
#include <Atom/RHI/ScopeProducerFunction.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/std/smart_ptr/make_shared.h>
Gems/Atom/RPI/Code/Source/RPI.Public/Pass/PassSystem.cpp
+1 -1
View File
@@ -17,7 +17,7 @@
#include <AzCore/std/sort.h>
#include <AzCore/Interface/Interface.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RHI/CpuProfiler.h>
#include <Atom/RHI/FrameGraphBuilder.h>
Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetrics.cpp
+1 -1
View File
@@ -6,7 +6,7 @@
*
*/
#include <Atom/RPI.Public/Shader/Metrics/ShaderMetrics.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
namespace AZ
{
Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp
+1 -1
View File
@@ -15,7 +15,7 @@
#include <AzCore/IO/SystemFile.h>
#include <AzCore/Utils//Utils.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzFramework/IO/LocalFileIO.h>
Gems/Atom/RPI/Code/Tests.Builders/AnyAssetBuilderTest.cpp
+1 -1
View File
@@ -13,7 +13,7 @@
#include <AzCore/Serialization/Utils.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Edit/Common/ConvertibleSource.h>
#include <Atom/RPI.Reflect/System/AnyAsset.h>
Gems/Atom/RPI/Code/Tests.Builders/PassBuilderTest.cpp
+1 -1
View File
@@ -16,7 +16,7 @@
#include <AzCore/Serialization/Utils.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RHI.Reflect/ReflectSystemComponent.h>
Gems/Atom/RPI/Code/Tests.Builders/ResourcePoolBuilderTest.cpp
+1 -1
View File
@@ -8,7 +8,7 @@
#include <AzTest/AzTest.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RHI.Reflect/BufferPoolDescriptor.h>
#include <Atom/RHI.Reflect/ImagePoolDescriptor.h>
Gems/Atom/RPI/Code/Tests/Common/JsonTestUtils.h
+1 -1
View File
@@ -15,7 +15,7 @@
#include <AzCore/IO/TextStreamWriters.h>
#include <AzCore/IO/ByteContainerStream.h>
#include <AzCore/JSON/prettywriter.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
namespace UnitTest
Gems/Atom/RPI/Code/Tests/Material/MaterialFunctorTests.cpp
-1
View File
@@ -19,7 +19,6 @@
#include <Atom/RPI.Public/Material/Material.h>
#include <Material/MaterialAssetTestUtils.h>
//#include <AtomCore/Serialization/Json/JsonUtils.h>
namespace UnitTest
{
using namespace AZ;
Gems/Atom/RPI/Code/Tests/Material/MaterialPropertySerializerTests.cpp
+1 -1
View File
@@ -11,7 +11,7 @@
#include <Common/JsonTestUtils.h>
#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
#include <Atom/RPI.Edit/Material/MaterialPropertySerializer.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Common/TestUtils.h>
#include <Tests/Serialization/Json/JsonSerializerConformityTests.h>
Gems/Atom/RPI/Code/Tests/Material/MaterialTypeSourceDataTests.cpp
+1 -1
View File
@@ -20,7 +20,7 @@
#include <Atom/RPI.Public/Shader/ShaderResourceGroup.h>
#include <Atom/RPI.Public/Material/Material.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzFramework/StringFunc/StringFunc.h>
Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportComponent.cpp
+1 -1
View File
@@ -25,7 +25,7 @@
#include <Atom/ImageProcessing/ImageObject.h>
#include <Atom/ImageProcessing/ImageProcessingBus.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Atom/RPI.Reflect/Asset/AssetUtils.h>
#include <Atom/RPI.Reflect/System/AnyAsset.h>
Gems/AtomLyIntegration/AtomBridge/Code/Source/Editor/AssetCollectionAsyncLoaderTestComponent.cpp
+1 -1
View File
@@ -13,7 +13,7 @@
#include <AzFramework/StringFunc/StringFunc.h>
#include <AtomCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
// Included so we can deduce the asset type from asset paths.
#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
Gems/ExpressionEvaluation/Code/Include/ExpressionEvaluation/ExpressionEngine/ExpressionTree.h
+19 -12
View File
@@ -11,6 +11,11 @@
#include <ExpressionEvaluation/ExpressionEngine/ExpressionTypes.h>
namespace AZ
{
class ExpressionTreeVariableDescriptorSerializer;
}
namespace ExpressionEvaluation
{
// Holds all of the tokeniszed information from parsing an expression string.
@@ -20,8 +25,22 @@ namespace ExpressionEvaluation
{
// Friend class for reflection
friend class ExpressionEvaluationSystemComponent;
friend class ExpressionTreeVariableDescriptorSerializer;
public:
struct VariableDescriptor
{
AZ_TYPE_INFO(VariableDescriptor, "{5E1A0044-E0E7-46D3-8BC6-A22E226ADB83}");
VariableDescriptor()
{
m_supportedTypes.push_back(azrtti_typeid<double>());
}
AZStd::vector< AZ::Uuid > m_supportedTypes;
ExpressionVariable m_value;
};
AZ_RTTI(ExpressionTree, "{4CCF3DFD-2EA8-47CB-AF25-353BC034EF42}");
AZ_CLASS_ALLOCATOR(ExpressionTree, AZ::SystemAllocator, 0);
@@ -147,18 +166,6 @@ namespace ExpressionEvaluation
private:
struct VariableDescriptor
{
AZ_TYPE_INFO(VariableDescriptor, "{5E1A0044-E0E7-46D3-8BC6-A22E226ADB83}");
VariableDescriptor()
{
m_supportedTypes.push_back(azrtti_typeid<double>());
}
AZStd::vector< AZ::Uuid > m_supportedTypes;
ExpressionVariable m_value;
};
AZStd::unordered_map< AZ::Crc32, VariableDescriptor > m_variables;
Gems/ExpressionEvaluation/Code/Source/ElementInformationSerializer.inl
+181
View File
@@ -0,0 +1,181 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/Memory/Memory.h>
#include <AzCore/Serialization/AZStdAnyDataContainer.inl>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <ExpressionEvaluation/ExpressionEngine/ExpressionTypes.h>
namespace AZ
{
class ElementInformationSerializer
: public BaseJsonSerializer
{
public:
AZ_RTTI(ElementInformationSerializer, "{B33E6AA9-C700-4E3D-857C-55F362AFE57A}", BaseJsonSerializer);
AZ_CLASS_ALLOCATOR_DECL;
private:
using ElementInformation = ExpressionEvaluation::ElementInformation;
static const char* EmptyAnyIdentifier;
static bool IsEmptyAny(const rapidjson::Value& typeId)
{
if (typeId.IsString())
{
AZStd::string_view typeName(typeId.GetString(), typeId.GetStringLength());
return typeName == EmptyAnyIdentifier;
}
return false;
}
JsonSerializationResult::Result Load
( void* outputValue
, const Uuid& outputValueTypeId
, const rapidjson::Value& inputValue
, JsonDeserializerContext& context) override
{
namespace JSR = JsonSerializationResult;
AZ_Assert(outputValueTypeId == azrtti_typeid<ElementInformation>(), "ElementInformationSerializer Load against "
"output typeID that was not ElementInformation");
AZ_Assert(outputValue, "ElementInformationSerializer Load against null output");
JsonSerializationResult::ResultCode result(JSR::Tasks::ReadField);
auto outputDatum = reinterpret_cast<ElementInformation*>(outputValue);
result.Combine(ContinueLoadingFromJsonObjectField
( &outputDatum->m_id
, azrtti_typeid<decltype(outputDatum->m_id)>()
, inputValue
, "Id"
, context));
// any storage begin
{
AZ::Uuid typeId = AZ::Uuid::CreateNull();
auto typeIdMember = inputValue.FindMember(JsonSerialization::TypeIdFieldIdentifier);
if (typeIdMember == inputValue.MemberEnd())
{
return context.Report
( JSR::Tasks::ReadField
, JSR::Outcomes::Missing
, AZStd::string::format("ElementInformationSerializer::Load failed to load the %s member"
, JsonSerialization::TypeIdFieldIdentifier));
}
if (!IsEmptyAny(typeIdMember->value))
{
result.Combine(LoadTypeId(typeId, typeIdMember->value, context));
if (typeId.IsNull())
{
return context.Report(JSR::Tasks::ReadField, JSR::Outcomes::Catastrophic
, "ElementInformationSerializer::Load failed to load the AZ TypeId of the value");
}
AZStd::any storage = context.GetSerializeContext()->CreateAny(typeId);
if (storage.empty() || storage.type() != typeId)
{
return context.Report(result, "ElementInformationSerializer::Load failed to load a value matched the "
"reported AZ TypeId. The C++ declaration may have been deleted or changed.");
}
result.Combine
( ContinueLoadingFromJsonObjectField(AZStd::any_cast<void>(&storage), typeId, inputValue, "Value", context));
outputDatum->m_extraStore = storage;
}
}
// any storage end
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "ElementInformationSerializer Load finished loading ElementInformation"
: "ElementInformationSerializer Load failed to load ElementInformation");
}
JsonSerializationResult::Result Store
( rapidjson::Value& outputValue
, const void* inputValue
, const void* defaultValue
, const Uuid& valueTypeId, JsonSerializerContext& context) override
{
namespace JSR = JsonSerializationResult;
AZ_Assert(valueTypeId == azrtti_typeid<ElementInformation>(), "ElementInformation Store against value typeID that "
"was not ElementInformation");
AZ_Assert(inputValue, "ElementInformation Store against null inputValue pointer ");
auto inputScriptDataPtr = reinterpret_cast<const ElementInformation*>(inputValue);
auto defaultScriptDataPtr = reinterpret_cast<const ElementInformation*>(defaultValue);
if (defaultScriptDataPtr)
{
if (inputScriptDataPtr->m_id == defaultScriptDataPtr->m_id
&& AZ::Helpers::CompareAnyValue(inputScriptDataPtr->m_extraStore, defaultScriptDataPtr->m_extraStore))
{
return context.Report
( JSR::Tasks::WriteValue, JSR::Outcomes::DefaultsUsed, "ElementInformation Store used defaults for "
"ElementInformation");
}
}
JSR::ResultCode result(JSR::Tasks::WriteValue);
outputValue.SetObject();
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "Id"
, &inputScriptDataPtr->m_id
, defaultScriptDataPtr ? &defaultScriptDataPtr->m_id : nullptr
, azrtti_typeid<decltype(inputScriptDataPtr->m_id)>()
, context));
if (!inputScriptDataPtr->m_extraStore.empty())
{
rapidjson::Value typeValue;
result.Combine(StoreTypeId(typeValue, inputScriptDataPtr->m_extraStore.type(), context));
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(typeValue)
, context.GetJsonAllocator());
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "Value"
, AZStd::any_cast<void>(const_cast<AZStd::any*>(&inputScriptDataPtr->m_extraStore))
, defaultScriptDataPtr ? AZStd::any_cast<void>(const_cast<AZStd::any*>(&defaultScriptDataPtr->m_extraStore)) : nullptr
, inputScriptDataPtr->m_extraStore.type()
, context));
}
else
{
rapidjson::Value emptyAny;
AZStd::string emptyAnyName(EmptyAnyIdentifier);
emptyAny.SetString(emptyAnyName.c_str(), aznumeric_caster(emptyAnyName.size()), context.GetJsonAllocator());
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(emptyAny)
, context.GetJsonAllocator());
}
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "ElementInformation Store finished saving ElementInformation"
: "ElementInformation Store failed to save ElementInformation");
}
};
AZ_CLASS_ALLOCATOR_IMPL(ElementInformationSerializer, SystemAllocator, 0);
const char* ElementInformationSerializer::EmptyAnyIdentifier = "Empty AZStd::any";
}
Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
+11 -4
View File
@@ -6,16 +6,17 @@
*
*/
#include <ExpressionEvaluationSystemComponent.h>
#include <AzCore/Debug/Profiler.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/Serialization/EditContextConstants.inl>
#include <AzCore/Serialization/Json/RegistrationContext.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <ExpressionEngine/InternalTypes.h>
#include <ExpressionEngine/MathOperators/MathExpressionOperators.h>
#include <ExpressionEngine/Utils.h>
#include <ExpressionEvaluationSystemComponent.h>
#include <ExpressionPrimitivesSerializers.inl>
#include <ElementInformationSerializer.inl>
namespace ExpressionEvaluation
{
@@ -146,6 +147,12 @@ namespace ExpressionEvaluation
;
}
}
if (AZ::JsonRegistrationContext* jsonContext = azrtti_cast<AZ::JsonRegistrationContext*>(context))
{
jsonContext->Serializer<AZ::ExpressionTreeVariableDescriptorSerializer>()->HandlesType<ExpressionTree::VariableDescriptor>();
jsonContext->Serializer<AZ::ElementInformationSerializer>()->HandlesType<ElementInformation>();
}
}
void ExpressionEvaluationSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
Gems/ExpressionEvaluation/Code/Source/ExpressionPrimitivesSerializers.inl
+147
View File
@@ -0,0 +1,147 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/Memory/Memory.h>
#include <AzCore/Serialization/AZStdAnyDataContainer.inl>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <ExpressionEvaluation/ExpressionEngine/ExpressionTree.h>
namespace AZ
{
class ExpressionTreeVariableDescriptorSerializer
: public BaseJsonSerializer
{
public:
AZ_RTTI(ExpressionTreeVariableDescriptorSerializer, "{5EFF37D6-BD54-45C6-9FC6-B1E0D3A8204C}", BaseJsonSerializer);
AZ_CLASS_ALLOCATOR_DECL;
private:
using VariableDescriptor = ExpressionEvaluation::ExpressionTree::VariableDescriptor;
JsonSerializationResult::Result Load
( void* outputValue
, const Uuid& outputValueTypeId
, const rapidjson::Value& inputValue
, JsonDeserializerContext& context) override
{
namespace JSR = JsonSerializationResult;
AZ_Assert(outputValueTypeId == azrtti_typeid<VariableDescriptor>(), "ExpressionTreeVariableDescriptorSerializer Load against "
"output typeID that was not VariableDescriptor");
AZ_Assert(outputValue, "ExpressionTreeVariableDescriptorSerializer Load against null output");
JsonSerializationResult::ResultCode result(JSR::Tasks::ReadField);
auto outputDatum = reinterpret_cast<VariableDescriptor*>(outputValue);
result.Combine(ContinueLoadingFromJsonObjectField
( &outputDatum->m_supportedTypes
, azrtti_typeid<decltype(outputDatum->m_supportedTypes)>()
, inputValue
, "SupportedTypes"
, context));
// any storage begin
AZ::Uuid typeId = AZ::Uuid::CreateNull();
auto typeIdMember = inputValue.FindMember(JsonSerialization::TypeIdFieldIdentifier);
if (typeIdMember == inputValue.MemberEnd())
{
return context.Report
( JSR::Tasks::ReadField
, JSR::Outcomes::Missing
, AZStd::string::format("ExpressionTreeVariableDescriptorSerializer::Load failed to load the %s member"
, JsonSerialization::TypeIdFieldIdentifier));
}
result.Combine(LoadTypeId(typeId, typeIdMember->value, context));
if (typeId.IsNull())
{
return context.Report(JSR::Tasks::ReadField, JSR::Outcomes::Catastrophic
, "ExpressionTreeVariableDescriptorSerializer::Load failed to load the AZ TypeId of the value");
}
AZStd::any storage = context.GetSerializeContext()->CreateAny(typeId);
if (storage.empty() || storage.type() != typeId)
{
return context.Report(result, "ExpressionTreeVariableDescriptorSerializer::Load failed to load a value matched the "
"reported AZ TypeId. The C++ declaration may have been deleted or changed.");
}
result.Combine(ContinueLoadingFromJsonObjectField(AZStd::any_cast<void>(&storage), typeId, inputValue, "Value", context));
outputDatum->m_value = storage;
// any storage end
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "ExpressionTreeVariableDescriptorSerializer Load finished loading VariableDescriptor"
: "ExpressionTreeVariableDescriptorSerializer Load failed to load VariableDescriptor");
}
JsonSerializationResult::Result Store
( rapidjson::Value& outputValue
, const void* inputValue
, const void* defaultValue
, const Uuid& valueTypeId, JsonSerializerContext& context) override
{
namespace JSR = JsonSerializationResult;
AZ_Assert(valueTypeId == azrtti_typeid<VariableDescriptor>(), "VariableDescriptor Store against value typeID that "
"was not VariableDescriptor");
AZ_Assert(inputValue, "VariableDescriptor Store against null inputValue pointer ");
auto inputScriptDataPtr = reinterpret_cast<const VariableDescriptor*>(inputValue);
auto defaultScriptDataPtr = reinterpret_cast<const VariableDescriptor*>(defaultValue);
if (defaultScriptDataPtr)
{
if (inputScriptDataPtr->m_supportedTypes == defaultScriptDataPtr->m_supportedTypes
&& AZ::Helpers::CompareAnyValue(inputScriptDataPtr->m_value, defaultScriptDataPtr->m_value))
{
return context.Report
( JSR::Tasks::WriteValue, JSR::Outcomes::DefaultsUsed, "VariableDescriptor Store used defaults for "
"VariableDescriptor");
}
}
JSR::ResultCode result(JSR::Tasks::WriteValue);
outputValue.SetObject();
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "SupportedTypes"
, &inputScriptDataPtr->m_supportedTypes
, defaultScriptDataPtr ? &defaultScriptDataPtr->m_supportedTypes : nullptr
, azrtti_typeid<decltype(inputScriptDataPtr->m_supportedTypes)>()
, context));
rapidjson::Value typeValue;
result.Combine(StoreTypeId(typeValue, inputScriptDataPtr->m_value.type(), context));
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(typeValue)
, context.GetJsonAllocator());
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "Value"
, AZStd::any_cast<void>(const_cast<AZStd::any*>(&inputScriptDataPtr->m_value))
, defaultScriptDataPtr ? AZStd::any_cast<void>(const_cast<AZStd::any*>(&defaultScriptDataPtr->m_value)) : nullptr
, inputScriptDataPtr->m_value.type()
, context));
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "VariableDescriptor Store finished saving VariableDescriptor"
: "VariableDescriptor Store failed to save VariableDescriptor");
}
};
AZ_CLASS_ALLOCATOR_IMPL(ExpressionTreeVariableDescriptorSerializer, SystemAllocator, 0);
}
Gems/ExpressionEvaluation/Code/expressionevaluation_files.cmake
+2
View File
@@ -13,6 +13,8 @@ set(FILES
Include/ExpressionEvaluation/ExpressionEngine/ExpressionTypes.h
Source/ExpressionEvaluationSystemComponent.cpp
Source/ExpressionEvaluationSystemComponent.h
Source/ExpressionPrimitivesSerializers.inl
Source/ElementInformationSerializer.inl
Source/ExpressionEngine/ExpressionElementParser.h
Source/ExpressionEngine/ExpressionPrimitive.cpp
Source/ExpressionEngine/ExpressionPrimitive.h
Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAsset.cpp
+2
View File
@@ -114,11 +114,13 @@ namespace ScriptCanvasEditor
ScriptCanvas::ScriptCanvasData& ScriptCanvasAsset::GetScriptCanvasData()
{
AZ_Assert(m_data != nullptr, "ScriptCanvasData not initialized, it must be created on construction");
return *m_data;
}
const ScriptCanvas::ScriptCanvasData& ScriptCanvasAsset::GetScriptCanvasData() const
{
AZ_Assert(m_data != nullptr, "ScriptCanvasData not initialized, it must be created on construction");
return *m_data;
}
}
Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasAssetHandler.cpp
+144 -71
View File
@@ -6,29 +6,47 @@
*
*/
#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
#include <Core/ScriptCanvasBus.h>
#include <ScriptCanvas/Components/EditorGraph.h>
#include <ScriptCanvas/Components/EditorScriptCanvasComponent.h>
#include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
#include <GraphCanvas/GraphCanvasBus.h>
#include <AzCore/IO/GenericStreams.h>
#include <AzCore/IO/FileIO.h>
#include <AzCore/Serialization/Utils.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Component/ComponentApplicationBus.h>
#include <AzCore/Component/Entity.h>
#include <AzCore/IO/FileIO.h>
#include <AzCore/IO/GenericStreams.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/Json/JsonSerializationResult.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Serialization/Utils.h>
#include <AzCore/std/string/string_view.h>
#include <AzFramework/StringFunc/StringFunc.h>
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <Core/ScriptCanvasBus.h>
#include <GraphCanvas/GraphCanvasBus.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
#include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
#include <ScriptCanvas/Components/EditorGraph.h>
#include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
#include <ScriptCanvas/Components/EditorScriptCanvasComponent.h>
#include <ScriptCanvas/Core/SerializationListener.h>
namespace ScriptCanvasAssetHandlerCpp
{
using namespace ScriptCanvas;
void CollectNodes(const GraphData::NodeContainer& container, SerializationListeners& listeners)
{
for (auto& nodeEntity : container)
{
if (nodeEntity)
{
if (auto listener = azrtti_cast<SerializationListener*>(AZ::EntityUtils::FindFirstDerivedComponent<Node>(nodeEntity)))
{
listeners.push_back(listener);
}
}
}
}
}
namespace ScriptCanvasEditor
{
@@ -75,26 +93,84 @@ namespace ScriptCanvasEditor
}
}
AZ::Data::AssetHandler::LoadResult ScriptCanvasAssetHandler::LoadAssetData(
const AZ::Data::Asset<AZ::Data::AssetData>& asset,
AZStd::shared_ptr<AZ::Data::AssetDataStream> stream,
const AZ::Data::AssetFilterCB& assetLoadFilterCB)
AZ::Data::AssetHandler::LoadResult ScriptCanvasAssetHandler::LoadAssetData
( const AZ::Data::Asset<AZ::Data::AssetData>& assetTarget
, AZStd::shared_ptr<AZ::Data::AssetDataStream> streamSource
, [[maybe_unused]] const AZ::Data::AssetFilterCB& assetLoadFilterCB)
{
auto* scriptCanvasAsset = asset.GetAs<ScriptCanvasAsset>();
AZ_Assert(scriptCanvasAsset, "This should be an scene slice asset, as this is the only type we process!");
if (scriptCanvasAsset && m_serializeContext)
namespace JSRU = AZ::JsonSerializationUtils;
using namespace ScriptCanvas;
auto* scriptCanvasAssetTarget = assetTarget.GetAs<ScriptCanvasAsset>();
AZ_Assert(scriptCanvasAssetTarget, "This should be a ScriptCanvasAsset, as this is the only type we process!");
if (m_serializeContext
&& streamSource
&& scriptCanvasAssetTarget)
{
stream->Seek(0U, AZ::IO::GenericStream::ST_SEEK_BEGIN);
// tolerate unknown classes in the editor. Let the asset processor warn about bad nodes...
bool loadSuccess = AZ::Utils::LoadObjectFromStreamInPlace(*stream, scriptCanvasAsset->GetScriptCanvasData(), m_serializeContext, AZ::ObjectStream::FilterDescriptor(assetLoadFilterCB, AZ::ObjectStream::FILTERFLAG_IGNORE_UNKNOWN_CLASSES));
return loadSuccess ? AZ::Data::AssetHandler::LoadResult::LoadComplete : AZ::Data::AssetHandler::LoadResult::Error;
streamSource->Seek(0U, AZ::IO::GenericStream::ST_SEEK_BEGIN);
auto& scriptCanvasDataTarget = scriptCanvasAssetTarget->GetScriptCanvasData();
AZStd::vector<AZ::u8> byteBuffer;
byteBuffer.resize_no_construct(streamSource->GetLength());
AZ::IO::ByteContainerStream<decltype(byteBuffer)> byteStreamSource(&byteBuffer);
const size_t bytesRead = streamSource->Read(byteBuffer.size(), byteBuffer.data());
scriptCanvasDataTarget.m_scriptCanvasEntity.reset(nullptr);
if (bytesRead == streamSource->GetLength())
{
byteStreamSource.Seek(0U, AZ::IO::GenericStream::ST_SEEK_BEGIN);
AZ::JsonDeserializerSettings settings;
settings.m_serializeContext = m_serializeContext;
settings.m_metadata.Create<SerializationListeners>();
// attempt JSON deserialization...
if (JSRU::LoadObjectFromStreamByType
( &scriptCanvasDataTarget
, azrtti_typeid<ScriptCanvasData>()
, byteStreamSource
, &settings).IsSuccess())
{
if (auto graphData = scriptCanvasAssetTarget->GetScriptCanvasGraph()
? scriptCanvasAssetTarget->GetScriptCanvasGraph()->GetGraphData()
: nullptr)
{
auto listeners = settings.m_metadata.Find<SerializationListeners>();
AZ_Assert(listeners, "Failed to create SerializationListeners");
ScriptCanvasAssetHandlerCpp::CollectNodes(graphData->m_nodes, *listeners);
for (auto listener : *listeners)
{
listener->OnDeserialize();
}
return AZ::Data::AssetHandler::LoadResult::LoadComplete;
}
else
{
AZ_Warning("ScriptCanvas", false, "ScriptCanvasAssetHandler::LoadAssetData failed to load graph data from JOSON");
}
}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
else
{// ...if there is a failure, check if it is saved in the old format
byteStreamSource.Seek(0U, AZ::IO::GenericStream::ST_SEEK_BEGIN);
// tolerate unknown classes in the editor. Let the asset processor warn about bad nodes...
if (AZ::Utils::LoadObjectFromStreamInPlace
(byteStreamSource
, scriptCanvasDataTarget
, m_serializeContext
, AZ::ObjectStream::FilterDescriptor(assetLoadFilterCB, AZ::ObjectStream::FILTERFLAG_IGNORE_UNKNOWN_CLASSES)))
{
return AZ::Data::AssetHandler::LoadResult::LoadComplete;
}
}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
}
}
return AZ::Data::AssetHandler::LoadResult::Error;
}
bool ScriptCanvasAssetHandler::SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream)
{
return SaveAssetData(asset.GetAs<ScriptCanvasAsset>(), stream);
@@ -105,20 +181,42 @@ namespace ScriptCanvasEditor
return SaveAssetData(assetData, stream, AZ::DataStream::ST_XML);
}
bool ScriptCanvasAssetHandler::SaveAssetData(const ScriptCanvasAsset* assetData, AZ::IO::GenericStream* stream, AZ::DataStream::StreamType streamType)
bool ScriptCanvasAssetHandler::SaveAssetData
( const ScriptCanvasAsset* assetData
, AZ::IO::GenericStream* stream
, [[maybe_unused]] AZ::DataStream::StreamType streamType)
{
if (assetData && m_serializeContext)
{
AZStd::vector<char> byteBuffer;
AZ::IO::ByteContainerStream<decltype(byteBuffer)> byteStream(&byteBuffer);
AZ::ObjectStream* objStream = AZ::ObjectStream::Create(&byteStream, *m_serializeContext, streamType);
bool scriptCanvasAssetSaved = objStream->WriteClass(&assetData->GetScriptCanvasData());
objStream->Finalize();
scriptCanvasAssetSaved = stream->Write(byteBuffer.size(), byteBuffer.data()) == byteBuffer.size() && scriptCanvasAssetSaved;
return scriptCanvasAssetSaved;
}
namespace JSRU = AZ::JsonSerializationUtils;
using namespace ScriptCanvas;
return false;
if (m_serializeContext
&& stream
&& assetData
&& assetData->GetScriptCanvasGraph()
&& assetData->GetScriptCanvasGraph()->GetGraphData())
{
auto graphData = assetData->GetScriptCanvasGraph()->GetGraphData();
AZ::JsonSerializerSettings settings;
settings.m_metadata.Create<SerializationListeners>();
auto listeners = settings.m_metadata.Find<SerializationListeners>();
AZ_Assert(listeners, "Failed to create SerializationListeners");
ScriptCanvasAssetHandlerCpp::CollectNodes(graphData->m_nodes, *listeners);
settings.m_keepDefaults = false;
settings.m_serializeContext = m_serializeContext;
for (auto listener : *listeners)
{
listener->OnSerialize();
}
return JSRU::SaveObjectToStream<ScriptCanvasData>(&assetData->GetScriptCanvasData(), *stream, nullptr, &settings).IsSuccess();
}
else
{
AZ_Error("ScriptCanvas", false, "Saving ScriptCavas assets in the handler requires a valid IO stream, "
"asset pointer, and serialize context");
return false;
}
}
void ScriptCanvasAssetHandler::DestroyAsset(AZ::Data::AssetPtr ptr)
@@ -126,17 +224,11 @@ namespace ScriptCanvasEditor
delete ptr;
}
//=========================================================================
// GetSerializeContext
//=========================================================================.
AZ::SerializeContext* ScriptCanvasAssetHandler::GetSerializeContext() const
{
return m_serializeContext;
}
//=========================================================================
// SetSerializeContext
//=========================================================================.
void ScriptCanvasAssetHandler::SetSerializeContext(AZ::SerializeContext* context)
{
m_serializeContext = context;
@@ -147,22 +239,17 @@ namespace ScriptCanvasEditor
EBUS_EVENT_RESULT(m_serializeContext, AZ::ComponentApplicationBus, GetSerializeContext);
if (!m_serializeContext)
{
AZ_Error("Script Canvas", false, "ScriptCanvasAssetHandler: No serialize context provided! We will not be able to process Graph Asset type");
AZ_Error("Script Canvas", false, "ScriptCanvasAssetHandler: No serialize context provided! "
"We will not be able to process Graph Asset type");
}
}
}
//=========================================================================
// GetHandledAssetTypes
//=========================================================================.
void ScriptCanvasAssetHandler::GetHandledAssetTypes(AZStd::vector<AZ::Data::AssetType>& assetTypes)
{
assetTypes.push_back(GetAssetType());
}
//=========================================================================
// GetAssetType
//=========================================================================.
AZ::Data::AssetType ScriptCanvasAssetHandler::GetAssetType() const
{
return ScriptCanvasAssetHandler::GetAssetTypeStatic();
@@ -178,38 +265,24 @@ namespace ScriptCanvasEditor
return azrtti_typeid<ScriptCanvasAsset>();
}
//=========================================================================
// GetAssetTypeExtensions
//=========================================================================.
void ScriptCanvasAssetHandler::GetAssetTypeExtensions(AZStd::vector<AZStd::string>& extensions)
{
ScriptCanvasAsset::Description description;
extensions.push_back(description.GetExtensionImpl());
}
//=========================================================================
// GetComponentTypeId
//=========================================================================.
AZ::Uuid ScriptCanvasAssetHandler::GetComponentTypeId() const
{
return azrtti_typeid<EditorScriptCanvasComponent>();
}
//=========================================================================
// GetGroup
//=========================================================================.
const char* ScriptCanvasAssetHandler::GetGroup() const
{
return ScriptCanvas::AssetDescription::GetGroup<ScriptCanvasEditor::ScriptCanvasAsset>();
}
//=========================================================================
// GetBrowserIcon
//=========================================================================.
const char* ScriptCanvasAssetHandler::GetBrowserIcon() const
{
return ScriptCanvas::AssetDescription::GetIconPath<ScriptCanvasEditor::ScriptCanvasAsset>();
}
}
Gems/ScriptCanvas/Code/Editor/View/Widgets/ValidationPanel/GraphValidationDockWidget.cpp
+1 -1
View File
@@ -734,7 +734,7 @@ namespace ScriptCanvasEditor
{
ui->statusTableView->clearSelection();
if (auto model = GetActiveData().second->GetModel())
if (auto model = GetActiveData().second ? GetActiveData().second->GetModel() : nullptr)
{
model->Clear();
model->RunValidation(m_activeGraphIds.scriptCanvasId);
Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Header.jinja
+2 -4
View File
@@ -43,10 +43,8 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
namespace {{attribute_Namespace}}
{
{% endif %}
{% set className = Class.attrib['Name'] %}
{% set baseClass = Class.attrib['Base'] %}
{% set baseClasses = ", ".join(Class.attrib['Base'].split(';')) if Class.attrib['Base'] is string else "ScriptCanvas::Node" %}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
////
@@ -66,7 +64,7 @@ namespace {{attribute_Namespace}}
// You must #include the generated header into the source header
#define SCRIPTCANVAS_NODE_{{ className }} \
public: \
AZ_COMPONENT({{ className }}, "{{ classUuid }}"{% if baseClass is defined %}, {{ baseClass }}{% endif %}); \
AZ_COMPONENT({{ className }}, "{{ classUuid }}", {{ baseClasses }} ); \
static void Reflect(AZ::ReflectContext* reflection); \
void ConfigureSlots() override; \
bool RequiresDynamicSlotOrdering() const override; \
Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Source.jinja
+8 -8
View File
@@ -4,6 +4,8 @@ For complete copyright and license terms please see the LICENSE at the root of t
SPDX-License-Identifier: Apache-2.0 OR MIT
#}
{% import 'ScriptCanvas_Macros.jinja' as macros %}
{% macro add_attribute(attribute, tags) %}
{% set value = tags[attribute] %}
{% if value is defined %}
@@ -26,7 +28,7 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
#include "{{ xml.attrib['Include'] }}"
{% for Class in xml.iter('Class') %}
{% set baseClass = Class.attrib['Base'].split(';')[0] if Class.attrib['Base'] is string else "ScriptCanvas::Node" %}
{% set attribute_Namespace = undefined %}
{%- if Class.attrib['Namespace'] is defined %}
{% if Class.attrib['Namespace'] != "None" %}
@@ -42,10 +44,8 @@ namespace {{attribute_Namespace}}
void {{ Class.attrib['QualifiedName'] }}::ConfigureSlots()
{
{% if Class.attrib['Base'] is defined %}
{{ Class.attrib['Base'] }}::ConfigureSlots();
{{ baseClass }}::ConfigureSlots();
{% endif %}
{% for Property in Class.iter('Property') %}
{% if Property.attrib['IsInput'] | booleanTrue %}
// {{ Property.attrib['Name'] }}
@@ -208,15 +208,15 @@ void {{ Class.attrib['QualifiedName'] }}::Reflect(AZ::ReflectContext* context)
{% endfor %}
{% endif %}
{% if Class.attrib['Base'] is defined %}
static_assert((std::is_base_of<ScriptCanvas::Node, {{ Class.attrib['Base'] }}>::value), "Script Canvas nodes require the first base class to be derived from ScriptCanvas::Node");
static_assert((std::is_base_of<ScriptCanvas::Node, {{ baseClass }}>::value), "Script Canvas nodes require the first base class to be derived from ScriptCanvas::Node");
{% endif %}
if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
{
serializeContext->Class<{{ Class.attrib['QualifiedName'] }}{% if Class.attrib['Base'] is defined %}, {{ Class.attrib['Base'] }}{% endif %}>()
serializeContext->Class<{{ Class.attrib['QualifiedName'] }}, {{ baseClass }}>()
{% if Class.attrib['EventHandler'] is defined %}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<{{ Class.attrib['EventHandler'] }}>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
{% endif %}
{% if Class.attrib['Version'] is defined %}
->Version({{ Class.attrib['Version'] }}{% if Class.attrib['VersionConverter'] is defined %}, &{{ Class.attrib['VersionConverter'] }}{% endif %})
Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasNodeable_Source.jinja
+2
View File
@@ -160,7 +160,9 @@ void {{attribute_QualifiedName}}::Reflect(AZ::ReflectContext* context)
{
{% if ExtendReflectionSerialize is defined %} auto {{preSerialize}} = {% else %} {% endif %}serializeContext->Class<{{ attribute_Name }}{% if attribute_Base is defined %}, {{ attribute_Base }}{% endif %}>(){{postSerialize}}
{% if attribute_EventHandler is defined %}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
{{preSerialize}}->EventHandler<{{ attribute_EventHandler }}>(){{postSerialize}}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
{% endif %}
{# Serialized Properties #}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvas_Macros.jinja
+1 -2
View File
@@ -173,11 +173,10 @@ AZStd::tuple<{{returnTypes|join(", ")}}>
{# ------- #}
{# ------------------------------------------------------------------------------------- #}
{# NODEABLES #}
{# TODO-LS: This macro lacks parsing the parameters provided to a Contract tag #}
{# TODO: This macro lacks parsing the parameters provided to a Contract tag #}
{%- macro AddContract(configurationName, item) -%}
{% set contracts = [] %}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Core.h
+3 -1
View File
@@ -24,6 +24,8 @@
#include <Core/NamedId.h>
#include <ScriptCanvas/Grammar/PrimitivesDeclarations.h>
#define OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED
namespace AZ
{
class Entity;
@@ -94,7 +96,7 @@ namespace ScriptCanvas
struct VersionData
{
AZ_TYPE_INFO(VersionData, "{14C629F6-467B-46FE-8B63-48FDFCA42175}");
AZ_TYPE_INFO(VersionData, "{52036892-DA63-4199-AC6A-9BAFE6B74EFC}");
static void Reflect(AZ::ReflectContext* context);
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp
+11 -2
View File
@@ -2041,7 +2041,7 @@ namespace ScriptCanvas
}
}
void Datum::OnWriteEnd()
void Datum::OnDeserialize()
{
if (m_type.GetType() == Data::eType::BehaviorContextObject)
{
@@ -2059,18 +2059,27 @@ namespace ScriptCanvas
}
else
{
AZ_Error("Script Canvas", false, AZStd::string::format("Datum type (%s) de-serialized, but no such class found in the behavior context", m_type.GetAZType().ToString<AZStd::string>().c_str()).c_str());
AZ_Error("ScriptCanvas", false, AZStd::string::format("Datum type (%s) de-serialized, but no such class found in the behavior context", m_type.GetAZType().ToString<AZStd::string>().c_str()).c_str());
}
}
}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void Datum::OnWriteEnd()
{
OnDeserialize();
}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
void Datum::Reflect(AZ::ReflectContext* reflection)
{
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection))
{
serializeContext->Class<Datum>()
->Version(DatumHelpers::Version::Current, &DatumHelpers::VersionConverter)
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<SerializeContextEventHandler>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
->Field("m_isUntypedStorage", &Datum::m_isOverloadedStorage)
->Field("m_type", &Datum::m_type)
->Field("m_originality", &Datum::m_originality)
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.h
+11 -5
View File
@@ -8,14 +8,15 @@
#pragma once
#include <AzCore/Outcome/Outcome.h>
#include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/std/string/string_view.h>
#include <ScriptCanvas/Core/Core.h>
#include <ScriptCanvas/Core/SerializationListener.h>
#include <ScriptCanvas/Data/BehaviorContextObject.h>
#include <ScriptCanvas/Data/Data.h>
#include <ScriptCanvas/Data/DataTrait.h>
#include <ScriptCanvas/Data/BehaviorContextObject.h>
#include <AzCore/Outcome/Outcome.h>
namespace AZ
{
@@ -33,11 +34,12 @@ namespace ScriptCanvas
/// A Datum is used to provide generic storage for all data types in ScriptCanvas, and provide a common interface to accessing, modifying, and displaying them
/// in the editor, regardless of their actual ScriptCanvas or BehaviorContext type.
class Datum final
: public SerializationListener
{
friend class AZ::DatumSerializer;
public:
AZ_TYPE_INFO(Datum, "{8B836FC0-98A8-4A81-8651-35C7CA125451}");
AZ_RTTI(Datum, "{8B836FC0-98A8-4A81-8651-35C7CA125451}", SerializationListener);
AZ_CLASS_ALLOCATOR(Datum, AZ::SystemAllocator, 0);
enum class eOriginality : int
@@ -234,6 +236,7 @@ namespace ScriptCanvas
}
};
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
class SerializeContextEventHandler : public AZ::SerializeContext::IEventHandler
{
public:
@@ -244,6 +247,7 @@ namespace ScriptCanvas
datum->OnWriteEnd();
}
};
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
friend class SerializeContextEventHandler;
@@ -341,9 +345,11 @@ namespace ScriptCanvas
void OnDatumEdited();
void OnReadBegin();
void OnDeserialize() override;
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void OnWriteEnd();
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
AZ_INLINE bool SatisfiesTraits(AZ::u8 behaviorValueTraits) const;
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/GraphData.cpp
+11 -3
View File
@@ -19,17 +19,17 @@ namespace AZ
namespace ScriptCanvas
{
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
class GraphDataEventHandler : public AZ::SerializeContext::IEventHandler
{
public:
/// Called to rebuild the Endpoint map
void OnWriteEnd(void* classPtr) override
{
auto* graphData = reinterpret_cast<GraphData*>(classPtr);
graphData->BuildEndpointMap();
graphData->LoadDependentAssets();
reinterpret_cast<GraphData*>(classPtr)->OnDeserialized();
}
};
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
void GraphData::Reflect(AZ::ReflectContext* context)
{
@@ -42,7 +42,9 @@ namespace ScriptCanvas
serializeContext->Class<GraphData>()
->Version(4, &GraphData::VersionConverter)
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<GraphDataEventHandler>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
->Field("m_nodes", &GraphData::m_nodes)
->Field("m_connections", &GraphData::m_connections)
->Field("m_dependentAssets", &GraphData::m_dependentAssets)
@@ -215,4 +217,10 @@ namespace ScriptCanvas
m_dependentAssets.clear();
}
void GraphData::OnDeserialized()
{
BuildEndpointMap();
LoadDependentAssets();
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/GraphData.h
+1
View File
@@ -37,6 +37,7 @@ namespace ScriptCanvas
void BuildEndpointMap();
void Clear(bool deleteData = false);
void LoadDependentAssets();
void OnDeserialized();
using NodeContainer = AZStd::unordered_set<AZ::Entity*>;
using ConnectionContainer = AZStd::vector<AZ::Entity*>;
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp
+10 -1
View File
@@ -60,6 +60,7 @@ namespace ScriptCanvas
// Node
/////////
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
class NodeEventHandler
: public AZ::SerializeContext::IEventHandler
{
@@ -67,9 +68,10 @@ namespace ScriptCanvas
void OnWriteEnd(void* objectPtr) override
{
auto node = reinterpret_cast<Node*>(objectPtr);
node->RebuildInternalState();
node->OnDeserialize();
}
};
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
bool NodeVersionConverter(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& nodeElementNode)
{
@@ -420,7 +422,9 @@ namespace ScriptCanvas
serializeContext->RegisterGenericType<AZStd::unordered_map<SlotId, Deprecated::VariableInfo>>();
serializeContext->Class<Node, AZ::Component>()
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<NodeEventHandler>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
->Version(NodeCpp::Version::Current, &NodeVersionConverter)
->Field("Slots", &Node::m_slots)
->Field("Datums", &Node::m_slotDatums)
@@ -2616,6 +2620,11 @@ namespace ScriptCanvas
}
}
void Node::OnDeserialize()
{
RebuildInternalState();
}
void Node::OnEndpointConnected(const Endpoint& endpoint)
{
const SlotId& currentSlotId = EndpointNotificationBus::GetCurrentBusId()->GetSlotId();
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.h
+10 -8
View File
@@ -14,25 +14,23 @@
#include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/std/algorithm.h>
#include <AzCore/std/tuple.h>
#include <ScriptCanvas/CodeGen/NodeableCodegen.h>
#include <ScriptCanvas/Core/Contracts/TypeContract.h>
#include <ScriptCanvas/Core/Core.h>
#include <ScriptCanvas/Core/DatumBus.h>
#include <ScriptCanvas/Core/Endpoint.h>
#include <ScriptCanvas/Core/SubgraphInterface.h>
#include <ScriptCanvas/Core/ExecutionNotificationsBus.h>
#include <ScriptCanvas/Core/GraphBus.h>
#include <ScriptCanvas/Core/NodeBus.h>
#include <ScriptCanvas/Core/SerializationListener.h>
#include <ScriptCanvas/Core/Slot.h>
#include <ScriptCanvas/Core/SubgraphInterface.h>
#include <ScriptCanvas/Debugger/StatusBus.h>
#include <ScriptCanvas/Debugger/ValidationEvents/ValidationEvent.h>
#include <ScriptCanvas/Execution/ErrorBus.h>
#include <ScriptCanvas/Execution/ExecutionBus.h>
#include <ScriptCanvas/Variable/GraphVariable.h>
#include <ScriptCanvas/Grammar/Primitives.h>
#include <ScriptCanvas/Debugger/ValidationEvents/ValidationEvent.h>
#include <ScriptCanvas/CodeGen/NodeableCodegen.h>
#include <ScriptCanvas/Variable/GraphVariable.h>
#define SCRIPT_CANVAS_CALL_ON_INDEX_SEQUENCE(lambdaInterior)\
int dummy[]{ 0, ( lambdaInterior , 0)... };\
@@ -65,6 +63,7 @@ namespace ScriptCanvas
struct BehaviorContextMethodHelper;
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
template<typename t_Class>
class SerializeContextReadWriteHandler : public AZ::SerializeContext::IEventHandler
{
@@ -128,6 +127,7 @@ namespace ScriptCanvas
deserializedObject->OnWriteEnd();
}
};
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
// List of slots that will be create visual only slots on the nodes.
// Useful for special configurations or editor only concepts.
@@ -401,6 +401,7 @@ namespace ScriptCanvas
, public DatumNotificationBus::Handler
, public NodeRequestBus::Handler
, public EndpointNotificationBus::MultiHandler
, public SerializationListener
{
friend class Graph;
friend class RuntimeComponent;
@@ -472,7 +473,7 @@ namespace ScriptCanvas
public:
AZ_COMPONENT(Node, "{52B454AE-FA7E-4FE9-87D3-A1CAB235C691}");
AZ_COMPONENT(Node, "{52B454AE-FA7E-4FE9-87D3-A1CAB235C691}", SerializationListener);
static void Reflect(AZ::ReflectContext* reflection);
Node();
@@ -821,6 +822,7 @@ namespace ScriptCanvas
//////////////////////////////////////////////////////////////////////////
protected:
void OnDeserialize() override;
virtual void OnReconfigurationBegin() {}
virtual void OnReconfigurationEnd() {}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/SerializationListener.h
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
namespace ScriptCanvas
{
class SerializationListener
{
public:
AZ_RTTI(SerializationListener, "{CA4EE281-30B3-4928-BCD8-9305CE75E463}");
virtual ~SerializationListener() {}
virtual void OnSerialize() {}
virtual void OnDeserialize() {}
};
using SerializationListeners = AZStd::vector<SerializationListener*>;
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Data/BehaviorContextObject.cpp
+6 -28
View File
@@ -17,26 +17,12 @@
namespace ScriptCanvas
{
void BehaviorContextObject::OnReadBegin()
{
if (!IsOwned())
{
Clear();
}
}
void BehaviorContextObject::OnWriteEnd()
{
// Id Remapping invokes this method as well, not just serializing from an ObjectStream
}
void BehaviorContextObject::Reflect(AZ::ReflectContext* reflection)
{
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection))
{
serializeContext->Class<BehaviorContextObject>()
->Version(0)
->EventHandler<SerializeContextEventHandler>()
->Field("m_flags", &BehaviorContextObject::m_flags)
->Field("m_object", &BehaviorContextObject::m_object)
;
@@ -55,24 +41,11 @@ namespace ScriptCanvas
}
}
void BehaviorContextObject::SerializeContextEventHandler::OnReadBegin(void* classPtr)
{
BehaviorContextObject* object = reinterpret_cast<BehaviorContextObject*>(classPtr);
object->OnReadBegin();
}
void BehaviorContextObject::SerializeContextEventHandler::OnWriteEnd(void* classPtr)
{
BehaviorContextObject* object = reinterpret_cast<BehaviorContextObject*>(classPtr);
object->OnWriteEnd();
}
BehaviorContextObjectPtr BehaviorContextObject::CloneObject(const AZ::BehaviorClass& behaviorClass)
{
if (SystemRequestBus::HasHandlers())
{
AZStd::vector<char> buffer;
{
bool wasOwned = IsOwned();
m_flags |= Flags::Owned;
@@ -87,7 +60,6 @@ namespace ScriptCanvas
}
AZ::IO::ByteContainerStream<AZStd::vector<char>> readStream(&buffer);
BehaviorContextObject* newObject = CreateDefault(behaviorClass);
AZ::Utils::LoadObjectFromStreamInPlace(readStream, (*newObject));
@@ -124,6 +96,12 @@ namespace ScriptCanvas
: BehaviorContextObjectPtr(aznew BehaviorContextObject(reference, GetAnyTypeInfoReference(typeID), referenceFlags));
}
void BehaviorContextObject::Deserialize(BehaviorContextObject& target, const AZ::BehaviorClass& behaviorClass, AZStd::any& source)
{
target.m_object = AZStd::move(AZStd::any(AZStd::any_cast<void>(&source), GetAnyTypeInfoObject(behaviorClass)));
target.m_flags = Owned;
}
void BehaviorContextObject::release()
{
if (--m_referenceCount == 0)
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Data/BehaviorContextObject.h
+6 -14
View File
@@ -22,6 +22,7 @@
namespace AZ
{
class ReflectContext;
class BehaviorContextObjectSerializer;
}
namespace ScriptCanvas
@@ -29,6 +30,8 @@ namespace ScriptCanvas
class BehaviorContextObject final
{
friend struct AZStd::IntrusivePtrCountPolicy<BehaviorContextObject>;
friend class Datum;
friend class AZ::BehaviorContextObjectSerializer;
public:
AZ_TYPE_INFO(BehaviorContextObject, "{B735214D-5182-4536-B748-61EC83C1F007}");
@@ -69,16 +72,6 @@ namespace ScriptCanvas
Reference = 1 << 3,
};
class SerializeContextEventHandler : public AZ::SerializeContext::IEventHandler
{
public:
/// Called right before we start reading from the instance pointed by classPtr.
void OnReadBegin(void* classPtr) override;
/// Called after we are done writing to the instance pointed by classPtr.
void OnWriteEnd(void* classPtr) override;
};
template<typename... Args>
static AZ::BehaviorObject InvokeConstructor(const AZ::BehaviorClass& behaviorClass, void* resultPtr, Args&&... args);
@@ -90,6 +83,8 @@ namespace ScriptCanvas
AZ_INLINE static BehaviorContextObject* CreateDefaultHeap(const AZ::BehaviorClass& behaviorClass);
static void Deserialize(BehaviorContextObject& target, const AZ::BehaviorClass& behaviorClass, AZStd::any& source);
// use the SSO optimization on behavior class size ALIGNED with a placement new of behavior class create
AZ_FORCE_INLINE static AnyTypeInfo GetAnyTypeInfoObject(const AZ::BehaviorClass& behaviorClass);
@@ -110,6 +105,7 @@ namespace ScriptCanvas
// it is very important to track these from the moment they are created...
friend struct AZ::Serialize::InstanceFactory<BehaviorContextObject, true, false>;
friend struct AZ::AnyTypeInfoConcept<BehaviorContextObject, void>;
//...so don't use the ctors, use the Create functions...
//...the friend declarations are here for compatibility with the serialization system only
AZ_FORCE_INLINE BehaviorContextObject() = default;
@@ -128,10 +124,6 @@ namespace ScriptCanvas
AZ_FORCE_INLINE bool IsOwned() const;
void OnReadBegin();
void OnWriteEnd();
AZ_FORCE_INLINE void add_ref();
void release();
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/EBusEventHandler.cpp
+10 -1
View File
@@ -602,15 +602,24 @@ namespace ScriptCanvas
}
}
void EBusEventHandler::OnWriteEnd()
void EBusEventHandler::OnDeserialize()
{
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_mutex);
if (!m_ebus)
{
CreateHandler(m_ebusName);
}
Node::OnDeserialize();
}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void EBusEventHandler::OnWriteEnd()
{
OnDeserialize();
}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
NodeTypeIdentifier EBusEventHandler::GetOutputNodeType(const SlotId& slotId) const
{
for (auto mapPair : m_eventMap)
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/EBusEventHandler.h
+4
View File
@@ -138,7 +138,11 @@ namespace ScriptCanvas
void SetAutoConnectToGraphOwner(bool enabled);
void OnDeserialize();
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void OnWriteEnd();
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
AZStd::string GetNodeName() const override
{
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/Method.cpp
+14 -2
View File
@@ -313,6 +313,7 @@ namespace ScriptCanvas
}
PopulateNodeType();
m_warnOnMissingFunction = true;
}
bool Method::InitializeOverloaded([[maybe_unused]] const NamespacePath& namespaces, AZStd::string_view className, AZStd::string_view methodName)
@@ -739,10 +740,11 @@ namespace ScriptCanvas
return TupleType{ nullptr, MethodType::Count, EventType::Count, nullptr };
}
void Method::OnWriteEnd()
void Method::OnDeserialize()
{
AZStd::lock_guard<AZStd::recursive_mutex> lock(m_mutex);
m_warnOnMissingFunction = true;
const AZ::BehaviorClass* bcClass{};
const AZ::BehaviorMethod* method{};
EventType eventType;
@@ -758,15 +760,23 @@ namespace ScriptCanvas
{
AZ_Warning("ScriptCanvas", !m_warnOnMissingFunction, "method node failed to deserialize properly");
}
}
if (m_resultSlotIDs.empty())
{
m_resultSlotIDs.emplace_back(SlotId{});
}
Node::OnDeserialize();
}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void Method::OnWriteEnd()
{
OnDeserialize();
}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
bool Method::BranchesOnResult() const
{
return m_method && m_method->HasResult() &&
@@ -829,7 +839,9 @@ namespace ScriptCanvas
{
serializeContext->Class<Method, Node>()
->Version(MethodCPP::eVersion::Current, &MethodCPP::MethodVersionConverter)
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<SerializeContextOnWriteEndHandler<Method>>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
->Field("methodType", &Method::m_methodType)
->Field("methodName", &Method::m_lookupName)
->Field("className", &Method::m_className)
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/Method.h
+7 -3
View File
@@ -22,7 +22,6 @@ namespace AZ
namespace ScriptCanvas
{
AZ::Outcome<void, AZStd::string> IsExposable(const AZ::BehaviorMethod& method);
Grammar::FunctionPrototype ToSignature(const AZ::BehaviorMethod& method);
@@ -31,7 +30,8 @@ namespace ScriptCanvas
{
namespace Core
{
class Method : public Node
class Method
: public Node
{
public:
AZ_COMPONENT(Method, "{E42861BD-1956-45AE-8DD7-CCFC1E3E5ACF}", Node);
@@ -107,7 +107,11 @@ namespace ScriptCanvas
SlotId GetBusSlotId() const;
void OnDeserialize();
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void OnWriteEnd();
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
virtual bool IsMethodOverloaded() const { return false; }
@@ -180,7 +184,7 @@ namespace ScriptCanvas
AZStd::vector<SlotId> m_inputSlots;
AZStd::vector<SlotId> m_resultSlotIDs;
AZStd::recursive_mutex m_mutex; // post-serialization
bool m_warnOnMissingFunction = true;
bool m_warnOnMissingFunction = false;
Method(const Method&) = delete;
};
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/MethodOverloaded.cpp
+11 -13
View File
@@ -60,7 +60,9 @@ namespace ScriptCanvas
{
serializeContext->Class<MethodOverloaded, Method>()
->Version(MethodOverloadedCpp::Version::Current, &MethodOverloadedVersionConverter)
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
->EventHandler<SerializeContextReadWriteHandler<MethodOverloaded>>()
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
->Field("orderedInputSlotIds", &MethodOverloaded::m_orderedInputSlotIds)
->Field("outputSlotIds", &MethodOverloaded::m_outputSlotIds)
;
@@ -186,6 +188,7 @@ namespace ScriptCanvas
RefreshActiveIndexes();
ConfigureContracts();
SetWarnOnMissingFunction(true);
}
SlotId MethodOverloaded::AddMethodInputSlot(const MethodConfiguration& config, size_t argumentIndex)
@@ -397,20 +400,14 @@ namespace ScriptCanvas
return signature;
}
void MethodOverloaded::OnReadBegin()
{
}
void MethodOverloaded::OnReadEnd()
{
}
void MethodOverloaded::OnWriteBegin()
{
SetWarnOnMissingFunction(false);
}
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
void MethodOverloaded::OnWriteEnd()
{
OnDeserialize();
}
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
void MethodOverloaded::OnDeserialize()
{
AZStd::lock_guard<AZStd::recursive_mutex> lock(GetMutex());
@@ -462,6 +459,7 @@ namespace ScriptCanvas
}
SetWarnOnMissingFunction(true);
Node::OnDeserialize();
}
void MethodOverloaded::SetupMethodData(const AZ::BehaviorMethod* behaviorMethod, const AZ::BehaviorClass* behaviorClass)
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Core/MethodOverloaded.h
+9 -5
View File
@@ -33,7 +33,9 @@ namespace ScriptCanvas
, public OverloadContractInterface
{
private:
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
friend class SerializeContextReadWriteHandler<MethodOverloaded>;
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
public:
static void Reflect(AZ::ReflectContext* reflectContext);
@@ -91,13 +93,15 @@ namespace ScriptCanvas
// \todo make execution thread sensitive, which can then support generic programming
Grammar::FunctionPrototype GetInputSignature() const;
#if defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)////
// SerializeContextReadWriteHandler
void OnReadBegin();
void OnReadEnd();
void OnWriteBegin();
void OnReadBegin() {}
void OnReadEnd() {}
void OnWriteBegin() {}
void OnWriteEnd();
////
#endif//defined(OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED)
void OnDeserialize() override;
void SetupMethodData(const AZ::BehaviorMethod* lookupMethod, const AZ::BehaviorClass* lookupClass);
void ConfigureContracts();
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Logic/Gate.ScriptCanvasGrammar.xml
-1
View File
@@ -5,7 +5,6 @@
QualifiedName="ScriptCanvas::Nodes::Logic::Gate"
PreferredClassName="If"
Uuid="{F19CC10A-02FD-4E75-ADAA-9CFBD8A4E2F8}"
Base="ScriptCanvas::Node"
Icon="Icons/ScriptCanvas/Print.png"
Version="0"
GeneratePropertyFriend="True"
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Serialization/BehaviorContextObjectSerializer.cpp
+149
View File
@@ -0,0 +1,149 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/Serialization/AZStdAnyDataContainer.inl>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Serialization/BehaviorContextObjectSerializer.h>
using namespace ScriptCanvas;
namespace AZ
{
AZ_CLASS_ALLOCATOR_IMPL(BehaviorContextObjectSerializer, SystemAllocator, 0);
JsonSerializationResult::Result BehaviorContextObjectSerializer::Load
( void* outputValue
, [[maybe_unused]] const Uuid& outputValueTypeId
, const rapidjson::Value& inputValue
, JsonDeserializerContext& context)
{
namespace JSR = JsonSerializationResult;
AZ_Assert(outputValueTypeId == azrtti_typeid<BehaviorContextObject>(), "BehaviorContextObjectSerializer Load against output typeID"
"that was not BehaviorContextObject");
AZ_Assert(outputValue, "BehaviorContextObjectSerializer Load against null output");
JsonSerializationResult::ResultCode result(JSR::Tasks::ReadField);
auto outputBehaviorContextObject = reinterpret_cast<BehaviorContextObject*>(outputValue);
bool isOwned = false;
result.Combine(ContinueLoadingFromJsonObjectField
( &isOwned
, azrtti_typeid<bool>()
, inputValue
, "isOwned"
, context));
if (isOwned)
{
AZStd::any storage;
{ // any storage begin
auto typeIdMember = inputValue.FindMember(JsonSerialization::TypeIdFieldIdentifier);
if (typeIdMember == inputValue.MemberEnd())
{
return context.Report
(JSR::Tasks::ReadField
, JSR::Outcomes::Missing
, AZStd::string::format("BehaviorContextObjectSerializer::Load failed to load the %s member"
, JsonSerialization::TypeIdFieldIdentifier));
}
AZ::Uuid typeId;
result.Combine(LoadTypeId(typeId, typeIdMember->value, context));
if (typeId.IsNull())
{
return context.Report(JSR::Tasks::ReadField, JSR::Outcomes::Catastrophic
, "BehaviorContextObjectSerializer::Load failed to load the AZ TypeId of the value");
}
storage = context.GetSerializeContext()->CreateAny(typeId);
if (storage.empty() || storage.type() != typeId)
{
return context.Report(result, "BehaviorContextObjectSerializer::Load failed to load a value matched the reported AZ "
"TypeId. The C++ declaration may have been deleted or changed.");
}
result.Combine(ContinueLoadingFromJsonObjectField(AZStd::any_cast<void>(&storage), typeId, inputValue, "value", context));
} // any storage end
auto bcClass = AZ::BehaviorContextHelper::GetClass(storage.type());
BehaviorContextObject::Deserialize(*outputBehaviorContextObject, *bcClass, storage);
}
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "BehaviorContextObjectSerializer Load finished loading BehaviorContextObject"
: "BehaviorContextObjectSerializer Load failed to load BehaviorContextObject");
}
JsonSerializationResult::Result BehaviorContextObjectSerializer::Store
( rapidjson::Value& outputValue
, const void* inputValue
, const void* defaultValue
, [[maybe_unused]] const Uuid& valueTypeId
, JsonSerializerContext& context)
{
namespace JSR = JsonSerializationResult;
AZ_Assert(valueTypeId == azrtti_typeid<BehaviorContextObject>(), "BehaviorContextObjectSerializer Store against value typeID that "
"was not BehaviorContextObject");
AZ_Assert(inputValue, "BehaviorContextObjectSerializer Store against null inputValue pointer ");
auto defaultScriptDataPtr = reinterpret_cast<const BehaviorContextObject*>(defaultValue);
auto inputScriptDataPtr = reinterpret_cast<const BehaviorContextObject*>(inputValue);
if (defaultScriptDataPtr)
{
if (AZ::Helpers::CompareAnyValue(inputScriptDataPtr->ToAny(), defaultScriptDataPtr->ToAny()))
{
return context.Report
( JSR::Tasks::WriteValue, JSR::Outcomes::DefaultsUsed, "BehaviorContextObjectSerializer Store used defaults "
"for BehaviorContextObject");
}
}
outputValue.SetObject();
JSR::ResultCode result(JSR::Tasks::WriteValue);
const bool isInputOwned = inputScriptDataPtr->IsOwned();
const bool isDefaultOwned = defaultScriptDataPtr ? defaultScriptDataPtr->IsOwned() : false;
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "isOwned"
, &isInputOwned
, &isDefaultOwned
, azrtti_typeid<bool>()
, context));
if (isInputOwned)
{
// any storage begin
{
rapidjson::Value typeValue;
result.Combine(StoreTypeId(typeValue, inputScriptDataPtr->ToAny().type(), context));
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(typeValue)
, context.GetJsonAllocator());
}
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "value"
, inputScriptDataPtr->Get()
, defaultScriptDataPtr ? defaultScriptDataPtr->Get() : nullptr
, inputScriptDataPtr->ToAny().type()
, context));
// datum storage end
}
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "BehaviorContextObjectSerializer Store finished saving BehaviorContextObject"
: "BehaviorContextObjectSerializer Store failed to save BehaviorContextObject");
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Serialization/BehaviorContextObjectSerializer.h
+37
View File
@@ -0,0 +1,37 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/Memory/Memory.h>
#include <AzCore/Serialization/Json/BaseJsonSerializer.h>
#include <AzCore/Serialization/SerializeContext.h>
namespace AZ
{
class BehaviorContextObjectSerializer
: public BaseJsonSerializer
{
public:
AZ_RTTI(BehaviorContextObjectSerializer, "{88469C4C-923F-4508-A45C-33DDBB91074E}", BaseJsonSerializer);
AZ_CLASS_ALLOCATOR_DECL;
private:
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;
};
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Serialization/DatumSerializer.cpp
+46 -25
View File
@@ -50,10 +50,23 @@ namespace AZ
, "scriptCanvasType"
, context));
AZStd::any storage;
{ // datum storage begin
AZ::Uuid typeId = AZ::Uuid::CreateNull();
// datum storage begin
auto isNullPointerMember = inputValue.FindMember("isNullPointer");
if (isNullPointerMember == inputValue.MemberEnd())
{
return context.Report
( JSR::Tasks::ReadField
, JSR::Outcomes::Missing
, "DatumSerializer::Load failed to load the 'isNullPointer'' member");
}
if (isNullPointerMember->value.GetBool())
{
*outputDatum = Datum(scType, Datum::eOriginality::Original);
}
else
{
AZ::Uuid typeId = AZ::Uuid::CreateNull();
auto typeIdMember = inputValue.FindMember(JsonSerialization::TypeIdFieldIdentifier);
if (typeIdMember == inputValue.MemberEnd())
{
@@ -71,7 +84,7 @@ namespace AZ
, "DatumSerializer::Load failed to load the AZ TypeId of the value");
}
storage = context.GetSerializeContext()->CreateAny(typeId);
AZStd::any storage = context.GetSerializeContext()->CreateAny(typeId);
if (storage.empty() || storage.type() != typeId)
{
return context.Report(result, "DatumSerializer::Load failed to load a value matched the reported AZ TypeId. "
@@ -79,22 +92,25 @@ namespace AZ
}
result.Combine(ContinueLoadingFromJsonObjectField(AZStd::any_cast<void>(&storage), typeId, inputValue, "value", context));
*outputDatum = Datum(scType, Datum::eOriginality::Original, AZStd::any_cast<void>(&storage), scType.GetAZType());
} // datum storage end
AZStd::string label;
AZ_Assert(azrtti_typeid<decltype(outputDatum->m_datumLabel)>() == azrtti_typeid<decltype(label)>()
, "m_datumLabel type changed and won't load properly");
result.Combine(ContinueLoadingFromJsonObjectField
result.Combine(ContinueLoadingFromJsonObjectField
( &label
, azrtti_typeid<decltype(outputDatum->m_datumLabel)>()
, inputValue
, "label"
, context));
outputDatum->SetLabel(label);
Datum copy(scType, Datum::eOriginality::Original, AZStd::any_cast<void>(&storage), scType.GetAZType());
copy.SetLabel(label);
*outputDatum = copy;
if (auto listeners = context.GetMetadata().Find<SerializationListeners>())
{
listeners->push_back(outputDatum);
}
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "DatumSerializer Load finished loading Datum"
: "DatumSerializer Load failed to load Datum");
@@ -123,7 +139,7 @@ namespace AZ
( JSR::Tasks::WriteValue, JSR::Outcomes::DefaultsUsed, "DatumSerializer Store used defaults for Datum");
}
}
JSR::ResultCode result(JSR::Tasks::WriteValue);
outputValue.SetObject();
@@ -142,26 +158,32 @@ namespace AZ
, defaultScriptDataPtr ? &defaultScriptDataPtr->GetType() : nullptr
, azrtti_typeid<decltype(inputScriptDataPtr->GetType())>()
, context));
{ // datum storage begin
{
rapidjson::Value typeValue;
result.Combine(StoreTypeId(typeValue, inputScriptDataPtr->GetType().GetAZType(), context));
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(typeValue)
, context.GetJsonAllocator());
}
// datum storage begin
auto inputObjectSource = inputScriptDataPtr->GetAsDanger();
outputValue.AddMember("isNullPointer", rapidjson::Value(inputObjectSource == nullptr), context.GetJsonAllocator());
if (inputObjectSource)
{
rapidjson::Value typeValue;
result.Combine(StoreTypeId(typeValue, inputScriptDataPtr->GetType().GetAZType(), context));
outputValue.AddMember
( rapidjson::StringRef(JsonSerialization::TypeIdFieldIdentifier)
, AZStd::move(typeValue)
, context.GetJsonAllocator());
auto defaultObjectSource = defaultScriptDataPtr ? defaultScriptDataPtr->GetAsDanger() : nullptr;
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "value"
, inputScriptDataPtr->GetAsDanger()
, defaultScriptDataPtr ? defaultScriptDataPtr->GetAsDanger() : nullptr
, inputObjectSource
, defaultObjectSource
, inputScriptDataPtr->GetType().GetAZType()
, context));
} // datum storage end
}
// datum storage end
result.Combine(ContinueStoringToJsonObjectField
( outputValue
, "label"
@@ -174,5 +196,4 @@ namespace AZ
? "DatumSerializer Store finished saving Datum"
: "DatumSerializer Store failed to save Datum");
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Serialization/RuntimeVariableSerializer.cpp
+1
View File
@@ -50,6 +50,7 @@ namespace AZ
}
result.Combine(ContinueLoadingFromJsonObjectField(AZStd::any_cast<void>(&outputVariable->value), typeId, inputValue, "value", context));
return context.Report(result, result.GetProcessing() != JSR::Processing::Halted
? "RuntimeVariableSerializer Load finished loading RuntimeVariable"
: "RuntimeVariableSerializer Load failed to load RuntimeVariable");
Gems/ScriptCanvas/Code/Source/SystemComponent.cpp
+6 -9
View File
@@ -7,7 +7,6 @@
*/
#include <iostream>
#include <AzCore/Component/EntityUtils.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/Serialization/Json/RegistrationContext.h>
@@ -23,8 +22,9 @@
#include <ScriptCanvas/Execution/ExecutionPerformanceTimer.h>
#include <ScriptCanvas/Execution/Interpreted/ExecutionInterpretedAPI.h>
#include <ScriptCanvas/Execution/RuntimeComponent.h>
#include <ScriptCanvas/Serialization/RuntimeVariableSerializer.h>
#include <ScriptCanvas/Serialization/DatumSerializer.h>
#include <ScriptCanvas/Serialization/BehaviorContextObjectSerializer.h>
#include <ScriptCanvas/Serialization/RuntimeVariableSerializer.h>
#include <ScriptCanvas/SystemComponent.h>
#include <ScriptCanvas/Variable/GraphVariableManagerComponent.h>
@@ -59,6 +59,7 @@ namespace ScriptCanvas
{
void SystemComponent::Reflect(AZ::ReflectContext* context)
{
VersionData::Reflect(context);
Nodeable::Reflect(context);
ReflectLibraries(context);
@@ -88,13 +89,9 @@ namespace ScriptCanvas
if (AZ::JsonRegistrationContext* jsonContext = azrtti_cast<AZ::JsonRegistrationContext*>(context))
{
jsonContext->Serializer<AZ::RuntimeVariableSerializer>()
->HandlesType<RuntimeVariable>()
;
jsonContext->Serializer<AZ::DatumSerializer>()
->HandlesType<Datum>()
;
jsonContext->Serializer<AZ::DatumSerializer>()->HandlesType<Datum>();
jsonContext->Serializer<AZ::BehaviorContextObjectSerializer>()->HandlesType<BehaviorContextObject>();
jsonContext->Serializer<AZ::RuntimeVariableSerializer>()->HandlesType<RuntimeVariable>();
}
#if defined(SC_EXECUTION_TRACE_ENABLED)
Gems/ScriptCanvas/Code/scriptcanvasgem_common_files.cmake
+3
View File
@@ -74,6 +74,7 @@ set(FILES
Include/ScriptCanvas/Core/NodeableNodeOverloaded.cpp
Include/ScriptCanvas/Core/NodeableNodeOverloaded.h
Include/ScriptCanvas/Core/NodeFunctionGeneric.h
Include/ScriptCanvas/Core/SerializationListener.h
Include/ScriptCanvas/Core/Slot.cpp
Include/ScriptCanvas/Core/Slot.h
Include/ScriptCanvas/Core/SlotConfigurationDefaults.h
@@ -539,6 +540,8 @@ set(FILES
Include/ScriptCanvas/Profiler/Aggregator.cpp
Include/ScriptCanvas/Profiler/DrillerEvents.h
Include/ScriptCanvas/Profiler/DrillerEvents.cpp
Include/ScriptCanvas/Serialization/BehaviorContextObjectSerializer.h
Include/ScriptCanvas/Serialization/BehaviorContextObjectSerializer.cpp
Include/ScriptCanvas/Serialization/DatumSerializer.h
Include/ScriptCanvas/Serialization/DatumSerializer.cpp
Include/ScriptCanvas/Serialization/RuntimeVariableSerializer.h
Gems/ScriptCanvasTesting/Assets/ScriptCanvas/UnitTests/LY_SC_UnitTest_PathologicalFlowOfControl.scriptcanvas
+7028 -11310
View File
File diff suppressed because it is too large Load Diff