void UK2Node_Timeline::ExpandNode(FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UBlueprint* Blueprint = GetBlueprint();
check(Blueprint);
UTimelineTemplate* Timeline = Blueprint->FindTimelineTemplateByVariableName(TimelineName);
if(Timeline)
{
ExpandForPin(GetDirectionPin(), Timeline->GetDirectionPropertyName(), CompilerContext, SourceGraph);
for(int32 i=0; i<Timeline->FloatTracks.Num(); i++)
{
const FName TrackName = Timeline->FloatTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
for(int32 i=0; i<Timeline->VectorTracks.Num(); i++)
{
const FName TrackName = Timeline->VectorTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
for(int32 i=0; i<Timeline->LinearColorTracks.Num(); i++)
{
const FName TrackName = Timeline->LinearColorTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
}
}
void UK2Node_Timeline::DestroyNode()
{
UBlueprint* Blueprint = GetBlueprint();
check(Blueprint);
UTimelineTemplate* Timeline = Blueprint->FindTimelineTemplateByVariableName(TimelineName);
if(Timeline)
{
FBlueprintEditorUtils::RemoveTimeline(Blueprint, Timeline, true);
// Move template object out of the way so that we can potentially create a timeline with the same name either through a paste or a new timeline action
Timeline->Rename(NULL, GetTransientPackage(), (Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : REN_None));
}
Super::DestroyNode();
}
UTimelineTemplate* UBlueprint::FindTimelineTemplateByVariableName(const FName& TimelineName)
{
const FName TimelineTemplateName = *UTimelineTemplate::TimelineVariableNameToTemplateName(TimelineName);
UTimelineTemplate* Timeline = FBlueprintInnerHelper::FindObjectByName<UTimelineTemplate>(Timelines, TimelineTemplateName);
// >>> Backwards Compatibility: VER_UE4_EDITORONLY_BLUEPRINTS
if(Timeline)
{
ensure(Timeline->GetOuter() && Timeline->GetOuter()->IsA(UClass::StaticClass()));
}
else
{
Timeline = FBlueprintInnerHelper::FindObjectByName<UTimelineTemplate>(Timelines, TimelineName);
if(Timeline)
{
ensure(Timeline->GetOuter() && Timeline->GetOuter() == this);
}
}
// <<< End Backwards Compatibility
return Timeline;
}
void UK2Node_Timeline::PostPasteNode()
{
Super::PostPasteNode();
UBlueprint* Blueprint = GetBlueprint();
check(Blueprint);
UTimelineTemplate* OldTimeline = NULL;
//find the template with same UUID
for(TObjectIterator<UTimelineTemplate> It;It;++It)
{
UTimelineTemplate* Template = *It;
if(Template->TimelineGuid == TimelineGuid)
{
OldTimeline = Template;
break;
}
}
// Make sure TimelineName is unique, and we allocate a new timeline template object for this node
TimelineName = FBlueprintEditorUtils::FindUniqueTimelineName(Blueprint);
if(!OldTimeline)
{
if (UTimelineTemplate* Template = FBlueprintEditorUtils::AddNewTimeline(Blueprint, TimelineName))
{
bAutoPlay = Template->bAutoPlay;
bLoop = Template->bLoop;
}
}
else
{
check(NULL != Blueprint->GeneratedClass);
Blueprint->Modify();
const FName TimelineTemplateName = *UTimelineTemplate::TimelineVariableNameToTemplateName(TimelineName);
UTimelineTemplate* Template = DuplicateObject<UTimelineTemplate>(OldTimeline, Blueprint->GeneratedClass, *TimelineTemplateName.ToString());
bAutoPlay = Template->bAutoPlay;
bLoop = Template->bLoop;
Template->SetFlags(RF_Transactional);
Blueprint->Timelines.Add(Template);
// Fix up timeline tracks to point to the proper location. When duplicated, they're still parented to their old blueprints because we don't have the appropriate scope. Note that we never want to fix up external curve asset references
{
for( auto TrackIt = Template->FloatTracks.CreateIterator(); TrackIt; ++TrackIt )
{
FTTFloatTrack& Track = *TrackIt;
if(Track.CurveFloat->GetOuter()->IsA(UBlueprint::StaticClass()))
{
Track.CurveFloat->Rename(*Template->MakeUniqueCurveName(Track.CurveFloat, Track.CurveFloat->GetOuter()), Blueprint, REN_DontCreateRedirectors);
}
}
for( auto TrackIt = Template->EventTracks.CreateIterator(); TrackIt; ++TrackIt )
{
FTTEventTrack& Track = *TrackIt;
if(Track.CurveKeys->GetOuter()->IsA(UBlueprint::StaticClass()))
{
Track.CurveKeys->Rename(*Template->MakeUniqueCurveName(Track.CurveKeys, Track.CurveKeys->GetOuter()), Blueprint, REN_DontCreateRedirectors);
}
}
for( auto TrackIt = Template->VectorTracks.CreateIterator(); TrackIt; ++TrackIt )
{
FTTVectorTrack& Track = *TrackIt;
if(Track.CurveVector->GetOuter()->IsA(UBlueprint::StaticClass()))
{
Track.CurveVector->Rename(*Template->MakeUniqueCurveName(Track.CurveVector, Track.CurveVector->GetOuter()), Blueprint, REN_DontCreateRedirectors);
}
}
for( auto TrackIt = Template->LinearColorTracks.CreateIterator(); TrackIt; ++TrackIt )
{
FTTLinearColorTrack& Track = *TrackIt;
if(Track.CurveLinearColor->GetOuter()->IsA(UBlueprint::StaticClass()))
{
Track.CurveLinearColor->Rename(*Template->MakeUniqueCurveName(Track.CurveLinearColor, Track.CurveLinearColor->GetOuter()), Blueprint, REN_DontCreateRedirectors);
}
}
}
FBlueprintEditorUtils::ValidateBlueprintChildVariables(Blueprint, TimelineName);
FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(Blueprint);
}
}
bool UBlueprint::ChangeOwnerOfTemplates()
{
UBlueprintGeneratedClass* BPGClass = Cast<UBlueprintGeneratedClass>(*GeneratedClass);
bool bIsStillStale = false;
if (BPGClass)
{
check(!bIsRegeneratingOnLoad);
// >>> Backwards Compatibility: VER_UE4_EDITORONLY_BLUEPRINTS
bool bMigratedOwner = false;
for( auto CompIt = ComponentTemplates.CreateIterator(); CompIt; ++CompIt )
{
UActorComponent* Component = (*CompIt);
check(Component);
if(Component->GetOuter() == this)
{
const bool bRenamed = Component->Rename(*Component->GetName(), BPGClass, REN_ForceNoResetLoaders|REN_DoNotDirty);
ensure(bRenamed);
bIsStillStale |= !bRenamed;
bMigratedOwner = true;
}
}
for( auto CompIt = Timelines.CreateIterator(); CompIt; ++CompIt )
{
UTimelineTemplate* Template = (*CompIt);
check(Template);
if(Template->GetOuter() == this)
{
const FString OldTemplateName = Template->GetName();
ensure(!OldTemplateName.EndsWith(TEXT("_Template")));
const bool bRenamed = Template->Rename(*UTimelineTemplate::TimelineVariableNameToTemplateName(Template->GetFName()), BPGClass, REN_ForceNoResetLoaders|REN_DoNotDirty);
ensure(bRenamed);
bIsStillStale |= !bRenamed;
ensure(OldTemplateName == UTimelineTemplate::TimelineTemplateNameToVariableName(Template->GetFName()));
bMigratedOwner = true;
}
}
if(USimpleConstructionScript* SCS = SimpleConstructionScript)
{
if(SCS->GetOuter() == this)
{
const bool bRenamed = SCS->Rename(NULL, BPGClass, REN_ForceNoResetLoaders|REN_DoNotDirty);
ensure(bRenamed);
bIsStillStale |= !bRenamed;
bMigratedOwner = true;
}
}
if (bMigratedOwner)
{
BPGClass->ComponentTemplates = ComponentTemplates;
BPGClass->Timelines = Timelines;
BPGClass->SimpleConstructionScript = SimpleConstructionScript;
}
// <<< End Backwards Compatibility
}
else
{
UE_LOG(LogBlueprint, Log, TEXT("ChangeOwnerOfTemplates: No BlueprintGeneratedClass in %s"), *GetName());
}
return !bIsStillStale;
}
