o3de/Gems/Atom/RPI/Code/Source/RPI.Builders/BuilderComponent.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/Component/Entity.h>
#include <AzCore/Serialization/EditContext.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Script/ScriptAsset.h>

#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
#include <Atom/RPI.Edit/Material/MaterialSourceData.h>
#include <Atom/RPI.Edit/Material/MaterialPropertyValueSourceData.h>
#include <Atom/RPI.Edit/Material/LuaMaterialFunctorSourceData.h>
#include <Atom/RPI.Edit/Shader/ShaderSourceData.h>
#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
#include <Atom/RPI.Edit/Common/AssetAliasesSourceData.h>

#include <Atom/RPI.Reflect/Asset/AssetHandler.h>
#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
#include <Atom/RPI.Reflect/Image/StreamingImagePoolAsset.h>
#include <Atom/RPI.Reflect/Buffer/BufferAsset.h>
#include <Atom/RPI.Reflect/Model/ModelLodAsset.h>
#include <Atom/RPI.Reflect/Model/ModelAsset.h>
#include <Atom/RPI.Reflect/Model/MorphTargetMetaAsset.h>
#include <Atom/RPI.Reflect/Model/SkinMetaAsset.h>
#include <Atom/RPI.Reflect/Pass/PassAsset.h>
#include <Atom/RPI.Reflect/Shader/ShaderVariantAsset.h>
#include <Atom/RPI.Reflect/Shader/ShaderVariantTreeAsset.h>

#include <BuilderComponent.h>
#include <Common/AnyAssetBuilder.h>
#include <Material/MaterialBuilder.h>
#include <ResourcePool/ResourcePoolBuilder.h>
#include <Pass/PassBuilder.h>

namespace AZ
{
    namespace RPI
    {
        void BuilderComponent::Reflect(AZ::ReflectContext* context)
        {
            if (auto* serialize = azrtti_cast<AZ::SerializeContext*>(context))
            {
                serialize->Class<BuilderComponent, AZ::Component>()
                    ->Version(0)
                    ->Attribute(AZ::Edit::Attributes::SystemComponentTags, AZStd::vector<AZ::Crc32>({ AssetBuilderSDK::ComponentTags::AssetBuilder }))
                ;
            }

            MaterialTypeSourceData::Reflect(context);
            MaterialSourceData::Reflect(context);
            MaterialPropertyValueSourceData::Reflect(context);
            MaterialFunctorSourceDataHolder::Reflect(context);
            LuaMaterialFunctorSourceData::Reflect(context);
            ResourcePoolSourceData::Reflect(context);
            ConvertibleSource::Reflect(context);
            AssetAliasesSourceData::Reflect(context);
            ShaderSourceData::Reflect(context);
            ShaderVariantListSourceData::Reflect(context);
        }

        BuilderComponent::BuilderComponent()
        {
            m_materialFunctorRegistration.Init();
        }

        BuilderComponent::~BuilderComponent()
        {
            m_materialFunctorRegistration.Shutdown();
        }

        void BuilderComponent::Activate()
        {
            // Register asset workers
            m_assetWorkers.emplace_back(MakeAssetBuilder<MaterialBuilder>());
            m_assetWorkers.emplace_back(MakeAssetBuilder<ResourcePoolBuilder>());
            m_assetWorkers.emplace_back(MakeAssetBuilder<AnyAssetBuilder>());
            m_assetWorkers.emplace_back(MakeAssetBuilder<PassBuilder>());

            m_assetHandlers.emplace_back(MakeAssetHandler<ShaderAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<MaterialTypeAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<MaterialAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<ResourcePoolAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<StreamingImagePoolAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<BufferAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<ModelLodAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<ModelAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<PassAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<ShaderVariantAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<ShaderVariantTreeAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<SkinMetaAssetHandler>());
            m_assetHandlers.emplace_back(MakeAssetHandler<MorphTargetMetaAssetHandler>());

            RPI::MaterialFunctorSourceDataRegistration* materialFunctorRegistration = RPI::MaterialFunctorSourceDataRegistration::Get();
            AZ_Assert(materialFunctorRegistration,
                "MaterialFunctorSourceDataRegistration must be added to a component of the current module, "
                "and initialize it in the component's Init() call.");
            materialFunctorRegistration->RegisterMaterialFunctor("Lua", azrtti_typeid<LuaMaterialFunctorSourceData>());


            // Add asset types and extensions to AssetCatalog. Uses "AssetCatalogService".
            auto assetCatalog = AZ::Data::AssetCatalogRequestBus::FindFirstHandler();
            if (assetCatalog)
            {
                assetCatalog->EnableCatalogForAsset(AZ::AzTypeInfo<AZ::ScriptAsset>::Uuid());
            }
        }

        void BuilderComponent::Deactivate()
        {
            m_assetHandlers.clear();
            m_assetWorkers.clear();
        }
    } // namespace RPI
} // namespace AZ