void CreateAndWriteRecordForSession()
{
FGuid SessionId;
if (FGuid::Parse(FEngineAnalytics::GetProvider().GetSessionID(), SessionId))
{
// convert session guid to one without braces or other chars that might not be suitable for storage
CurrentSession.SessionId = SessionId.ToString(EGuidFormats::DigitsWithHyphens);
}
else
{
CurrentSession.SessionId = FEngineAnalytics::GetProvider().GetSessionID();
}
CurrentSession.EngineVersion = FEngineVersion::Current().ToString(EVersionComponent::Changelist);
CurrentSession.Timestamp = FDateTime::UtcNow();
CurrentSession.bCrashed = false;
CurrentSession.bIsDebugger = FPlatformMisc::IsDebuggerPresent();
CurrentSessionSectionName = GetStoreSectionString(CurrentSession.SessionId);
FString IsDebuggerString = CurrentSession.bIsDebugger ? EditorAnalyticsDefs::TrueValueString : EditorAnalyticsDefs::FalseValueString;
FPlatformMisc::SetStoredValue(EditorAnalyticsDefs::StoreId, CurrentSessionSectionName, EditorAnalyticsDefs::CrashStoreKey, EditorAnalyticsDefs::FalseValueString);
FPlatformMisc::SetStoredValue(EditorAnalyticsDefs::StoreId, CurrentSessionSectionName, EditorAnalyticsDefs::EngineVersionStoreKey, CurrentSession.EngineVersion);
FPlatformMisc::SetStoredValue(EditorAnalyticsDefs::StoreId, CurrentSessionSectionName, EditorAnalyticsDefs::TimestampStoreKey, TimestampToString(CurrentSession.Timestamp));
FPlatformMisc::SetStoredValue(EditorAnalyticsDefs::StoreId, CurrentSessionSectionName, EditorAnalyticsDefs::DebuggerStoreKey, IsDebuggerString);
SessionRecords.Add(CurrentSession);
}
/**
* Start capturing stats for upload
* Uses the unique ApiKey associated with your app
*/
bool FAnalyticsProviderET::StartSession(const TArray<FAnalyticsEventAttribute>& Attributes)
{
UE_LOG(LogAnalytics, Log, TEXT("[%s] AnalyticsET::StartSession"),*APIKey);
// end/flush previous session before staring new one
if (bSessionInProgress)
{
EndSession();
}
FGuid SessionGUID;
FPlatformMisc::CreateGuid(SessionGUID);
SessionID = SessionGUID.ToString(EGuidFormats::DigitsWithHyphensInBraces);
// always ensure we send a few specific attributes on session start.
TArray<FAnalyticsEventAttribute> AppendedAttributes(Attributes);
// this is for legacy reasons (we used to use this ID, so helps us create old->new mappings).
AppendedAttributes.Emplace(TEXT("UniqueDeviceId"), FPlatformMisc::GetUniqueDeviceId());
// we should always know what platform is hosting this session.
AppendedAttributes.Emplace(TEXT("Platform"), FString(FPlatformProperties::IniPlatformName()));
AppendedAttributes.Emplace(TEXT("LegacyURL"), bUsingLegacyAppServer ? TEXT("true") : TEXT("false"));
RecordEvent(TEXT("SessionStart"), AppendedAttributes);
bSessionInProgress = true;
return bSessionInProgress;
}
bool FParticleTrackEditor::AddKeyInternal( float KeyTime, const TArray<TWeakObjectPtr<UObject>> Objects )
{
bool bHandleCreated = false;
bool bTrackCreated = false;
for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex )
{
UObject* Object = Objects[ObjectIndex].Get();
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject( Object );
FGuid ObjectHandle = HandleResult.Handle;
bHandleCreated |= HandleResult.bWasCreated;
if (ObjectHandle.IsValid())
{
FFindOrCreateTrackResult TrackResult = FindOrCreateTrackForObject(ObjectHandle, UMovieSceneParticleTrack::StaticClass());
UMovieSceneTrack* Track = TrackResult.Track;
bTrackCreated |= TrackResult.bWasCreated;
if (bTrackCreated && ensure(Track))
{
UMovieSceneParticleTrack* ParticleTrack = Cast<UMovieSceneParticleTrack>(Track);
ParticleTrack->AddNewSection(KeyTime);
ParticleTrack->SetDisplayName(LOCTEXT("TrackName", "Particle System"));
}
}
}
return bHandleCreated || bTrackCreated;
}
void FMarginTrackEditor::OnKeyMargin( float KeyTime, const FPropertyChangedParams* PropertyChangedParams )
{
FMargin MarginValue = *PropertyChangedParams->GetPropertyValue<FMargin>();
FName PropertyName = PropertyChangedParams->PropertyPath.Last()->GetFName();
for( int32 ObjectIndex = 0; ObjectIndex < PropertyChangedParams->ObjectsThatChanged.Num(); ++ObjectIndex )
{
UObject* Object = PropertyChangedParams->ObjectsThatChanged[ObjectIndex];
FMarginKey Key;
Key.bAddKeyEvenIfUnchanged = !PropertyChangedParams->bRequireAutoKey;
Key.CurveName = PropertyChangedParams->StructPropertyNameToKey;
Key.Value = MarginValue;
FGuid ObjectHandle = FindOrCreateHandleToObject( Object );
if (ObjectHandle.IsValid())
{
UMovieSceneTrack* Track = GetTrackForObject( ObjectHandle, UMovieSceneMarginTrack::StaticClass(), PropertyName );
if( ensure( Track ) )
{
UMovieSceneMarginTrack* MarginTrack = CastChecked<UMovieSceneMarginTrack>(Track);
MarginTrack->SetPropertyNameAndPath( PropertyName, PropertyChangedParams->GetPropertyPathString() );
// Find or add a new section at the auto-key time and changing the property same property
// AddKeyToSection is not actually a virtual, it's redefined in each class with a different type
bool bSuccessfulAdd = MarginTrack->AddKeyToSection( KeyTime, Key );
if (bSuccessfulAdd)
{
MarginTrack->SetAsShowable();
}
}
}
}
}
/**
* @EventName Editor.AbnormalShutdown
*
* @Trigger Fired only by the editor at startup, once for each "abnormal shutdown" detected that has not already been sent.
*
* @Type Static
*
* @EventParam SessionId Analytics SessionID of the session that abnormally terminated.
* @EventParam EngineVersion EngineVersion of the session that abnormally terminated.
* @EventParam ShutdownType - one of Crashed, Debugger, or AbormalShutdown
* * Crashed - we definitely detected a crash (whether or not a debugger was attached)
* * Debugger - the session crashed or shutdown abnormally, but we had a debugger attached at startup, so abnormal termination is much more likely because the user was debugging.
* * AbnormalShutdown - this happens when we didn't detect a normal shutdown, but none of the above cases is the cause.
* @EventParam Timestamp - the UTC time of the last known time the crashed session was running, within 5 minutes.
*
* @TODO: Debugger should be a completely separate flag, since it's orthogonal to whether we detect a crash or shutdown.
*
* @Comments The editor will only try to check for abnormal terminations if it determines it is a real editor run (not a commandlet or PIE, or editor -game run), and the user has not disabled sending Engine Usage data to Epic via the Editor global preferences.
*
* SessionId can be used to find the actual session associated with this crash in the data.
*
* Use THIS instead of the current event's analytics AppVersion field, since the crash could be from an old version. Could technically be found by searching the data for the SessionId and checking the version there, but sending it here simplifies the backend processing and ensure we have the version here even if we never got the original events.
*
* If multiple versions of the editor or launched, this code will properly track each one and its shutdown status. So during startup, an editor instance may need to fire off several events.
*
* When attributing abnormal terminations to engine versions, be sure to use the EngineVersion associated with this event, and not the AppVersion. AppVersion is for the session that is currently sending the event, not for the session that crashed. That is why EngineVersion is sent separately.
*
* The editor updates this timestamp every 5 minutes, so we should know the time of the crash within 5 minutes. It should technically correlate with the last heartbeat we receive in the data for that session.
*/
void SendAbnormalShutdownReport(const FSessionRecord& Record)
{
FGameProjectGenerationModule& GameProjectModule = FModuleManager::LoadModuleChecked<FGameProjectGenerationModule>(TEXT("GameProjectGeneration"));
bool bHasCode = GameProjectModule.Get().ProjectHasCodeFiles();
#if PLATFORM_WINDOWS
const FString PlatformName(TEXT("Windows"));
#elif PLATFORM_MAC
const FString PlatformName(TEXT("Mac"));
#elif PLATFORM_LINUX
const FString PlatformName(TEXT("Linux"));
#else
const FString PlatformName(TEXT("Unknown"));
#endif
FGuid SessionId;
FString SessionIdString = Record.SessionId;
if (FGuid::Parse(SessionIdString, SessionId))
{
// convert session guid to one with braces for sending to analytics
SessionIdString = SessionId.ToString(EGuidFormats::DigitsWithHyphensInBraces);
}
FString ShutdownTypeString = Record.bCrashed ? EditorAnalyticsDefs::CrashSessionToken :
(Record.bIsDebugger ? EditorAnalyticsDefs::DebuggerSessionToken : EditorAnalyticsDefs::AbnormalSessionToken);
TArray< FAnalyticsEventAttribute > AbnormalShutdownAttributes;
AbnormalShutdownAttributes.Add(FAnalyticsEventAttribute(FString("SessionId"), SessionIdString));
AbnormalShutdownAttributes.Add(FAnalyticsEventAttribute(FString("EngineVersion"), Record.EngineVersion));
AbnormalShutdownAttributes.Add(FAnalyticsEventAttribute(FString("ShutdownType"), ShutdownTypeString));
AbnormalShutdownAttributes.Add(FAnalyticsEventAttribute(FString("Timestamp"), Record.Timestamp.ToIso8601()));
FEditorAnalytics::ReportEvent(TEXT("Editor.AbnormalShutdown"), PlatformName, bHasCode, AbnormalShutdownAttributes);
}
// Have a similar process function for the normal tcp connection.
void FNetworkFileServerHttp::Process(FArchive& In, TArray<uint8>&Out, FNetworkFileServerHttp* Server)
{
int loops = 0;
while(!In.AtEnd())
{
UE_LOG(LogFileServer, Log, TEXT("In %d "), loops++);
// Every Request has a Guid attached to it - similar to Web session IDs.
FGuid ClientGuid;
In << ClientGuid;
UE_LOG(LogFileServer, Log, TEXT("Recieved GUID %s"), *ClientGuid.ToString());
FNetworkFileServerClientConnectionHTTP* Connection = NULL;
if (Server->RequestHandlers.Contains(ClientGuid))
{
UE_LOG(LogFileServer, Log, TEXT("Picking up an existing handler" ));
Connection = Server->RequestHandlers[ClientGuid];
}
else
{
UE_LOG(LogFileServer, Log, TEXT("Creating a handler" ));
Connection = Server->CreateNewConnection();
Server->RequestHandlers.Add(ClientGuid,Connection);
}
Connection->ProcessPayload(In);
Out.Append(Connection->GetOutBuffer());
Connection->ResetBuffer();
}
}
FKeyPropertyResult FFaceFXAnimationTrackEditor::AddFaceFXSection(FFrameNumber KeyTime, UObject* Object, FFaceFXAnimComponentSet AnimCompSet)
{
FKeyPropertyResult result;
bool bHandleCreated = false;
bool bTrackCreated = false;
bool bTrackModified = false;
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject(Object);
FGuid ObjectHandle = HandleResult.Handle;
result.bHandleCreated |= HandleResult.bWasCreated;
if (ObjectHandle.IsValid())
{
FFindOrCreateTrackResult TrackResult = FindOrCreateTrackForObject(ObjectHandle, UFaceFXAnimationTrack::StaticClass());
UMovieSceneTrack* Track = TrackResult.Track;
result.bTrackCreated |= TrackResult.bWasCreated;
if (UFaceFXAnimationTrack* AnimTrack = Cast<UFaceFXAnimationTrack>(Track))
{
AnimTrack->AddSection(KeyTime, AnimCompSet);
result.bTrackModified = true;
}
}
return result;
}
void FOnlineSessionInfoNull::Init(const FOnlineSubsystemNull& Subsystem)
{
// Read the IP from the system
bool bCanBindAll;
HostAddr = ISocketSubsystem::Get()->GetLocalHostAddr(*GLog, bCanBindAll);
// The below is a workaround for systems that set hostname to a distinct address from 127.0.0.1 on a loopback interface.
// See e.g. https://www.debian.org/doc/manuals/debian-reference/ch05.en.html#_the_hostname_resolution
// and http://serverfault.com/questions/363095/why-does-my-hostname-appear-with-the-address-127-0-1-1-rather-than-127-0-0-1-in
// Since we bind to 0.0.0.0, we won't answer on 127.0.1.1, so we need to advertise ourselves as 127.0.0.1 for any other loopback address we may have.
uint32 HostIp = 0;
HostAddr->GetIp(HostIp); // will return in host order
// if this address is on loopback interface, advertise it as 127.0.0.1
if ((HostIp & 0xff000000) == 0x7f000000)
{
HostAddr->SetIp(0x7f000001); // 127.0.0.1
}
// Now set the port that was configured
HostAddr->SetPort(GetPortFromNetDriver(Subsystem.GetInstanceName()));
FGuid OwnerGuid;
FPlatformMisc::CreateGuid(OwnerGuid);
SessionId = FUniqueNetIdString(OwnerGuid.ToString());
}
void FMovieScene3DConstraintTrackInstance::Update( float Position, float LastPosition, const TArray<UObject*>& RuntimeObjects, class IMovieScenePlayer& Player, FMovieSceneSequenceInstance& SequenceInstance, EMovieSceneUpdatePass UpdatePass )
{
UMovieScene3DConstraintSection* FirstConstraintSection = nullptr;
const TArray<UMovieSceneSection*>& ConstraintSections = ConstraintTrack->GetAllSections();
for (int32 ConstraintIndex = 0; ConstraintIndex < ConstraintSections.Num(); ++ConstraintIndex)
{
UMovieScene3DConstraintSection* ConstraintSection = CastChecked<UMovieScene3DConstraintSection>(ConstraintSections[ConstraintIndex]);
if (ConstraintSection->IsTimeWithinSection(Position) &&
(FirstConstraintSection == nullptr || FirstConstraintSection->GetRowIndex() > ConstraintSection->GetRowIndex()))
{
TArray<UObject*> ConstraintObjects;
FGuid ConstraintId = ConstraintSection->GetConstraintId();
if (ConstraintId.IsValid())
{
Player.GetRuntimeObjects( Player.GetRootMovieSceneSequenceInstance(), ConstraintId, ConstraintObjects);
for (int32 ConstraintObjectIndex = 0; ConstraintObjectIndex < ConstraintObjects.Num(); ++ConstraintObjectIndex)
{
AActor* Actor = Cast<AActor>(ConstraintObjects[ConstraintObjectIndex]);
if (Actor)
{
UpdateConstraint(Position, RuntimeObjects, Actor, ConstraintSection);
}
}
}
}
}
}
UProperty* UUserDefinedStruct::CustomFindProperty(const FName Name) const
{
const FGuid Guid = FStructureEditorUtils::GetGuidFromPropertyName(Name);
UProperty* Property = Guid.IsValid() ? FStructureEditorUtils::GetPropertyByGuid(this, Guid) : NULL;
ensure(!Property || Guid == FStructureEditorUtils::GetGuidForProperty(Property));
return Property;
}
void FProfilerClientManager::Subscribe( const FGuid& Session )
{
#if STATS
FGuid OldSessionId = ActiveSessionId;
PendingSessionId = Session;
if (MessageEndpoint.IsValid())
{
if (OldSessionId.IsValid())
{
TArray<FGuid> Instances;
Connections.GenerateKeyArray(Instances);
for (int32 i = 0; i < Instances.Num(); ++i)
{
MessageEndpoint->Publish(new FProfilerServiceUnsubscribe(OldSessionId, Instances[i]), EMessageScope::Network);
// fire the disconnection delegate
ProfilerClientDisconnectedDelegate.Broadcast(ActiveSessionId, Instances[i]);
}
ActiveSessionId.Invalidate();
}
ActiveSessionId = PendingSessionId;
}
Connections.Reset();
#endif
}
bool F3DAttachTrackEditor::AddKeyInternal( float KeyTime, const TArray<TWeakObjectPtr<UObject>> Objects, const FName SocketName, const FName ComponentName, AActor* ParentActor)
{
bool bHandleCreated = false;
bool bTrackCreated = false;
bool bTrackModified = false;
FGuid ParentActorId;
if (ParentActor != nullptr)
{
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject(ParentActor);
ParentActorId = HandleResult.Handle;
bHandleCreated |= HandleResult.bWasCreated;
}
if (!ParentActorId.IsValid())
{
return false;
}
for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex )
{
UObject* Object = Objects[ObjectIndex].Get();
FFindOrCreateHandleResult HandleResult = FindOrCreateHandleToObject( Object );
FGuid ObjectHandle = HandleResult.Handle;
bHandleCreated |= HandleResult.bWasCreated;
if (ObjectHandle.IsValid())
{
FFindOrCreateTrackResult TrackResult = FindOrCreateTrackForObject( ObjectHandle, UMovieScene3DAttachTrack::StaticClass());
UMovieSceneTrack* Track = TrackResult.Track;
bTrackCreated |= TrackResult.bWasCreated;
if (ensure(Track))
{
// Clamp to next attach section's start time or the end of the current sequencer view range
float AttachEndTime = GetSequencer()->GetViewRange().GetUpperBoundValue();
for (int32 AttachSectionIndex = 0; AttachSectionIndex < Track->GetAllSections().Num(); ++AttachSectionIndex)
{
float StartTime = Track->GetAllSections()[AttachSectionIndex]->GetStartTime();
float EndTime = Track->GetAllSections()[AttachSectionIndex]->GetEndTime();
if (KeyTime < StartTime)
{
if (AttachEndTime > StartTime)
{
AttachEndTime = StartTime;
}
}
}
Cast<UMovieScene3DAttachTrack>(Track)->AddConstraint( KeyTime, AttachEndTime, SocketName, ComponentName, ParentActorId );
bTrackModified = true;
}
}
}
return bHandleCreated || bTrackCreated || bTrackModified;
}
CefRefPtr<CefDictionaryValue> FUnrealCEFSubProcessRemoteScripting::V8FunctionToCef(CefRefPtr<CefV8Value> Object, CefRefPtr<CefV8Value> Function)
{
CefRefPtr<CefDictionaryValue> Result = CefDictionaryValue::Create();
FGuid Guid = CallbackRegistry.FindOrAdd(CefV8Context::GetCurrentContext(), Object, Function);
Result->SetString("$type", "callback");
Result->SetString("$id", *Guid.ToString(EGuidFormats::Digits));
Result->SetString("$name", Function->GetFunctionName());
return Result;
}
void FCameraCutTrackEditor::HandleAddCameraCutComboButtonMenuEntryExecute(AActor* Camera)
{
FGuid ObjectGuid = FindOrCreateHandleToObject(Camera).Handle;
if (ObjectGuid.IsValid())
{
AnimatablePropertyChanged(FOnKeyProperty::CreateRaw(this, &FCameraCutTrackEditor::AddKeyInternal, ObjectGuid));
}
}
FGuid FSequencer::GetHandleToObject( UObject* Object )
{
TSharedRef<FMovieSceneInstance> FocusedMovieSceneInstance = GetFocusedMovieSceneInstance();
UMovieScene* FocusedMovieScene = FocusedMovieSceneInstance->GetMovieScene();
FGuid ObjectGuid = ObjectBindingManager->FindGuidForObject( *FocusedMovieScene, *Object );
if (ObjectGuid.IsValid())
{
// Make sure that the possessable is still valid, if it's not remove the binding so new one
// can be created. This can happen due to undo.
FMovieScenePossessable* Possessable = FocusedMovieScene->FindPossessable(ObjectGuid);
if (Possessable == nullptr )
{
ObjectBindingManager->UnbindPossessableObjects(ObjectGuid);
ObjectGuid.Invalidate();
}
}
bool bPossessableAdded = false;
// If the object guid was not found attempt to add it
// Note: Only possessed actors can be added like this
if( !ObjectGuid.IsValid() && ObjectBindingManager->CanPossessObject( *Object ) )
{
// @todo sequencer: Undo doesn't seem to be working at all
const FScopedTransaction Transaction( LOCTEXT("UndoPossessingObject", "Possess Object with MovieScene") );
// Possess the object!
{
// Create a new possessable
FocusedMovieScene->Modify();
ObjectGuid = FocusedMovieScene->AddPossessable( Object->GetName(), Object->GetClass() );
if ( IsShotFilteringOn() )
{
AddUnfilterableObject(ObjectGuid);
}
ObjectBindingManager->BindPossessableObject( ObjectGuid, *Object );
bPossessableAdded = true;
}
}
if( bPossessableAdded )
{
SpawnOrDestroyPuppetObjects( GetFocusedMovieSceneInstance() );
NotifyMovieSceneDataChanged();
}
return ObjectGuid;
}
void FUdpMessageProcessor::ProcessHelloSegment( FInboundSegment& Segment, FNodeInfo& NodeInfo )
{
FGuid RemoteNodeId;
*Segment.Data << RemoteNodeId;
if (RemoteNodeId.IsValid())
{
NodeInfo.ResetIfRestarted(RemoteNodeId);
}
}
FArchive* CreateOutputArchive()
{
FArchive* OutputFilePtr = nullptr;
if (CommunicationMode == ThroughFile)
{
const double StartTime = FPlatformTime::Seconds();
bool bResult = false;
// It seems XGE does not support deleting files.
// Don't delete the input file if we are running under Incredibuild.
// Instead, we signal completion by creating a zero byte "Success" file after the output file has been fully written.
if (!GShaderCompileUseXGE)
{
do
{
// Remove the input file so that it won't get processed more than once
bResult = IFileManager::Get().Delete(*InputFilePath);
}
while (!bResult && (FPlatformTime::Seconds() - StartTime < 2));
if (!bResult)
{
UE_LOG(LogShaders, Fatal,TEXT("Couldn't delete input file %s, is it readonly?"), *InputFilePath);
}
}
// To make sure that the process waiting for results won't read unfinished output file,
// we use a temp file name during compilation.
do
{
FGuid Guid;
FPlatformMisc::CreateGuid(Guid);
TempFilePath = WorkingDirectory + Guid.ToString();
} while (IFileManager::Get().FileSize(*TempFilePath) != INDEX_NONE);
const double StartTime2 = FPlatformTime::Seconds();
do
{
// Create the output file.
OutputFilePtr = IFileManager::Get().CreateFileWriter(*TempFilePath,FILEWRITE_EvenIfReadOnly);
}
while (!OutputFilePtr && (FPlatformTime::Seconds() - StartTime2 < 2));
if (!OutputFilePtr)
{
UE_LOG(LogShaders, Fatal,TEXT("Couldn't save output file %s"), *TempFilePath);
}
}
return OutputFilePtr;
}
void FUdpMessageProcessor::ProcessByeSegment( FInboundSegment& Segment, FNodeInfo& NodeInfo )
{
FGuid RemoteNodeId;
*Segment.Data << RemoteNodeId;
if (RemoteNodeId.IsValid())
{
if (NodeInfo.NodeId == RemoteNodeId)
{
RemoveKnownNode(RemoteNodeId);
}
}
}
bool FUnrealCEFSubProcessRemoteObject::ExecuteMethod(const CefString& MethodName, CefRefPtr<CefV8Value> Object, const CefV8ValueList& Arguments, CefRefPtr<CefV8Value>& Retval, CefString& InException)
{
CefRefPtr<CefV8Context> Context = CefV8Context::GetCurrentContext();
CefRefPtr<CefV8Exception> Exception;
CefRefPtr<CefV8Value> PromiseObjects;
// Run JS code that creates and unwraps a Promise object
if (!Context->Eval(
"(function() " \
"{ "
" var Accept, Reject, PromiseObject;" \
" PromiseObject = new Promise(function(InAccept, InReject) " \
" {"
" Accept = InAccept;" \
" Reject = InReject;" \
" });" \
" return [PromiseObject, Accept, Reject];" \
"})()" , PromiseObjects, Exception))
{
InException = Exception->GetMessage();
return false;
}
if (!(PromiseObjects.get() && PromiseObjects->IsArray() && PromiseObjects->GetArrayLength() == 3))
{
return false;
}
Retval = PromiseObjects->GetValue(0);
CefRefPtr<CefV8Value> Accept = PromiseObjects->GetValue(1);
CefRefPtr<CefV8Value> Reject = PromiseObjects->GetValue(2);
check(Retval->IsObject());
check(Accept->IsFunction());
check(Reject->IsFunction());
FGuid CallbackGuid = RemoteScripting->CallbackRegistry.FindOrAdd(Context, Retval, Accept, Reject, true);
CefRefPtr<CefProcessMessage> Message = CefProcessMessage::Create("UE::ExecuteUObjectMethod");
CefRefPtr<CefListValue> MessageArguments = Message->GetArgumentList();
MessageArguments->SetString(0, CefString(*ObjectId.ToString(EGuidFormats::Digits)));
MessageArguments->SetString(1, MethodName);
MessageArguments->SetString(2, CefString(*CallbackGuid.ToString(EGuidFormats::Digits)));
MessageArguments->SetList(3, RemoteScripting->V8ArrayToCef(Arguments));
Browser->SendProcessMessage(PID_BROWSER, Message);
return true;
}
void FProfilerClientManager::RequestLastCapturedFile( const FGuid& InstanceId /*= FGuid()*/ )
{
#if STATS
if (MessageEndpoint.IsValid() && ActiveSessionId.IsValid())
{
if( !InstanceId.IsValid() )
{
TArray<FMessageAddress> Instances;
for (auto It = Connections.CreateConstIterator(); It; ++It)
{
Instances.Add(It.Value().ServiceAddress);
}
MessageEndpoint->Send(new FProfilerServiceRequest(EProfilerRequestType::PRT_SendLastCapturedFile), Instances);
}
else
{
const FMessageAddress* MessageAddress = &Connections.Find(InstanceId)->ServiceAddress;
if( MessageAddress )
{
MessageEndpoint->Send(new FProfilerServiceRequest(EProfilerRequestType::PRT_SendLastCapturedFile), *MessageAddress);
}
}
}
#endif
}
void FProfilerActionManager::ToggleDataPreview_Execute( const FGuid SessionInstanceID )
{
// One session instance
if( SessionInstanceID.IsValid() )
{
const FProfilerSessionRef* ProfilerSessionPtr = This->FindSessionInstance( SessionInstanceID );
if( ProfilerSessionPtr )
{
(*ProfilerSessionPtr)->bDataPreviewing = !(*ProfilerSessionPtr)->bDataPreviewing;
This->ProfilerClient->SetPreviewState( (*ProfilerSessionPtr)->bDataPreviewing, SessionInstanceID );
}
const bool bDataPreviewing = This->IsDataPreviewing();
if( !bDataPreviewing )
{
This->bLivePreview = false;
}
}
// All session instances
else
{
const bool bDataPreviewing = !This->IsDataPreviewing();
This->SetDataPreview( bDataPreviewing );
if( !bDataPreviewing )
{
This->bLivePreview = false;
}
}
}
void FProfilerClientManager::SetPreviewState( const bool bRequestedPreviewState, const FGuid& InstanceId /*= FGuid()*/ )
{
#if STATS
if (MessageEndpoint.IsValid() && ActiveSessionId.IsValid())
{
if( !InstanceId.IsValid() )
{
TArray<FMessageAddress> Instances;
for (auto It = Connections.CreateConstIterator(); It; ++It)
{
Instances.Add(It.Value().ServiceAddress);
}
MessageEndpoint->Send(new FProfilerServicePreview(bRequestedPreviewState), Instances);
}
else
{
const FMessageAddress* MessageAddress = &Connections.Find(InstanceId)->ServiceAddress;
if( MessageAddress )
{
MessageEndpoint->Send(new FProfilerServicePreview(bRequestedPreviewState), *MessageAddress);
}
}
}
#endif
}
bool UMovieScene::RemoveSpawnable( const FGuid& Guid )
{
bool bAnythingRemoved = false;
if( ensure( Guid.IsValid() ) )
{
for( auto SpawnableIter( Spawnables.CreateIterator() ); SpawnableIter; ++SpawnableIter )
{
auto& CurSpawnable = *SpawnableIter;
if( CurSpawnable.GetGuid() == Guid )
{
Modify();
{
UClass* GeneratedClass = CurSpawnable.GetClass();
UBlueprint* Blueprint = GeneratedClass ? Cast<UBlueprint>(GeneratedClass->ClassGeneratedBy) : NULL;
check(NULL != Blueprint);
// @todo sequencer: Also remove created Blueprint inner object. Is this sufficient? Needs to work with Undo too!
Blueprint->ClearFlags( RF_Standalone ); // @todo sequencer: Probably not needed for Blueprint
Blueprint->MarkPendingKill();
}
RemoveObjectBinding( Guid );
// Found it!
Spawnables.RemoveAt( SpawnableIter.GetIndex() );
bAnythingRemoved = true;
break;
}
}
}
return bAnythingRemoved;
}
bool IsValid() const
{
return
MagicNumber == TCP_MESSAGING_TRANSPORT_PROTOCOL_MAGIC &&
Version == ETcpMessagingVersion::OldestSupportedVersion &&
NodeId.IsValid();
}
static FName Generate(UUserDefinedStruct* Struct, const FString& NameBase, const FGuid Guid, FString* OutFriendlyName = NULL)
{
check(Struct);
FString Result;
if (!NameBase.IsEmpty())
{
const FName NewNameBase(*NameBase);
if (ensure(NewNameBase.IsValidXName(INVALID_OBJECTNAME_CHARACTERS)))
{
Result = NameBase;
}
}
if (Result.IsEmpty())
{
Result = TEXT("MemberVar");
}
const uint32 UniqueNameId = CastChecked<UUserDefinedStructEditorData>(Struct->EditorData)->GenerateUniqueNameIdForMemberVariable();
const FString FriendlyName = FString::Printf(TEXT("%s_%u"), *Result, UniqueNameId);
if (OutFriendlyName)
{
*OutFriendlyName = FriendlyName;
}
const FName NameResult = *FString::Printf(TEXT("%s_%s"), *FriendlyName, *Guid.ToString(EGuidFormats::Digits));
check(NameResult.IsValidXName(INVALID_OBJECTNAME_CHARACTERS));
return NameResult;
}
void FParticleTrackEditor::AddKeyInternal( float KeyTime, const TArray<UObject*> Objects, bool bTrigger)
{
for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex )
{
UObject* Object = Objects[ObjectIndex];
FGuid ObjectHandle = FindOrCreateHandleToObject( Object );
if (ObjectHandle.IsValid())
{
UMovieSceneTrack* Track = GetTrackForObject( ObjectHandle, UMovieSceneParticleTrack::StaticClass(), FName("ParticleSystem"));
if (ensure(Track))
{
Cast<UMovieSceneParticleTrack>(Track)->AddNewParticleSystem( KeyTime, bTrigger );
}
}
}
}
void FAnimationTrackEditor::AddKeyInternal( float KeyTime, const TArray<UObject*> Objects, class UAnimSequence* AnimSequence )
{
for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex )
{
UObject* Object = Objects[ObjectIndex];
FGuid ObjectHandle = FindOrCreateHandleToObject( Object );
if (ObjectHandle.IsValid())
{
UMovieSceneTrack* Track = GetTrackForObject( ObjectHandle, UMovieSceneAnimationTrack::StaticClass(), FName("Animation"));
if (ensure(Track))
{
Cast<UMovieSceneAnimationTrack>(Track)->AddNewAnimation( KeyTime, AnimSequence );
}
}
}
}
void FWebJSScripting::InvokeJSFunction(FGuid FunctionId, const CefRefPtr<CefListValue>& FunctionArguments, bool bIsError)
{
CefRefPtr<CefProcessMessage> Message = CefProcessMessage::Create(TEXT("UE::ExecuteJSFunction"));
CefRefPtr<CefListValue> MessageArguments = Message->GetArgumentList();
MessageArguments->SetString(0, *FunctionId.ToString(EGuidFormats::Digits));
MessageArguments->SetList(1, FunctionArguments);
MessageArguments->SetBool(2, bIsError);
SendProcessMessage(Message);
}
TSharedRef<FObjectBindingNode> FSequencerNodeTree::AddObjectBinding(const FString& ObjectName, const FGuid& ObjectBinding, TMap<FGuid, const FMovieSceneBinding*>& GuidToBindingMap, TArray< TSharedRef<FSequencerDisplayNode> >& OutNodeList)
{
TSharedPtr<FObjectBindingNode> ObjectNode;
TSharedPtr<FObjectBindingNode>* FoundObjectNode = ObjectBindingMap.Find(ObjectBinding);
if (FoundObjectNode != nullptr)
{
ObjectNode = *FoundObjectNode;
}
else
{
// The node name is the object guid
FName ObjectNodeName = *ObjectBinding.ToString();
// Try to get the parent object node if there is one.
TSharedPtr<FObjectBindingNode> ParentNode;
TArray<UObject*> RuntimeObjects;
UMovieSceneSequence* Animation = Sequencer.GetFocusedMovieSceneSequence();
UObject* RuntimeObject = Animation->FindObject(ObjectBinding);
if ( RuntimeObject != nullptr)
{
UObject* ParentObject = Animation->GetParentObject(RuntimeObject);
if (ParentObject != nullptr)
{
FGuid ParentBinding = Animation->FindObjectId(*ParentObject);
TSharedPtr<FObjectBindingNode>* FoundParentNode = ObjectBindingMap.Find( ParentBinding );
if ( FoundParentNode != nullptr )
{
ParentNode = *FoundParentNode;
}
else
{
const FMovieSceneBinding** FoundParentMovieSceneBinding = GuidToBindingMap.Find( ParentBinding );
if ( FoundParentMovieSceneBinding != nullptr )
{
ParentNode = AddObjectBinding( (*FoundParentMovieSceneBinding)->GetName(), ParentBinding, GuidToBindingMap, OutNodeList );
}
}
}
}
// Create the node.
ObjectNode = MakeShareable( new FObjectBindingNode( ObjectNodeName, ObjectName, ObjectBinding, ParentNode, *this ) );
if (ParentNode.IsValid())
{
ParentNode->AddObjectBindingNode(ObjectNode.ToSharedRef());
}
else
{
OutNodeList.Add( ObjectNode.ToSharedRef() );
}
// Map the guid to the object binding node for fast lookup later
ObjectBindingMap.Add( ObjectBinding, ObjectNode );
}
return ObjectNode.ToSharedRef();
}
void FSequencerObjectBindingNode::HandleLabelsSubMenuCreate(FMenuBuilder& MenuBuilder)
{
const TSet< TSharedRef<FSequencerDisplayNode> >& SelectedNodes = GetSequencer().GetSelection().GetSelectedOutlinerNodes();
TArray<FGuid> ObjectBindingIds;
for (TSharedRef<const FSequencerDisplayNode> SelectedNode : SelectedNodes )
{
if (SelectedNode->GetType() == ESequencerNode::Object)
{
TSharedRef<const FSequencerObjectBindingNode> ObjectBindingNode = StaticCastSharedRef<const FSequencerObjectBindingNode>(SelectedNode);
FGuid ObjectBindingId = ObjectBindingNode->GetObjectBinding();
if (ObjectBindingId.IsValid())
{
ObjectBindingIds.Add(ObjectBindingId);
}
}
}
MenuBuilder.AddWidget(SNew(SSequencerLabelEditor, GetSequencer(), ObjectBindingIds), FText::GetEmpty(), true);
}
