bool UPawnActionsComponent::OnEvent(UPawnAction& Action, EPawnActionEventType::Type Event)
{
bool bResult = false;
const FPawnActionEvent ActionEvent(Action, Event, ActionEventIndex++);
if (Event != EPawnActionEventType::Invalid && ActionEvents.Find(ActionEvent) == INDEX_NONE)
{
ActionEvents.Add(ActionEvent);
// if it's a first even enable tick
if (ActionEvents.Num() == 1)
{
SetComponentTickEnabled(true);
}
bResult = true;
}
else if (Event == EPawnActionEventType::Invalid)
{
// ignore
UE_VLOG(ControlledPawn, LogPawnAction, Warning, TEXT("Ignoring Action Event: Action %s Event %s")
, *Action.GetName(), *GetEventName(Event));
}
else
{
UE_VLOG(ControlledPawn, LogPawnAction, Warning, TEXT("Ignoring duplicate Action Event: Action %s Event %s")
, *Action.GetName(), *GetEventName(Event));
}
return bResult;
}
void CHotKey::Save(std::ostream& OutFile) const
#else
void CHotKey::Save(ostream& OutFile) const
#endif
{
//write out the event name
#if _MSC_VER >= 1300
OutFile << strlen(GetEventName()) << std::endl;
OutFile << GetEventName() << std::endl;
//write out the event name
OutFile << strlen(GetDescription()) << std::endl;
OutFile << GetDescription() << std::endl;
//write out if it is modifiable or not
OutFile << ((IsUserChangable()) ? 1 : 0) << std::endl;
#else
OutFile << strlen(GetEventName()) << endl;
OutFile << GetEventName() << endl;
//write out the event name
OutFile << strlen(GetDescription()) << endl;
OutFile << GetDescription() << endl;
//write out if it is modifiable or not
OutFile << ((IsUserChangable()) ? 1 : 0) << endl;
#endif
//lists that we need to save
const CUIEventList* pLists[] = {&m_StartEventList, &m_EndEventList};
for(uint32 nCurrList = 0; nCurrList < sizeof(pLists) / sizeof(pLists[0]); nCurrList++)
{
//write out the number of events in the current list
uint32 nNumEvents = pLists[nCurrList]->GetSize();
#if _MSC_VER >= 1300
OutFile << nNumEvents << std::endl;
#else
OutFile << nNumEvents << endl;
#endif
for(uint32 nCurrEvent = 0; nCurrEvent < nNumEvents; nCurrEvent++)
{
//cache the event so we don't have to use this ugly thing over and over
CUIEvent& Event = *((*pLists[nCurrList])[nCurrEvent]);
#if _MSC_VER >= 1300
OutFile << Event.GetType() << std::endl;
OutFile << GetEventValue(Event) << std::endl;
#else
OutFile << Event.GetType() << endl;
OutFile << GetEventValue(Event) << endl;
#endif
}
}
}
//saves the key to the registry
bool CHotKey::SaveToRegistry(CGenRegMgr& RegMgr, const char* pszRegDir, const char* pszName) const
{
CString sKeyName;
//write the name of the hotkey
sKeyName.Format("%sName", pszName);
RegMgr.SetStringValue(pszRegDir, sKeyName, (GetEventName()) ? GetEventName() : "");
//write the description
sKeyName.Format("%sDescription", pszName);
RegMgr.SetStringValue(pszRegDir, sKeyName, (GetDescription()) ? GetDescription() : "");
//write if it is changable or not
sKeyName.Format("%sChangable", pszName);
RegMgr.SetStringBoolValue(pszRegDir, sKeyName, IsUserChangable());
//lists that we need to save
const CUIEventList* pLists[] = {&m_StartEventList, &m_EndEventList};
for(uint32 nCurrList = 0; nCurrList < sizeof(pLists) / sizeof(pLists[0]); nCurrList++)
{
//get the number of events in this list
uint32 nNumEvents = pLists[nCurrList]->GetSize();
//get the number of events for this hotkey
sKeyName.Format("%sList%dNumEvents", pszName, nCurrList);
RegMgr.SetDwordValue(pszRegDir, sKeyName, nNumEvents);
//write all the events
for(uint32 nCurrEvent = 0; nCurrEvent < nNumEvents; nCurrEvent++)
{
//cache the event so we don't have to use this ugly thing over and over
CUIEvent& Event = *((*pLists[nCurrList])[nCurrEvent]);
//write out the event type
sKeyName.Format("%sList%dEvent%dType", pszName, nCurrList, nCurrEvent);
RegMgr.SetDwordValue(pszRegDir, sKeyName, Event.GetType());
//now write out the event value
sKeyName.Format("%sList%dEvent%dValue", pszName, nCurrList, nCurrEvent);
RegMgr.SetDwordValue(pszRegDir, sKeyName, GetEventValue(Event));
}
}
return true;
}
CCircularBuffer::CCircularBuffer(void *start)
{
this->header = (CircularBufferHeader*)start;
if (this->header->Magic != '~CB1') {
DebugWriteLine(L"Corrupted buffer header");
}
this->data = (byte*)(this->header + 1);
this->dataLength = this->header->TotalLength - sizeof(CircularBufferHeader);
this->nonFullEvent = OpenEventWaitHandle(GetEventName(this->header->NonFullEventName));
this->nonEmptyEvent = OpenEventWaitHandle(GetEventName(this->header->NonEmptyEventName));
if (this->nonFullEvent != nullptr)
DebugWriteLine(L"nonFullEvent found!\n");
if (this->nonEmptyEvent != nullptr)
DebugWriteLine(L"nonEmptyEvent found!\n");
DebugWriteLine(L"circular buffer header: %x %x %x %x\n", this->header->StartOffset, this->header->EndOffset, this->header->NonEmptyEventName, this->header->NonFullEventName);
}
void UK2Node_LiveEditObject::GetNodeAttributes( TArray<TKeyValuePair<FString, FString>>& OutNodeAttributes ) const
{
UClass* ClassToSpawn = GetClassToSpawn();
const FString ClassToSpawnStr = ClassToSpawn ? ClassToSpawn->GetName() : TEXT( "UnknownClass" );
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Type" ), TEXT( "LiveEditObject" ) ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Class" ), GetClass()->GetName() ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Name" ), GetName() ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "ClassToSpawn" ), ClassToSpawnStr ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "EventName" ), GetEventName() ));
}
// This function makes an entry into the application event log
void CNTService::LogEvent(WORD wType, DWORD dwID,
const wchar_t* pszS1,
const wchar_t* pszS2,
const wchar_t* pszS3)
{
#ifndef _DEBUG
if ( EVMSG_DEBUG == dwID )
return;
#endif
const wchar_t* ps[3];
ps[0] = pszS1;
ps[1] = pszS2;
ps[2] = pszS3;
int iStr = 0;
for (int i = 0; i < 3; i++) {
if (ps[i] != NULL) iStr++;
}
// Check the event source has been registered and if
// not then register it now
if (!m_hEventSource) {
TCHAR *name = GetEventName();
// Modification: 2-8-2005
// m_hEventSource = ::RegisterEventSourceW(NULL, // local machine
// GetEventName()); // source name
m_hEventSource = ::RegisterEventSource(NULL, // local machine
GetEventName()); // source name
// End Change
}
if (m_hEventSource) {
::ReportEventW(m_hEventSource,
wType,
0,
dwID,
NULL, // sid
iStr,
0,
ps,
NULL);
}
}
void IOEvent::ReleaseRef()
{
int ret = __sync_sub_and_fetch(&ref_count,1);
TRACE(GetEventName()<<",dec ref:"<<ref_count<<",ret:"<<ref_count);
if( ret == 0)
{
delete this;
}
}
HRESULT CAGCEventDef::GetEventDescription(AGCEventID idEvent, BSTR* pbstrOut)
{
// Initialize the [out] parameter
*pbstrOut = NULL;
// Find the definition of the event ID
const XEventDef* it = find(idEvent);
if (end() == it)
return E_INVALIDARG;
// Get the event description string
HRESULT hr = GetString(it->m_pszEventDescription, pbstrOut);
// If not specified, use the event name string
return (S_FALSE != hr) ? hr : GetEventName(it->m_id, pbstrOut);
}
BOOL CNTService::Install()
{
// Get the executable file path
TCHAR szFilePath[_MAX_PATH];
::GetModuleFileName(NULL, szFilePath, sizeof(szFilePath)/sizeof(*szFilePath));
// make registry entries to support logging messages
// Add the source name as a subkey under the Application
// key in the EventLog service portion of the registry.
TCHAR szKey[256];
HKEY hKey = NULL;
_tcscpy(szKey, _T("SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\"));
_tcscat(szKey, GetEventName());
// see if key exists
int result = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, szKey, 0, KEY_ALL_ACCESS, &hKey);
if (result == ERROR_FILE_NOT_FOUND) { // create it
if (::RegCreateKey(HKEY_LOCAL_MACHINE, szKey, &hKey) != ERROR_SUCCESS) {
return FALSE;
}
} else if (result != ERROR_SUCCESS) {
// punt
return FALSE;
}
// Add the Event ID message-file name to the 'EventMessageFile' subkey.
::RegSetValueEx(hKey,
_T("EventMessageFile"),
0,
REG_EXPAND_SZ,
(CONST BYTE*)szFilePath,
(_tcslen(szFilePath) + 1)*sizeof(*szFilePath));
// Set the supported types flags.
DWORD dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
::RegSetValueEx(hKey,
_T("TypesSupported"),
0,
REG_DWORD,
(CONST BYTE*)&dwData,
sizeof(DWORD));
::RegCloseKey(hKey);
return TRUE;
}
MapDialogue::MapDialogue(uint32 id) :
_dialogue_id(id),
_times_seen(0),
_max_views(-1),
_line_count(0),
_current_line(0),
_blocked(false),
_save_state(true),
_event_name("")
{
// Look up the event for this dialogue to see whether it has already been read before or not
// Either create the event or retrieve the number of times the dialogue has been seen.
_event_name = GetEventName();
GlobalEventGroup& event_group = *(MapMode::CurrentInstance()->GetMapEventGroup());
if (event_group.DoesEventExist(_event_name) == false) {
event_group.AddNewEvent(_event_name, 0);
}
else {
SetTimesSeen(event_group.GetEvent(_event_name));
}
}
void StepOneThreadSuite::RunDebuggee( Step* steps, int stepsCount )
{
Exec exec;
TEST_ASSERT_RETURN( SUCCEEDED( exec.Init( mCallback ) ) );
LaunchInfo info = { 0 };
wchar_t cmdLine[ MAX_PATH ] = L"";
IProcess* proc = NULL;
const wchar_t* Debuggee = StepOneThreadDebuggee;
Symbol funcs[] =
{
{ NULL, 0 },
{ L"Scenario1Func0", 0 },
{ L"Scenario1Func1", 0 },
{ L"Scenario1Func2", 0 },
{ L"Scenario1Func3", 0 },
};
TEST_ASSERT_RETURN( SUCCEEDED( FindSymbols( Debuggee, funcs, _countof( funcs ) ) ) );
swprintf_s( cmdLine, L"\"%s\" 1", Debuggee );
info.CommandLine = cmdLine;
info.Exe = Debuggee;
TEST_ASSERT_RETURN( SUCCEEDED( exec.Launch( &info, proc ) ) );
uint32_t pid = proc->GetId();
int nextStep = 0;
char msg[1024] = "";
RefPtr<IProcess> process;
process = proc;
proc->Release();
mCallback->SetTrackLastEvent( true );
for ( int i = 0; !mCallback->GetProcessExited(); i++ )
{
bool continued = false;
HRESULT hr = exec.WaitForEvent( DefaultTimeoutMillis );
// this should happen after process exit
if ( hr == E_TIMEOUT )
break;
TEST_ASSERT_RETURN( SUCCEEDED( hr ) );
TEST_ASSERT_RETURN( SUCCEEDED( hr = exec.DispatchEvent() ) );
if ( !process->IsStopped() )
continue;
if ( (mCallback->GetLastEvent()->Code != ExecEvent_ModuleLoad)
&& (mCallback->GetLastEvent()->Code != ExecEvent_ModuleUnload)
&& (mCallback->GetLastEvent()->Code != ExecEvent_ThreadStart)
&& (mCallback->GetLastEvent()->Code != ExecEvent_ThreadExit)
&& (mCallback->GetLastEvent()->Code != ExecEvent_LoadComplete) )
{
Step* curStep = &steps[nextStep];
nextStep++;
RefPtr<Thread> thread;
CONTEXT_X86 context = { 0 };
if ( mCallback->GetLastThreadId() != 0 )
{
TEST_ASSERT_RETURN( process->FindThread( mCallback->GetLastThreadId(), thread.Ref() ) );
TEST_ASSERT_RETURN( exec.GetThreadContext(
process, thread->GetId(), CONTEXT_X86_FULL, 0, &context, sizeof context ) == S_OK );
}
uintptr_t baseAddr = 0;
RefPtr<IModule> procMod = mCallback->GetProcessModule();
if ( procMod.Get() != NULL )
baseAddr = (uintptr_t) procMod->GetImageBase();
// TODO: test threadId
if ( mCallback->GetLastEvent()->Code != curStep->Event.Code )
{
sprintf_s( msg, "Expected event '%s', got '%s'.",
GetEventName( curStep->Event.Code ),
GetEventName( mCallback->GetLastEvent()->Code ) );
TEST_FAIL_MSG( msg );
break;
}
else if ( (curStep->Event.Code == ExecEvent_Exception)
&& (curStep->Event.ExceptionCode != ((ExceptionEventNode*) mCallback->GetLastEvent().get())->Exception.ExceptionCode) )
{
sprintf_s( msg, "Expected exception %08x, got %08x.",
curStep->Event.ExceptionCode,
((ExceptionEventNode*) mCallback->GetLastEvent().get())->Exception.ExceptionCode );
TEST_FAIL_MSG( msg );
break;
}
else if ( (curStep->Event.Code == ExecEvent_Exception)
|| (curStep->Event.Code == ExecEvent_StepComplete)
|| (curStep->Event.Code == ExecEvent_Breakpoint) )
{
uintptr_t funcRva = funcs[curStep->Event.FunctionIndex].RelativeAddress;
uintptr_t addr = (funcRva + curStep->Event.AddressOffset + baseAddr);
if ( context.Eip != addr )
{
sprintf_s( msg, "Expected instruction pointer at %08x, got %08x.", addr, context.Eip );
TEST_FAIL_MSG( msg );
break;
}
}
mCallback->SetCanStepInFunctionReturnValue( curStep->Action.CanStepInFunction );
if ( curStep->Action.BPAddressOffset != 0 )
{
uintptr_t funcRva = funcs[curStep->Action.FunctionIndex].RelativeAddress;
uintptr_t addr = (funcRva + curStep->Action.BPAddressOffset + baseAddr);
TEST_ASSERT_RETURN( SUCCEEDED( exec.SetBreakpoint( process.Get(), addr ) ) );
}
if ( curStep->Action.Action == Action_StepInstruction )
{
TEST_ASSERT_RETURN( SUCCEEDED(
exec.StepInstruction( process.Get(), curStep->Action.StepIn, true ) ) );
continued = true;
}
else if ( curStep->Action.Action == Action_StepRange )
{
AddressRange range = { context.Eip, context.Eip };
TEST_ASSERT_RETURN( SUCCEEDED(
exec.StepRange( process.Get(), curStep->Action.StepIn, range, true ) ) );
continued = true;
}
}
if ( !continued )
TEST_ASSERT_RETURN( SUCCEEDED( exec.Continue( process, true ) ) );
}
TEST_ASSERT( mCallback->GetLoadCompleted() );
TEST_ASSERT( mCallback->GetProcessExited() );
}
void UK2Node_LiveEditObject::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
UEdGraphPin *SourceExecPin = GetExecPin();
UEdGraphPin *SourceThenPin = GetThenPin();
UEdGraphPin *SourceBlueprintPin = GetBlueprintPin();
UEdGraphPin *SourceBaseClassPin = GetBaseClassPin();
UEdGraphPin *SourceDescriptionPin = GetDescriptionPin();
UEdGraphPin *SourcePermittedBindingsPin = GetPermittedBindingsPin();
UEdGraphPin *SourceOnMidiInputPin = GetOnMidiInputPin();
UEdGraphPin *SourceVariablePin = GetVariablePin();
if(NULL == SourceVariablePin)
{
CompilerContext.MessageLog.Error(*LOCTEXT("LiveEditObjectNodeMissingBlueprint_Error", "LiveEdit node @@ must have a blueprint specified and a variable selected to tune.").ToString(), this);
// we break exec links so this is the only error we get, don't want the SpawnActor node being considered and giving 'unexpected node' type warnings
BreakAllNodeLinks();
return;
}
UClass* SpawnClass = GetClassToSpawn();
if(NULL == SpawnClass)
{
CompilerContext.MessageLog.Error(*LOCTEXT("LiveEditObjectNodeMissingBaseClass_Error", "LiveEdit node @@ must have a Base Class specified.").ToString(), this);
// we break exec links so this is the only error we get, don't want the SpawnActor node being considered and giving 'unexpected node' type warnings
BreakAllNodeLinks();
return;
}
if ( SourcePermittedBindingsPin->LinkedTo.Num() == 0 )
{
CompilerContext.MessageLog.Error(*LOCTEXT("LiveEditObjectNodeMissingBinding_Error", "LiveEdit node @@ must specify Permitted Bindings.").ToString(), this);
// we break exec links so this is the only error we get, don't want the SpawnActor node being considered and giving 'unexpected node' type warnings
BreakAllNodeLinks();
return;
}
//sanity check the VariablePin value
{
UProperty *Property = UK2Node_LiveEditObjectStatics::GetPropertyByName( SpawnClass, *SourceVariablePin->DefaultValue );
if ( Property == NULL || !Property->IsA(UNumericProperty::StaticClass()) )
{
CompilerContext.MessageLog.Error(*LOCTEXT("LiveEditObjectNodeInvalidVariable_Error", "LiveEdit node @@ must have a valid variable selected.").ToString(), this);
// we break exec links so this is the only error we get, don't want the SpawnActor node being considered and giving 'unexpected node' type warnings
BreakAllNodeLinks();
return;
}
}
//hooks to pins that are generated after a BaseClass is set
UEdGraphPin *DeltaMultPin = GetDeltaMultPin();
UEdGraphPin *ShouldClampPin = GetShouldClampPin();
UEdGraphPin *ClampMinPin = GetClampMinPin();
UEdGraphPin *ClampMaxPin = GetClampMaxPin();
UK2Node_Self *SelfNode = CompilerContext.SpawnIntermediateNode<UK2Node_Self>(this,SourceGraph);
SelfNode->AllocateDefaultPins();
UEdGraphPin *SelfNodeThenPin = SelfNode->FindPinChecked(Schema->PN_Self);
FString EventNameGuid = GetEventName();
//Create the registration part of the LiveEditor binding process
{
UK2Node_CallFunction *RegisterForMIDINode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
RegisterForMIDINode->FunctionReference.SetExternalMember( TEXT("RegisterForLiveEditEvent"), ULiveEditorKismetLibrary::StaticClass() );
RegisterForMIDINode->AllocateDefaultPins();
UEdGraphPin *ExecPin = RegisterForMIDINode->GetExecPin();
CompilerContext.MovePinLinksToIntermediate(*SourceExecPin, *ExecPin);
UEdGraphPin *ThenPin = RegisterForMIDINode->GetThenPin();
CompilerContext.MovePinLinksToIntermediate(*SourceThenPin, *ThenPin);
UEdGraphPin *TargetPin = RegisterForMIDINode->FindPinChecked( FString(TEXT("Target")) );
TargetPin->MakeLinkTo(SelfNodeThenPin);
UEdGraphPin *EventNamePin = RegisterForMIDINode->FindPinChecked( FString(TEXT("EventName")) );
EventNamePin->DefaultValue = EventNameGuid;
UEdGraphPin *DescriptionPin = RegisterForMIDINode->FindPinChecked( FString(TEXT("Description")) );
CompilerContext.CopyPinLinksToIntermediate( *SourceDescriptionPin, *DescriptionPin);
UEdGraphPin *PermittedBindingsPin = RegisterForMIDINode->FindPinChecked( FString(TEXT("PermittedBindings")) );
CompilerContext.CopyPinLinksToIntermediate( *SourcePermittedBindingsPin, *PermittedBindingsPin);
}
//Create the event handling part of the LiveEditor binding process
{
//
//the event itself
//
UFunction *EventMIDISignature = GetEventMIDISignature();
UK2Node_Event* EventNode = CompilerContext.SpawnIntermediateNode<UK2Node_Event>(this, SourceGraph);
check(EventNode);
EventNode->EventSignatureClass = Cast<UClass>(EventMIDISignature->GetOuter());
EventNode->EventSignatureName = EventMIDISignature->GetFName();
EventNode->CustomFunctionName = *EventNameGuid;
EventNode->bInternalEvent = true;
EventNode->AllocateDefaultPins();
// Cache these out because we'll connect the sequence to it
UEdGraphPin *EventThenPin = EventNode->FindPinChecked( Schema->PN_Then );
UEdGraphPin *EventDeltaPin = EventNode->FindPinChecked( FString(TEXT("Delta")) );
UEdGraphPin *EventMidiValuePin = EventNode->FindPinChecked( FString(TEXT("MidiValue")) );
UEdGraphPin *EventControlTypePin = EventNode->FindPinChecked( FString(TEXT("ControlType")) );
//
// Check if Blueprint is NULL
//
UEdGraphPin *CompareBlueprintToNullBranchThenPin = NULL;
{
UK2Node_CallFunction *CompareBlueprintToNullNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
CompareBlueprintToNullNode->FunctionReference.SetExternalMember( TEXT("NotEqual_ObjectObject"), UKismetMathLibrary::StaticClass() );
CompareBlueprintToNullNode->AllocateDefaultPins();
//Set A Pin to the Blueprint Pin
UEdGraphPin *CompareBlueprintToNullAPin = CompareBlueprintToNullNode->FindPinChecked( FString(TEXT("A")) );
CompilerContext.CopyPinLinksToIntermediate( *SourceBlueprintPin, *CompareBlueprintToNullAPin);
// hook for Compare Blueprint to NULL result
UEdGraphPin *CompareBlueprintToNullResultPin = CompareBlueprintToNullNode->GetReturnValuePin();
// Create the BRANCH that will drive the comparison
UK2Node_IfThenElse* CompareBlueprintToNullBranchNode = CompilerContext.SpawnIntermediateNode<UK2Node_IfThenElse>(this, SourceGraph);
CompareBlueprintToNullBranchNode->AllocateDefaultPins();
//hook up the condition
CompareBlueprintToNullResultPin->MakeLinkTo( CompareBlueprintToNullBranchNode->GetConditionPin() );
//hook event to the branck input
EventThenPin->MakeLinkTo( CompareBlueprintToNullBranchNode->GetExecPin() );
//cache ot the THEN pin for later linkup
CompareBlueprintToNullBranchThenPin = CompareBlueprintToNullBranchNode->GetThenPin();
}
//
// Get Class Default Object
//
UK2Node_CallFunction *GetClassDefaultObjectNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
GetClassDefaultObjectNode->FunctionReference.SetExternalMember( TEXT("GetBlueprintClassDefaultObject"), ULiveEditorKismetLibrary::StaticClass() );
GetClassDefaultObjectNode->AllocateDefaultPins();
UEdGraphPin *GetClassDefaultObjectBlueprintPin = GetClassDefaultObjectNode->FindPinChecked( TEXT("Blueprint") );
CompilerContext.CopyPinLinksToIntermediate( *SourceBlueprintPin, *GetClassDefaultObjectBlueprintPin);
//hook for later -> the pointer to the ClassDefaultObject of our BlueprintPin
UEdGraphPin *GetClassDefaultObjectResultPin = GetClassDefaultObjectNode->GetReturnValuePin();
//
// Compare to BaseClass to make sure that the target Blueprint IsA(BaseClass)
//
UEdGraphPin *ClassIsChildOfBranchThenPin = NULL;
{
//
//we need to get the class of the Blueprint pin
UK2Node_CallFunction *GetClassNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
GetClassNode->FunctionReference.SetExternalMember( TEXT("GetObjectClass"), UGameplayStatics::StaticClass() );
GetClassNode->AllocateDefaultPins();
//Pin in the GetClassDefaultObjectResultPin to the Object Parameter of the GetObjectClass FUNCTION
//we want to make sure that the Class of the DEFAULT_OBJECT IsA( BaseClass )
UEdGraphPin *GetClassObjectPin = GetClassNode->FindPinChecked( FString(TEXT("Object")) );
GetClassDefaultObjectResultPin->MakeLinkTo( GetClassObjectPin );
//hook for the Class result
UEdGraphPin *GetClassReturnValuePin = GetClassNode->GetReturnValuePin();
//
//the ClassIsChildOf FUNCTION
UK2Node_CallFunction *ClassIsChildOfNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
ClassIsChildOfNode->FunctionReference.SetExternalMember( TEXT("ClassIsChildOf"), UKismetMathLibrary::StaticClass() );
ClassIsChildOfNode->AllocateDefaultPins();
//hook up the test pin
UEdGraphPin *ClassIsChildOfTestPin = ClassIsChildOfNode->FindPinChecked( FString(TEXT("TestClass")) );
GetClassReturnValuePin->MakeLinkTo( ClassIsChildOfTestPin );
//copy our BaseClass Pin into the ClassIsChildOf Parameter
UEdGraphPin *ClassIsChildOfParentPin = ClassIsChildOfNode->FindPinChecked( FString(TEXT("ParentClass")) );
CompilerContext.CopyPinLinksToIntermediate( *SourceBaseClassPin, *ClassIsChildOfParentPin);
//hook for return value
UEdGraphPin *ClassIsChildOfResultPin = ClassIsChildOfNode->GetReturnValuePin();
//
// Create the BRANCH that will drive the comparison
UK2Node_IfThenElse* ClassIsChildOfBranchNode = CompilerContext.SpawnIntermediateNode<UK2Node_IfThenElse>(this, SourceGraph);
ClassIsChildOfBranchNode->AllocateDefaultPins();
//hook up the previous branch to this one
check( CompareBlueprintToNullBranchThenPin != NULL );
CompareBlueprintToNullBranchThenPin->MakeLinkTo( ClassIsChildOfBranchNode->GetExecPin() );
//hook up our condition
ClassIsChildOfResultPin->MakeLinkTo( ClassIsChildOfBranchNode->GetConditionPin() );
//cache ot the THEN pin for later linkup
ClassIsChildOfBranchThenPin = ClassIsChildOfBranchNode->GetThenPin();
}
//
//The set variable function (to set LiveEdited new value)
//
UK2Node_CallFunction *ModifyVarNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
ModifyVarNode->FunctionReference.SetExternalMember( TEXT("ModifyPropertyByName"), ULiveEditorKismetLibrary::StaticClass() );
ModifyVarNode->AllocateDefaultPins();
// Make link from the event to the Set variable node
UEdGraphPin *ModifyVarExecPin = ModifyVarNode->GetExecPin();
ClassIsChildOfBranchThenPin->MakeLinkTo( ModifyVarExecPin );
//link up the Target Pin
UEdGraphPin *ModifyVarNodeTargetPin = ModifyVarNode->FindPinChecked( TEXT("Target") );
GetClassDefaultObjectResultPin->MakeLinkTo( ModifyVarNodeTargetPin );
//link up the PropertyName Pin
UEdGraphPin *ModifyVarNodePropertyNamePin = ModifyVarNode->FindPinChecked( TEXT("PropertyName") );
ModifyVarNodePropertyNamePin->DefaultValue = SourceVariablePin->DefaultValue;
//link up the MIDI Value Pin
UEdGraphPin *ModifyVarNodeMidiValuePin = ModifyVarNode->FindPinChecked( TEXT("MidiValue") );
EventMidiValuePin->MakeLinkTo(ModifyVarNodeMidiValuePin);
//link up the ControlType Pin
UEdGraphPin *ModifyVarNodeControlTypePin = ModifyVarNode->FindPinChecked( TEXT("ControlType") );
EventControlTypePin->MakeLinkTo(ModifyVarNodeControlTypePin);
//hook for the Delta Pin
UEdGraphPin *ModifyVarNodeDeltaPin = ModifyVarNode->FindPinChecked( TEXT("Delta") );
//Clamping
if ( ShouldClampPin->DefaultValue == FString(TEXT("true")) )
{
UEdGraphPin *ModifyVarNodeShouldClampPin = ModifyVarNode->FindPinChecked( TEXT("bShouldClamp") );
CompilerContext.CopyPinLinksToIntermediate( *ShouldClampPin, *ModifyVarNodeShouldClampPin);
check( ClampMinPin != NULL );
UEdGraphPin *ModifyVarNodeClampMinPin = ModifyVarNode->FindPinChecked( TEXT("ClampMin") );
CompilerContext.CopyPinLinksToIntermediate( *ClampMinPin, *ModifyVarNodeClampMinPin);
check( ClampMaxPin != NULL );
UEdGraphPin *ModifyVarNodeClampMaxPin = ModifyVarNode->FindPinChecked( TEXT("ClampMax") );
CompilerContext.CopyPinLinksToIntermediate( *ClampMaxPin, *ModifyVarNodeClampMaxPin);
}
//hook for ModifyVar THEN
UEdGraphPin *ModifyVarNodeThenPin = ModifyVarNode->GetThenPin();
//
// The Multiply Delta * DeltaMult function
//
UK2Node_CallFunction *MultiplyNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
MultiplyNode->FunctionReference.SetExternalMember( TEXT("Multiply_FloatFloat"), UKismetMathLibrary::StaticClass() );
MultiplyNode->AllocateDefaultPins();
//cache this out. it will be linked to from the output of the (int)Delta -> (float)Delta Conversion function
UEdGraphPin *MultiplyNodeFirstPin = MultiplyNode->FindPinChecked( FString(TEXT("A")) );
// 2nd input to the Add function comes from the Current variable value
UEdGraphPin *MultiplyNodeSecondPin = MultiplyNode->FindPinChecked( FString(TEXT("B")) );
CompilerContext.CopyPinLinksToIntermediate( *DeltaMultPin, *MultiplyNodeSecondPin);
UEdGraphPin *MultiplyNodeReturnValuePin = MultiplyNode->GetReturnValuePin();
MultiplyNodeReturnValuePin->MakeLinkTo( ModifyVarNodeDeltaPin );
//
// The Convert function to go from (int)Delta to ULiveEditorKismetLibrary::ModifyPropertyByName(... float Delta ...)
//
FName ConvertFunctionName;
bool success = Schema->SearchForAutocastFunction( EventDeltaPin, MultiplyNodeFirstPin, ConvertFunctionName );
check( success );
UK2Node_CallFunction *ConvertDeltaNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
ConvertDeltaNode->FunctionReference.SetExternalMember( ConvertFunctionName, UKismetMathLibrary::StaticClass() );
ConvertDeltaNode->AllocateDefaultPins();
FName PinName;
success = UK2Node_LiveEditObjectStatics::SearchForConvertPinName( Schema, EventDeltaPin, PinName );
check( success );
UEdGraphPin *ConvertDeltaInputPin = ConvertDeltaNode->FindPinChecked( PinName.ToString() );
EventDeltaPin->MakeLinkTo( ConvertDeltaInputPin );
UEdGraphPin *ConvertDeltaOutputPin = ConvertDeltaNode->GetReturnValuePin();
ConvertDeltaOutputPin->MakeLinkTo( MultiplyNodeFirstPin );
//
// TODO - markDirty
//
//
// send out the object value updates
//
UK2Node_CallFunction *ReplicationNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this,SourceGraph);
ReplicationNode->FunctionReference.SetExternalMember( TEXT("ReplicateChangesToChildren"), ULiveEditorKismetLibrary::StaticClass() );
ReplicationNode->AllocateDefaultPins();
UEdGraphPin *ReplicationNodeVarNamePin = ReplicationNode->FindPinChecked( TEXT("PropertyName") );
ReplicationNodeVarNamePin->DefaultValue = SourceVariablePin->DefaultValue;
UEdGraphPin *ReplicationNodeArchetypePin = ReplicationNode->FindPinChecked( FString(TEXT("Archetype")) );
GetClassDefaultObjectResultPin->MakeLinkTo( ReplicationNodeArchetypePin );
UEdGraphPin *ReplicationNodeExecPin = ReplicationNode->GetExecPin();
ModifyVarNodeThenPin->MakeLinkTo( ReplicationNodeExecPin );
UEdGraphPin *ReplicationNodeThenPin = ReplicationNode->FindPinChecked( FString(TEXT("then")) );
//
// Finally, activate our OnMidiInput pin
//
CompilerContext.CopyPinLinksToIntermediate( *SourceOnMidiInputPin, *ReplicationNodeThenPin);
}
// Break any links to the expanded node
BreakAllNodeLinks();
}
FString UPawnActionsComponent::DescribeEventType(EPawnActionEventType::Type EventType)
{
return GetEventName(EventType);
}
void IOEvent::RequireRef()
{
int ret = __sync_fetch_and_add(&ref_count,1);
TRACE(GetEventName()<<",add ref:"<<ref_count<<",ret:"<<ret);
}
IOEvent::~IOEvent(){
TRACE("event:"<<GetEventName()<<" dead");
}
void CDialogSession::NotifyListeners(EDialogSessionEvent event)
{
DiaLOG::Log(DiaLOG::eAlways, "[DIALOG} CDialogSession: %s Notifying listeners on Event %s", GetDebugName(), GetEventName(event));
m_listenerVecTemp.reserve(m_listenerVec.size());
m_listenerVecTemp.resize(0);
m_listenerVecTemp.insert( m_listenerVecTemp.end(),m_listenerVec.begin(),m_listenerVec.end() );
// it's safe to remove oneself while being called back
for (int i = (int)m_listenerVecTemp.size()-1; i >= 0; i--)
{
m_listenerVecTemp[i]->SessionEvent(this, event);
}
}