o3de/Gems/Atom/RHI/Code/Source/RHI.Reflect/ShaderDataMappings.cpp

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/

#include <AzCore/Serialization/SerializeContext.h>

#include <Atom/RHI.Reflect/ShaderDataMappings.h>

namespace AZ
{
    namespace RHI
    {
        void ShaderDataMappingColor::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingColor>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingColor::m_name)
                    ->Field("Value", &ShaderDataMappingColor::m_value);
            }
        }

        void ShaderDataMappingUint::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingUint>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingUint::m_name)
                    ->Field("Value", &ShaderDataMappingUint::m_value);
            }
        }

        void ShaderDataMappingFloat::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingFloat>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingFloat::m_name)
                    ->Field("Value", &ShaderDataMappingFloat::m_value);
            }
        }

        void ShaderDataMappingFloat2::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingFloat2>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingFloat2::m_name)
                    ->Field("Value", &ShaderDataMappingFloat2::m_value);
            }
        }

        void ShaderDataMappingFloat3::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingFloat3>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingFloat3::m_name)
                    ->Field("Value", &ShaderDataMappingFloat3::m_value);
            }
        }

        void ShaderDataMappingFloat4::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingFloat4>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingFloat4::m_name)
                    ->Field("Value", &ShaderDataMappingFloat4::m_value);
            }
        }

        void ShaderDataMappingMatrix3x3::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingMatrix3x3>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingMatrix3x3::m_name)
                    ->Field("Value", &ShaderDataMappingMatrix3x3::m_value);
            }
        }

        void ShaderDataMappingMatrix4x4::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serializeContext->Class<ShaderDataMappingMatrix4x4>()
                    ->Version(0)
                    ->Field("Name", &ShaderDataMappingMatrix4x4::m_name)
                    ->Field("Value", &ShaderDataMappingMatrix4x4::m_value);
            }
        }

        void ShaderDataMappings::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
            {
                ShaderDataMappingColor::Reflect(context);
                ShaderDataMappingUint::Reflect(context);
                ShaderDataMappingFloat::Reflect(context);
                ShaderDataMappingFloat2::Reflect(context);
                ShaderDataMappingFloat3::Reflect(context);
                ShaderDataMappingFloat4::Reflect(context);
                ShaderDataMappingMatrix3x3::Reflect(context);
                ShaderDataMappingMatrix4x4::Reflect(context);

                serializeContext->Class<ShaderDataMappings>()
                    ->Version(0)
                    ->Field("ColorMappings", &ShaderDataMappings::m_colorMappings)
                    ->Field("UintMappings", &ShaderDataMappings::m_uintMappings)
                    ->Field("FloatMappings", &ShaderDataMappings::m_floatMappings)
                    ->Field("Float2Mappings", &ShaderDataMappings::m_float2Mappings)
                    ->Field("Float3Mappings", &ShaderDataMappings::m_float3Mappings)
                    ->Field("Float4Mappings", &ShaderDataMappings::m_float4Mappings)
                    ->Field("Matrix3x3Mappings", &ShaderDataMappings::m_matrix3x3Mappings)
                    ->Field("Matrix4x4Mappings", &ShaderDataMappings::m_matrix4x4Mappings)
                    ;
            }
        }
    }
}