void CopyPropagationPass2::Initialize()
{
// I don't want to delete any of the statements, but I must clear
// out the list I was using to contain the statements
if (!toBeRemoved.empty())
{
while (toBeRemoved.begin() != toBeRemoved.end())
{
toBeRemoved.pop_front() ;
}
}
assert(procDef != NULL) ;
InitializeMap() ;
// Also, collect all of the feedback variables for later
SymbolTable* procSymTable = procDef->get_symbol_table() ;
assert(procSymTable != NULL) ;
for (int i = 0 ; i < procSymTable->get_symbol_table_object_count() ; ++i)
{
if(dynamic_cast<VariableSymbol*>(procSymTable->get_symbol_table_object(i)) != NULL)
{
VariableSymbol* nextSymbol =
dynamic_cast<VariableSymbol*>(procSymTable->get_symbol_table_object(i));
if (nextSymbol->lookup_annote_by_name("FeedbackVariable") != NULL)
{
feedbackVariables.push_back(nextSymbol) ;
}
}
}
}
TSharedPtr<IComponentAssetBroker> FComponentAssetBrokerage::FindBrokerByAssetType(UClass* InAssetClass)
{
InitializeMap();
TArray< TSharedPtr<IComponentAssetBroker> >* pBrokerList = AssetToBrokerMap.Find(InAssetClass);
return ((pBrokerList != NULL) && (pBrokerList->Num() > 0)) ? (*pBrokerList)[0] : NULL;
}
void FComponentAssetBrokerage::RegisterBroker(TSharedPtr<IComponentAssetBroker> Broker, TSubclassOf<UActorComponent> InComponentClass, bool bSetAsPrimary, bool bMapCompnentForAssets)
{
InitializeMap();
check(Broker.IsValid());
UClass* AssetClass = Broker->GetSupportedAssetClass();
check((AssetClass != NULL) && (AssetClass != UObject::StaticClass()));
checkf(!ComponentToBrokerMap.Contains(InComponentClass), TEXT("Component class already has a registered broker; you have to chain them yourself."));
ComponentToBrokerMap.Add(InComponentClass, Broker);
if (bSetAsPrimary)
{
AssetToBrokerMap.FindOrAdd(AssetClass).Insert(Broker, 0);
}
else
{
AssetToBrokerMap.FindOrAdd(AssetClass).Add(Broker);
}
if (bMapCompnentForAssets)
{
FComponentClassList& ValidComponentTypes = AssetToComponentClassMap.FindOrAdd(AssetClass);
if (bSetAsPrimary)
{
ValidComponentTypes.Insert(InComponentClass, 0);
}
else
{
ValidComponentTypes.Add(InComponentClass);
}
}
}
/** See if this component supports assets of any type */
bool FComponentAssetBrokerage::SupportsAssets(UActorComponent* InComponent)
{
InitializeMap();
if (InComponent == NULL)
{
return false;
}
else
{
TSharedPtr<IComponentAssetBroker> Broker = FindBrokerByComponentType(InComponent->GetClass());
return Broker.IsValid();
}
}
UObject* FComponentAssetBrokerage::GetAssetFromComponent(UActorComponent* InComponent)
{
InitializeMap();
if (InComponent != NULL)
{
TSharedPtr<IComponentAssetBroker> Broker = FindBrokerByComponentType(InComponent->GetClass());
if (Broker.IsValid())
{
return Broker->GetAssetFromComponent(InComponent);
}
}
return NULL;
}
/** Assign the assigned asset to the supplied component */
bool FComponentAssetBrokerage::AssignAssetToComponent(UActorComponent* InComponent, UObject* InAsset)
{
InitializeMap();
if (InComponent != NULL)
{
TSharedPtr<IComponentAssetBroker> Broker = FindBrokerByComponentType(InComponent->GetClass());
if (Broker.IsValid())
{
return Broker->AssignAssetToComponent(InComponent, InAsset);
}
}
return false;
}
TArray<UClass*> FComponentAssetBrokerage::GetSupportedAssets(UClass* InFilterComponentClass)
{
InitializeMap();
TArray< UClass* > SupportedAssets;
for (auto ComponentTypeIt = ComponentToBrokerMap.CreateIterator(); ComponentTypeIt; ++ComponentTypeIt)
{
TSubclassOf<UActorComponent> Component = ComponentTypeIt.Key();
if(InFilterComponentClass == NULL || Component->IsChildOf(InFilterComponentClass))
{
SupportedAssets.Add(ComponentTypeIt.Value()->GetSupportedAssetClass());
}
}
return SupportedAssets;
}
/** Find set of components that support this asset */
FComponentClassList FComponentAssetBrokerage::GetComponentsForAsset(const UObject* InAsset)
{
InitializeMap();
FComponentClassList OutClasses;
if (InAsset != NULL)
{
for (UClass* Class = InAsset->GetClass(); Class != UObject::StaticClass(); Class = Class->GetSuperClass())
{
if (FComponentClassList* pTypesForClass = AssetToComponentClassMap.Find(Class))
{
OutClasses.Append(*pTypesForClass);
}
}
}
return OutClasses;
}
TSubclassOf<UActorComponent> FComponentAssetBrokerage::GetPrimaryComponentForAsset(UClass* InAssetClass)
{
InitializeMap();
if (InAssetClass != NULL)
{
for (UClass* Class = InAssetClass; Class != UObject::StaticClass(); Class = Class->GetSuperClass())
{
if (FComponentClassList* pTypesForClass = AssetToComponentClassMap.Find(Class))
{
if (pTypesForClass->Num() > 0)
{
return (*pTypesForClass)[0];
}
}
}
}
return NULL;
}
void Initialize(User *user)
{
InitializeMap(user);
}
TSharedPtr<IComponentAssetBroker> FComponentAssetBrokerage::FindBrokerByComponentType(TSubclassOf<UActorComponent> InComponentClass)
{
InitializeMap();
return ComponentToBrokerMap.FindRef(InComponentClass);
}
