void AAbilitySystemDebugHUD::DrawDebugAbilitySystemComponent(UAbilitySystemComponent *Component)
{
UWorld *World = GetWorld();
float GameWorldTime = World->GetTimeSeconds();
UFont* Font = GEngine->GetSmallFont();
FColor Color(38, 128, 0);
float X = 20.f;
float Y = 20.f;
FString String = FString::Printf(TEXT("%.2f"), Component->GetWorld()->GetTimeSeconds());
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
String = FString::Printf(TEXT("%s (%d)"), *Component->GetPathName(), Component->IsDefaultSubobject());
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
String = FString::Printf(TEXT("%s == %s"), *Component->GetArchetype()->GetPathName(), *Component->GetClass()->GetDefaultObject()->GetPathName());
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
for (const UAttributeSet* Set : Component->SpawnedAttributes)
{
if (!Set)
continue;
check(Set);
// Draw Attribute Set
DrawWithBackground(Font, FString::Printf(TEXT("%s (%d)"), *Set->GetName(), Set->IsDefaultSubobject()), Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
String = FString::Printf(TEXT("%s == %s"), *Set->GetArchetype()->GetPathName(), *Set->GetClass()->GetDefaultObject()->GetPathName());
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
for (TFieldIterator<UProperty> PropertyIt(Set->GetClass(), EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty *Prop = *PropertyIt;
FString ValueString;
const void *PropertyValue = Prop->ContainerPtrToValuePtr<void>(Set);
Prop->ExportTextItem(ValueString, PropertyValue, NULL, NULL, 0);
String = FString::Printf(TEXT("%s: %s"), *Prop->GetName(), *ValueString);
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
}
Y+= 25;
// Draw Active GameplayEffect
for (FActiveGameplayEffect& Effect : &Component->ActiveGameplayEffects)
{
String = FString::Printf(TEXT("%s. [%d, %d] %.2f"), *Effect.Spec.ToSimpleString(), Effect.PredictionKey.Current, Effect.PredictionKey.Base, Effect.GetTimeRemaining(GameWorldTime));
DrawWithBackground(Font, String, Color, EAlignHorizontal::Left, X, EAlignVertical::Top, Y);
}
}
}
void UK2Node_SpawnActorFromClass::CreatePinsForClass(UClass* InClass, TArray<UEdGraphPin*>& OutClassPins)
{
check(InClass != NULL);
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
const UObject* const ClassDefaultObject = InClass->GetDefaultObject(false);
for (TFieldIterator<UProperty> PropertyIt(InClass, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
UClass* PropertyClass = CastChecked<UClass>(Property->GetOuter());
const bool bIsDelegate = Property->IsA(UMulticastDelegateProperty::StaticClass());
const bool bIsExposedToSpawn = UEdGraphSchema_K2::IsPropertyExposedOnSpawn(Property);
const bool bIsSettableExternally = !Property->HasAnyPropertyFlags(CPF_DisableEditOnInstance);
if( bIsExposedToSpawn &&
!Property->HasAnyPropertyFlags(CPF_Parm) &&
bIsSettableExternally &&
Property->HasAllPropertyFlags(CPF_BlueprintVisible) &&
!bIsDelegate &&
(NULL == FindPin(Property->GetName()) ) )
{
UEdGraphPin* Pin = CreatePin(EGPD_Input, TEXT(""), TEXT(""), NULL, false, false, Property->GetName());
const bool bPinGood = (Pin != NULL) && K2Schema->ConvertPropertyToPinType(Property, /*out*/ Pin->PinType);
OutClassPins.Add(Pin);
if (ClassDefaultObject && Pin != NULL && K2Schema->PinDefaultValueIsEditable(*Pin))
{
FString DefaultValueAsString;
const bool bDefaultValueSet = FBlueprintEditorUtils::PropertyValueToString(Property, reinterpret_cast<const uint8*>(ClassDefaultObject), DefaultValueAsString);
check( bDefaultValueSet );
K2Schema->TrySetDefaultValue(*Pin, DefaultValueAsString);
}
// Copy tooltip from the property.
if (Pin != nullptr)
{
K2Schema->ConstructBasicPinTooltip(*Pin, Property->GetToolTipText(), Pin->PinToolTip);
}
}
}
// Change class of output pin
UEdGraphPin* ResultPin = GetResultPin();
ResultPin->PinType.PinSubCategoryObject = InClass;
}
void UParticleModuleTypeDataRibbon::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
Super::PostEditChangeProperty(PropertyChangedEvent);
UProperty* PropertyThatChanged = PropertyChangedEvent.Property;
if (PropertyThatChanged && PropertyThatChanged->GetName() == TEXT("MaxTessellationBetweenParticles"))
{
if (MaxTessellationBetweenParticles < 0)
{
MaxTessellationBetweenParticles = 0;
}
}
else if (PropertyThatChanged && PropertyThatChanged->GetName() == TEXT("SheetsPerTrail"))
{
if (SheetsPerTrail <= 0)
{
SheetsPerTrail = 1;
}
}
else if (PropertyThatChanged && PropertyThatChanged->GetName() == TEXT("MaxTrailCount"))
{
if (MaxTrailCount <= 0)
{
MaxTrailCount = 1;
}
}
else if (PropertyThatChanged && PropertyThatChanged->GetName() == TEXT("MaxParticleInTrailCount"))
{
if (MaxParticleInTrailCount < 0)
{
MaxParticleInTrailCount = 0;
}
}
}
void SGraphPinLiveEditVar::GenerateComboBoxIndexesRecurse( UStruct *InStruct, FString PropertyPrefix, TArray< TSharedPtr<int32> >& OutComboBoxIndexes )
{
check( InStruct != NULL );
for (TFieldIterator<UProperty> PropertyIt(InStruct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
if ( !Property->IsA(UNumericProperty::StaticClass()) )
{
if ( Property->IsA(UStructProperty::StaticClass()) )
{
UStructProperty *StructProp = Cast<UStructProperty>(Property);
if ( IsPropertyPermitedForLiveEditor(*StructProp) )
{
if ( Property->ArrayDim > 1 )
{
for ( int32 i = 0; i < Property->ArrayDim; ++i )
{
FString arrayIndex = FString::Printf( TEXT("[%d]"), i );
FString NewPropertyPrefix = FString::Printf( TEXT("%s%s%s."), *PropertyPrefix, *Property->GetName(), *arrayIndex );
GenerateComboBoxIndexesRecurse( StructProp->Struct, NewPropertyPrefix, OutComboBoxIndexes );
}
}
else
{
FString NewPropertyPrefix = FString::Printf( TEXT("%s%s."), *PropertyPrefix, *Property->GetName() );
GenerateComboBoxIndexesRecurse( StructProp->Struct, NewPropertyPrefix, OutComboBoxIndexes );
}
}
}
else if ( Property->IsA(UArrayProperty::StaticClass()) )
{
UArrayProperty *ArrayProp = Cast<UArrayProperty>(Property);
}
continue;
}
if ( IsPropertyPermitedForLiveEditor(*Property) )
{
if ( Property->ArrayDim > 1 )
{
for ( int32 i = 0; i < Property->ArrayDim; ++i )
{
FString arrayIndex = FString::Printf( TEXT("[%d]"), i );
FString Name = PropertyPrefix + Property->GetName() + arrayIndex;
VariableNameList.Add( Name );
}
}
else
{
FString Name = PropertyPrefix + Property->GetName();
VariableNameList.Add( Name );
}
}
}
}
FORCEINLINE bool operator()( UProperty & A, UProperty & B ) const
{
// Ensure stable sort
if ( A.GetOffset_ForGC() == B.GetOffset_ForGC() )
{
return A.GetName() < B.GetName();
}
return A.GetOffset_ForGC() < B.GetOffset_ForGC();
}
void USpeedTreeImportData::SaveOptions()
{
int32 PortFlags = 0;
for (UProperty* Property = GetClass()->PropertyLink; Property; Property = Property->PropertyLinkNext)
{
if (!Property->HasAnyPropertyFlags(CPF_Config))
{
continue;
}
FString Section = TEXT("SpeedTree_Import_UI_Option_") + GetClass()->GetName();
FString Key = Property->GetName();
const bool bIsPropertyInherited = Property->GetOwnerClass() != GetClass();
UObject* SuperClassDefaultObject = GetClass()->GetSuperClass()->GetDefaultObject();
UArrayProperty* Array = dynamic_cast<UArrayProperty*>(Property);
if (Array)
{
FConfigSection* Sec = GConfig->GetSectionPrivate(*Section, 1, 0, *GEditorPerProjectIni);
check(Sec);
Sec->Remove(*Key);
FScriptArrayHelper_InContainer ArrayHelper(Array, this);
for (int32 i = 0; i < ArrayHelper.Num(); i++)
{
FString Buffer;
Array->Inner->ExportTextItem(Buffer, ArrayHelper.GetRawPtr(i), ArrayHelper.GetRawPtr(i), this, PortFlags);
Sec->Add(*Key, *Buffer);
}
}
else
{
TCHAR TempKey[MAX_SPRINTF] = TEXT("");
for (int32 Index = 0; Index < Property->ArrayDim; Index++)
{
if (Property->ArrayDim != 1)
{
FCString::Sprintf(TempKey, TEXT("%s[%i]"), *Property->GetName(), Index);
Key = TempKey;
}
FString Value;
Property->ExportText_InContainer(Index, Value, this, this, this, PortFlags);
GConfig->SetString(*Section, *Key, *Value, *GEditorPerProjectIni);
}
}
}
GConfig->Flush(0);
}
void AWorldSettings::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
UProperty* PropertyThatChanged = PropertyChangedEvent.Property;
if (PropertyThatChanged)
{
if (PropertyThatChanged->GetName()==TEXT("bForceNoPrecomputedLighting") && bForceNoPrecomputedLighting)
{
FMessageDialog::Open( EAppMsgType::Ok, LOCTEXT("bForceNoPrecomputedLightingIsEnabled", "bForceNoPrecomputedLighting is now enabled, build lighting once to propagate the change (will remove existing precomputed lighting data)."));
}
if (PropertyThatChanged->GetName()==TEXT("bEnableWorldComposition"))
{
if (UWorldComposition::EnableWorldCompositionEvent.IsBound())
{
bEnableWorldComposition = UWorldComposition::EnableWorldCompositionEvent.Execute(GetWorld(), bEnableWorldComposition);
}
else
{
bEnableWorldComposition = false;
}
}
}
LightmassSettings.NumIndirectLightingBounces = FMath::Clamp(LightmassSettings.NumIndirectLightingBounces, 0, 100);
LightmassSettings.IndirectLightingSmoothness = FMath::Clamp(LightmassSettings.IndirectLightingSmoothness, .25f, 10.0f);
LightmassSettings.VolumeLightSamplePlacementScale = FMath::Clamp(LightmassSettings.VolumeLightSamplePlacementScale, .1f, 100.0f);
LightmassSettings.IndirectLightingQuality = FMath::Clamp(LightmassSettings.IndirectLightingQuality, .1f, 10.0f);
LightmassSettings.StaticLightingLevelScale = FMath::Clamp(LightmassSettings.StaticLightingLevelScale, .001f, 1000.0f);
LightmassSettings.EmissiveBoost = FMath::Max(LightmassSettings.EmissiveBoost, 0.0f);
LightmassSettings.DiffuseBoost = FMath::Max(LightmassSettings.DiffuseBoost, 0.0f);
LightmassSettings.DirectIlluminationOcclusionFraction = FMath::Clamp(LightmassSettings.DirectIlluminationOcclusionFraction, 0.0f, 1.0f);
LightmassSettings.IndirectIlluminationOcclusionFraction = FMath::Clamp(LightmassSettings.IndirectIlluminationOcclusionFraction, 0.0f, 1.0f);
LightmassSettings.OcclusionExponent = FMath::Max(LightmassSettings.OcclusionExponent, 0.0f);
LightmassSettings.FullyOccludedSamplesFraction = FMath::Clamp(LightmassSettings.FullyOccludedSamplesFraction, 0.0f, 1.0f);
LightmassSettings.MaxOcclusionDistance = FMath::Max(LightmassSettings.MaxOcclusionDistance, 0.0f);
LightmassSettings.EnvironmentIntensity = FMath::Max(LightmassSettings.EnvironmentIntensity, 0.0f);
// Ensure texture size is power of two between 512 and 4096.
PackedLightAndShadowMapTextureSize = FMath::Clamp<uint32>( FMath::RoundUpToPowerOfTwo( PackedLightAndShadowMapTextureSize ), 512, 4096 );
if (GetWorld() != nullptr && GetWorld()->PersistentLevel->GetWorldSettings() == this)
{
if (GIsEditor)
{
GEngine->DeferredCommands.AddUnique(TEXT("UpdateLandscapeSetup"));
}
}
Super::PostEditChangeProperty(PropertyChangedEvent);
}
bool FDetailWidgetExtensionHandler::IsPropertyExtendable(const UClass* InObjectClass, const IPropertyHandle& InPropertyHandle) const
{
// TODO UMG make this work for multiple widgets.
if ( InPropertyHandle.GetNumOuterObjects() == 1 )
{
TArray<UObject*> Objects;
InPropertyHandle.GetOuterObjects(Objects);
// We don't allow bindings on the CDO.
if ( Objects[0]->HasAnyFlags(RF_ClassDefaultObject) )
{
return false;
}
UProperty* Property = InPropertyHandle.GetProperty();
FString DelegateName = Property->GetName() + "Delegate";
if ( UClass* ContainerClass = Cast<UClass>(Property->GetOuter()) )
{
UDelegateProperty* DelegateProperty = FindField<UDelegateProperty>(ContainerClass, FName(*DelegateName));
if ( DelegateProperty )
{
return true;
}
}
}
return false;
}
/** Finds a property by name, starting in the specified scope; Validates property type and returns NULL along with emitting an error if there is a mismatch. */
UProperty* FKismetCompilerUtilities::FindPropertyInScope(UStruct* Scope, UEdGraphPin* Pin, FCompilerResultsLog& MessageLog, const UEdGraphSchema_K2* Schema, UClass* SelfClass)
{
while (Scope != NULL)
{
for (TFieldIterator<UProperty> It(Scope, EFieldIteratorFlags::IncludeSuper); It; ++It)
{
UProperty* Property = *It;
if (Property->GetName() == Pin->PinName)
{
if (FKismetCompilerUtilities::IsTypeCompatibleWithProperty(Pin, Property, MessageLog, Schema, SelfClass))
{
return Property;
}
else
{
// Exit now, we found one with the right name but the type mismatched (and there was a type mismatch error)
return NULL;
}
}
}
// Functions don't automatically check their class when using a field iterator
UFunction* Function = Cast<UFunction>(Scope);
Scope = (Function != NULL) ? Cast<UStruct>(Function->GetOuter()) : NULL;
}
// Couldn't find the name
MessageLog.Error(*LOCTEXT("PropertyNotFound_Error", "The property associated with @@ could not be found").ToString(), Pin);
return NULL;
}
void UK2Node_SpawnActor::CreatePinsForClass(UClass* InClass)
{
check(InClass != NULL);
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
for (TFieldIterator<UProperty> PropertyIt(InClass, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
UClass* PropertyClass = CastChecked<UClass>(Property->GetOuter());
const bool bIsDelegate = Property->IsA(UMulticastDelegateProperty::StaticClass());
const bool bIsExposedToSpawn = UEdGraphSchema_K2::IsPropertyExposedOnSpawn(Property);
const bool bIsSettableExternally = !Property->HasAnyPropertyFlags(CPF_DisableEditOnInstance);
if( bIsExposedToSpawn &&
!Property->HasAnyPropertyFlags(CPF_Parm) &&
bIsSettableExternally &&
Property->HasAllPropertyFlags(CPF_BlueprintVisible) &&
!bIsDelegate )
{
UEdGraphPin* Pin = CreatePin(EGPD_Input, TEXT(""), TEXT(""), NULL, false, false, Property->GetName());
const bool bPinGood = (Pin != NULL) && K2Schema->ConvertPropertyToPinType(Property, /*out*/ Pin->PinType);
}
}
// Change class of output pin
UEdGraphPin* ResultPin = GetResultPin();
ResultPin->PinType.PinSubCategoryObject = InClass;
}
FString FScriptCodeGeneratorBase::GenerateFunctionDispatch(UFunction* Function)
{
FString Params;
const bool bHasParamsOrReturnValue = (Function->Children != NULL);
if (bHasParamsOrReturnValue)
{
Params += TEXT("\tstruct FDispatchParams\r\n\t{\r\n");
for (TFieldIterator<UProperty> ParamIt(Function); ParamIt; ++ParamIt)
{
UProperty* Param = *ParamIt;
Params += FString::Printf(TEXT("\t\t%s %s;\r\n"), *GetPropertyTypeCPP(Param, CPPF_ArgumentOrReturnValue), *Param->GetName());
}
Params += TEXT("\t} Params;\r\n");
int32 ParamIndex = 0;
for (TFieldIterator<UProperty> ParamIt(Function); ParamIt; ++ParamIt, ++ParamIndex)
{
UProperty* Param = *ParamIt;
Params += FString::Printf(TEXT("\tParams.%s = %s;\r\n"), *Param->GetName(), *InitializeFunctionDispatchParam(Function, Param, ParamIndex));
}
}
Params += FString::Printf(TEXT("\tstatic UFunction* Function = Obj->FindFunctionChecked(TEXT(\"%s\"));\r\n"), *Function->GetName());
if (bHasParamsOrReturnValue)
{
Params += TEXT("\tcheck(Function->ParmsSize == sizeof(FDispatchParams));\r\n");
Params += TEXT("\tObj->ProcessEvent(Function, &Params);\r\n");
}
else
{
Params += TEXT("\tObj->ProcessEvent(Function, NULL);\r\n");
}
return Params;
}
bool FJsonObjectConverter::UStructToJsonObject(const UStruct* StructDefinition, const void* Struct, TSharedRef<FJsonObject> OutJsonObject, int64 CheckFlags, int64 SkipFlags)
{
for(TFieldIterator<UProperty> It(StructDefinition); It; ++It)
{
UProperty* Property = *It;
// Check to see if we should ignore this property
if (CheckFlags != 0 && !Property->HasAnyPropertyFlags(CheckFlags))
{
continue;
}
if (Property->HasAnyPropertyFlags(SkipFlags))
{
continue;
}
FString VariableName = StandardizeCase(Property->GetName());
const void* Value = Property->ContainerPtrToValuePtr<uint8>(Struct);
// convert the property to a FJsonValue
TSharedPtr<FJsonValue> JsonValue = UPropertyToJsonValue(Property, Value, CheckFlags, SkipFlags);
if (!JsonValue.IsValid())
{
UClass* PropClass = Property->GetClass();
UE_LOG(LogJson, Error, TEXT("UStructToJsonObject - Unhandled property type '%s': %s"), *PropClass->GetName(), *Property->GetPathName());
return false;
}
// set the value on the output object
OutJsonObject->SetField(VariableName, JsonValue);
}
return true;
}
bool UK2Node::CreatePinsForFunctionEntryExit(const UFunction* Function, bool bForFunctionEntry)
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
// Create the inputs and outputs
bool bAllPinsGood = true;
for (TFieldIterator<UProperty> PropIt(Function); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
{
UProperty* Param = *PropIt;
const bool bIsFunctionInput = !Param->HasAnyPropertyFlags(CPF_OutParm) || Param->HasAnyPropertyFlags(CPF_ReferenceParm);
if (bIsFunctionInput == bForFunctionEntry)
{
const EEdGraphPinDirection Direction = bForFunctionEntry ? EGPD_Output : EGPD_Input;
UEdGraphPin* Pin = CreatePin(Direction, TEXT(""), TEXT(""), NULL, false, false, Param->GetName());
const bool bPinGood = K2Schema->ConvertPropertyToPinType(Param, /*out*/ Pin->PinType);
K2Schema->SetPinDefaultValueBasedOnType(Pin);
UK2Node_CallFunction::GeneratePinTooltipFromFunction(*Pin, Function);
bAllPinsGood = bAllPinsGood && bPinGood;
}
}
return bAllPinsGood;
}
void UK2Node_Variable::GetNodeAttributes( TArray<TKeyValuePair<FString, FString>>& OutNodeAttributes ) const
{
UProperty* VariableProperty = GetPropertyForVariable();
const FString VariableName = VariableProperty ? VariableProperty->GetName() : TEXT( "InvalidVariable" );
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Type" ), TEXT( "Variable" ) ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Class" ), GetClass()->GetName() ));
OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Name" ), VariableName ));
}
bool FJsonObjectConverter::JsonAttributesToUStruct(const TMap< FString, TSharedPtr<FJsonValue> >& JsonAttributes, const UStruct* StructDefinition, void* OutStruct, int64 CheckFlags, int64 SkipFlags)
{
if (StructDefinition == FJsonObjectWrapper::StaticStruct())
{
// Just copy it into the object
FJsonObjectWrapper* ProxyObject = (FJsonObjectWrapper *)OutStruct;
ProxyObject->JsonObject = MakeShareable(new FJsonObject());
ProxyObject->JsonObject->Values = JsonAttributes;
return true;
}
// iterate over the struct properties
for(TFieldIterator<UProperty> PropIt(StructDefinition); PropIt; ++PropIt)
{
UProperty* Property = *PropIt;
FString PropertyName = Property->GetName();
// Check to see if we should ignore this property
if (CheckFlags != 0 && !Property->HasAnyPropertyFlags(CheckFlags))
{
continue;
}
if (Property->HasAnyPropertyFlags(SkipFlags))
{
continue;
}
// find a json value matching this property name
TSharedPtr<FJsonValue> JsonValue;
for (auto It = JsonAttributes.CreateConstIterator(); It; ++It)
{
// use case insensitive search sincd FName may change caseing strangely on us
if (PropertyName.Equals(It.Key(), ESearchCase::IgnoreCase))
{
JsonValue = It.Value();
break;
}
}
if (!JsonValue.IsValid() || JsonValue->IsNull())
{
// we allow values to not be found since this mirrors the typical UObject mantra that all the fields are optional when deserializing
continue;
}
void* Value = Property->ContainerPtrToValuePtr<uint8>(OutStruct);
if (!JsonValueToUProperty(JsonValue, Property, Value, CheckFlags, SkipFlags))
{
UE_LOG(LogJson, Error, TEXT("JsonObjectToUStruct - Unable to parse %s.%s from JSON"), *StructDefinition->GetName(), *PropertyName);
return false;
}
}
return true;
}
FString FLuaScriptCodeGenerator::ExportFunction(const FString& ClassNameCPP, UClass* Class, UFunction* Function)
{
FString GeneratedGlue = GenerateWrapperFunctionDeclaration(ClassNameCPP, Class, Function);
GeneratedGlue += TEXT("\r\n{\r\n");
UProperty* ReturnValue = NULL;
UClass* FuncSuper = NULL;
if (Function->GetOwnerClass() != Class)
{
// Find the base definition of the function
if (ExportedClasses.Contains(Function->GetOwnerClass()->GetFName()))
{
FuncSuper = Function->GetOwnerClass();
}
}
FString FunctionBody;
if (FuncSuper == NULL)
{
FunctionBody += FString::Printf(TEXT("\t%s\r\n"), *GenerateObjectDeclarationFromContext(ClassNameCPP, Class));
FunctionBody += GenerateFunctionDispatch(Function);
FString FunctionCallArguments;
FString ReturnValueDeclaration;
for (TFieldIterator<UProperty> ParamIt(Function); !ReturnValue && ParamIt; ++ParamIt)
{
UProperty* Param = *ParamIt;
if (Param->GetPropertyFlags() & CPF_ReturnParm)
{
ReturnValue = Param;
}
}
FString ReturnValueName;
if (ReturnValue)
{
ReturnValueName = FString::Printf(TEXT("Params.%s"), *ReturnValue->GetName());
}
FunctionBody += FString::Printf(TEXT("\t%s\r\n"), *GenerateReturnValueHandler(ClassNameCPP, Class, Function, ReturnValue, *ReturnValueName));
}
else
{
FunctionBody = FString::Printf(TEXT("\treturn %s_%s(InScriptContext);\r\n"), *FuncSuper->GetName(), *Function->GetName());
}
GeneratedGlue += FunctionBody;
GeneratedGlue += TEXT("}\r\n\r\n");
auto& Exports = ClassExportedFunctions.FindOrAdd(Class);
Exports.Add(Function->GetFName());
return GeneratedGlue;
}
void UK2Node_AddComponent::AllocatePinsForExposedVariables()
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
const UActorComponent* TemplateComponent = GetTemplateFromNode();
const UClass* ComponentClass = TemplateComponent ? TemplateComponent->GetClass() : nullptr;
if (ComponentClass != nullptr)
{
const UObject* ClassDefaultObject = ComponentClass ? ComponentClass->ClassDefaultObject : nullptr;
for (TFieldIterator<UProperty> PropertyIt(ComponentClass, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
const bool bNotDelegate = !Property->IsA(UMulticastDelegateProperty::StaticClass());
const bool bIsExposedToSpawn = UEdGraphSchema_K2::IsPropertyExposedOnSpawn(Property);
const bool bIsVisible = Property->HasAllPropertyFlags(CPF_BlueprintVisible);
const bool bNotParam = !Property->HasAllPropertyFlags(CPF_Parm);
if(bNotDelegate && bIsExposedToSpawn && bIsVisible && bNotParam)
{
FEdGraphPinType PinType;
K2Schema->ConvertPropertyToPinType(Property, /*out*/ PinType);
const bool bIsUnique = (NULL == FindPin(Property->GetName()));
if (K2Schema->FindSetVariableByNameFunction(PinType) && bIsUnique)
{
UEdGraphPin* Pin = CreatePin(EGPD_Input, TEXT(""), TEXT(""), NULL, false, false, Property->GetName());
Pin->PinType = PinType;
bHasExposedVariable = true;
if ((ClassDefaultObject != nullptr) && K2Schema->PinDefaultValueIsEditable(*Pin))
{
FString DefaultValueAsString;
const bool bDefaultValueSet = FBlueprintEditorUtils::PropertyValueToString(Property, reinterpret_cast<const uint8*>(ClassDefaultObject), DefaultValueAsString);
check(bDefaultValueSet);
K2Schema->TrySetDefaultValue(*Pin, DefaultValueAsString);
}
// Copy tooltip from the property.
K2Schema->ConstructBasicPinTooltip(*Pin, Property->GetToolTipText(), Pin->PinToolTip);
}
}
}
}
// Hide transform and attachment pins if it is not a scene component
const bool bHideTransformPins = (ComponentClass != nullptr) ? !ComponentClass->IsChildOf(USceneComponent::StaticClass()) : false;
UEdGraphPin* ManualAttachmentPin = GetManualAttachmentPin();
ManualAttachmentPin->SafeSetHidden(bHideTransformPins);
UEdGraphPin* TransformPin = GetRelativeTransformPin();
TransformPin->SafeSetHidden(bHideTransformPins);
}
bool FJsonObjectConverter::UStructToJsonAttributes(const UStruct* StructDefinition, const void* Struct, TMap< FString, TSharedPtr<FJsonValue> >& OutJsonAttributes, int64 CheckFlags, int64 SkipFlags, const CustomExportCallback* ExportCb)
{
if (SkipFlags == 0)
{
// If we have no specified skip flags, skip deprecated by default when writing
SkipFlags |= CPF_Deprecated;
}
if (StructDefinition == FJsonObjectWrapper::StaticStruct())
{
// Just copy it into the object
const FJsonObjectWrapper* ProxyObject = (const FJsonObjectWrapper *)Struct;
if (ProxyObject->JsonObject.IsValid())
{
OutJsonAttributes = ProxyObject->JsonObject->Values;
}
return true;
}
for (TFieldIterator<UProperty> It(StructDefinition); It; ++It)
{
UProperty* Property = *It;
// Check to see if we should ignore this property
if (CheckFlags != 0 && !Property->HasAnyPropertyFlags(CheckFlags))
{
continue;
}
if (Property->HasAnyPropertyFlags(SkipFlags))
{
continue;
}
FString VariableName = StandardizeCase(Property->GetName());
const void* Value = Property->ContainerPtrToValuePtr<uint8>(Struct);
// convert the property to a FJsonValue
TSharedPtr<FJsonValue> JsonValue = UPropertyToJsonValue(Property, Value, CheckFlags, SkipFlags, ExportCb);
if (!JsonValue.IsValid())
{
UClass* PropClass = Property->GetClass();
UE_LOG(LogJson, Error, TEXT("UStructToJsonObject - Unhandled property type '%s': %s"), *PropClass->GetName(), *Property->GetPathName());
return false;
}
// set the value on the output object
OutJsonAttributes.Add(VariableName, JsonValue);
}
return true;
}
bool FDataTableImporterJSON::ReadRow(const TSharedRef<FJsonObject>& ParsedTableRowObject, const int32 RowIdx)
{
// Get row name
FName RowName = DataTableUtils::MakeValidName(ParsedTableRowObject->GetStringField(TEXT("Name")));
// Check its not 'none'
if (RowName.IsNone())
{
ImportProblems.Add(FString::Printf(TEXT("Row '%d' missing a name."), RowIdx));
return false;
}
// Check its not a duplicate
if (DataTable->RowMap.Find(RowName) != nullptr)
{
ImportProblems.Add(FString::Printf(TEXT("Duplicate row name '%s'."), *RowName.ToString()));
return false;
}
// Allocate data to store information, using UScriptStruct to know its size
uint8* RowData = (uint8*)FMemory::Malloc(DataTable->RowStruct->PropertiesSize);
DataTable->RowStruct->InitializeStruct(RowData);
// And be sure to call DestroyScriptStruct later
if (auto UDStruct = Cast<const UUserDefinedStruct>(DataTable->RowStruct))
{
UDStruct->InitializeDefaultValue(RowData);
}
// Add to row map
DataTable->RowMap.Add(RowName, RowData);
// Now read in each property
for (TFieldIterator<UProperty> It(DataTable->RowStruct); It; ++It)
{
UProperty* BaseProp = *It;
check(BaseProp);
const FString PropertyName = BaseProp->GetName();
TSharedPtr<FJsonValue> ParsedPropertyValue = ParsedTableRowObject->TryGetField(PropertyName);
if (!ParsedPropertyValue.IsValid())
{
ImportProblems.Add(FString::Printf(TEXT("Row '%s' is missing an entry for '%s'."), *RowName.ToString(), *PropertyName));
continue;
}
void* Data = BaseProp->ContainerPtrToValuePtr<void>(RowData, 0);
ReadStructEntry(ParsedPropertyValue.ToSharedRef(), RowName, RowData, BaseProp, Data);
}
return true;
}
TArray<FString> UDataTable::GetUniqueColumnTitles() const
{
TArray<FString> Result;
Result.Add(TEXT("Name"));
for (TFieldIterator<UProperty> It(RowStruct); It; ++It)
{
UProperty* Prop = *It;
check(Prop != NULL);
const FString DisplayName = Prop->GetName();
Result.Add(DisplayName);
}
return Result;
}
static PyObject *py_ue_uscriptstruct_fields(ue_PyUScriptStruct *self, PyObject * args)
{
PyObject *ret = PyList_New(0);
for (TFieldIterator<UProperty> PropIt(self->u_struct); PropIt; ++PropIt)
{
UProperty* property = *PropIt;
PyObject *property_name = PyUnicode_FromString(TCHAR_TO_UTF8(*property->GetName()));
PyList_Append(ret, property_name);
Py_DECREF(property_name);
}
return ret;
}
bool FDeviceProfileTextureLODSettingsColumn::Supports(const TSharedRef< IPropertyTableColumn >& Column, const TSharedRef< IPropertyTableUtilities >& Utilities) const
{
if( Column->GetDataSource()->IsValid() )
{
TSharedPtr< FPropertyPath > PropertyPath = Column->GetDataSource()->AsPropertyPath();
if( PropertyPath.IsValid() && PropertyPath->GetNumProperties() > 0 )
{
const FPropertyInfo& PropertyInfo = PropertyPath->GetRootProperty();
UProperty* Property = PropertyInfo.Property.Get();
if (Property->GetName() == TEXT("TextureLODGroups") && Property->IsA(UArrayProperty::StaticClass()))
{
return true;
}
}
}
return false;
}
/**
* Get a given UObject's properties in simple key/value string map
*
* @param Obj The UObject to extract properties for
* @param ObjProperties [OUT] Property map to be filled
*/
static void GetObjProperties (UObject* Obj, FPropertiesMap& ObjProperties)
{
for (TFieldIterator<UProperty> PropIt(Obj->GetClass(), EFieldIteratorFlags::IncludeSuper); PropIt; ++PropIt)
{
UProperty* Prop = *PropIt;
if ( ShouldCompareProperty(Prop) )
{
for (int32 Index = 0; Index < Prop->ArrayDim; Index++)
{
FString PropName = (Prop->ArrayDim > 1) ? FString::Printf(TEXT("%s[%d]"), *Prop->GetName(), Index) : *Prop->GetName();
FString PropText;
Prop->ExportText_InContainer(Index, PropText, Obj, Obj, Obj, PPF_SimpleObjectText);
ObjProperties.Add(PropName, PropText);
}
}
}
}
TSharedRef<SWidget> FDetailWidgetExtensionHandler::GenerateExtensionWidget(const UClass* InObjectClass, TSharedPtr<IPropertyHandle> InPropertyHandle)
{
UProperty* Property = InPropertyHandle->GetProperty();
FString DelegateName = Property->GetName() + "Delegate";
UDelegateProperty* DelegateProperty = FindFieldChecked<UDelegateProperty>(CastChecked<UClass>(Property->GetOuter()), FName(*DelegateName));
const bool bIsEditable = Property->HasAnyPropertyFlags(CPF_Edit | CPF_EditConst);
const bool bDoSignaturesMatch = DelegateProperty->SignatureFunction->GetReturnProperty()->SameType(Property);
if ( !ensure(bIsEditable && bDoSignaturesMatch) )
{
return SNullWidget::NullWidget;
}
return SNew(SPropertyBinding, BlueprintEditor.Pin().ToSharedRef(), DelegateProperty, InPropertyHandle.ToSharedRef())
.GeneratePureBindings(true);
}
void GetInterpPropertyNames(UObject* InObject, const FString& Prefix)
{
UClass* ObjectClass = InObject->GetClass();
// First search for any properties in this object
for (TFieldIterator<UProperty> ClassFieldIt(ObjectClass); ClassFieldIt; ++ClassFieldIt)
{
UProperty* ClassMemberProperty = *ClassFieldIt;
if (ClassMemberProperty->HasAnyPropertyFlags(CPF_Interp))
{
// Is this property the desired type?
if (IsDesiredProperty(ClassMemberProperty))
{
const FString QualifiedFullPath = FString::Printf(TEXT("%s%s"), *Prefix, *ClassMemberProperty->GetName());
GatheredPropertyPaths.Add(*QualifiedFullPath);
}
// If this is a struct, look for any desired properties inside of it
if (UStructProperty* OuterStructProperty = Cast<UStructProperty>(ClassMemberProperty))
{
for (TFieldIterator<UProperty> StructFieldIt(OuterStructProperty->Struct); StructFieldIt; ++StructFieldIt)
{
UProperty* StructMemberProperty = *StructFieldIt;
if (StructMemberProperty->HasAnyPropertyFlags(CPF_Interp) && IsDesiredProperty(StructMemberProperty))
{
const FString QualifiedFullPath = FString::Printf(TEXT("%s%s.%s"), *Prefix, *OuterStructProperty->GetName(), *StructMemberProperty->GetName());
GatheredPropertyPaths.Add(*QualifiedFullPath);
}
}
}
}
}
// Then iterate over each subobject of this object looking for interp properties.
TArray<UObject*> DefaultSubObjects;
ObjectClass->GetDefaultObjectSubobjects(DefaultSubObjects);
for (int32 SubObjectIndex = 0; SubObjectIndex < DefaultSubObjects.Num(); ++SubObjectIndex)
{
UObject* Component = DefaultSubObjects[SubObjectIndex];
const FString ComponentPrefix = Component->GetName() + TEXT(".");
GetInterpPropertyNames(Component, ComponentPrefix);
}
}
void SGAAttributeWidget::Construct(const FArguments& InArgs)
{
AttributesList.Empty();
AttributesNodes.Empty();
OnAttributeSelected = InArgs._OnAttributeSelectedIn;
for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
{
UClass* Class = *ClassIt;
if (Class->IsChildOf(UGAAttributesBase::StaticClass())
&& !FKismetEditorUtilities::IsClassABlueprintSkeleton(Class))
{
FString className = Class->GetName();
if (!className.Contains(TEXT("REINST_")))
{
TSharedPtr<FGAAttributeNode> attributeNode = MakeShareable(new FGAAttributeNode());
attributeNode->Attribute = className;
for (TFieldIterator<UProperty> PropertyIt(Class, EFieldIteratorFlags::ExcludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Prop = *PropertyIt;
//I need array within array, one for list of attributes, and one for class names.
// TSharedPtr<FString> attribute = MakeShareable(new FString(Prop->GetName()));
attributeNode->AttributeNames.Add(Prop->GetName());
//AttributesList.Add(attribute);
}
AttributesNodes.Add(attributeNode);
}
}
}
ChildSlot
[
SAssignNew(AttributeTreeWidget, STreeView<TSharedPtr<FGAAttributeNode>>)
.OnSelectionChanged(this, &SGAAttributeWidget::OnItemSelected)
.TreeItemsSource(&AttributesNodes)
.OnGenerateRow(this, &SGAAttributeWidget::OnGenerateRow)
.OnGetChildren(this, &SGAAttributeWidget::OnGetChildren)
.OnExpansionChanged(this, &SGAAttributeWidget::OnExpansionChanged)
.SelectionMode(ESelectionMode::Single)
];
}
void UUnrealEdEngine::ConvertMatinees()
{
FVector StartLocation= FVector::ZeroVector;
UWorld* World = GWorld;
if( World )
{
ULevel* Level = World->GetCurrentLevel();
if( !Level )
{
Level = World->PersistentLevel;
}
check(Level);
for( TObjectIterator<UInterpData> It; It; ++It )
{
UInterpData* InterpData = *It;
if( InterpData->IsIn( Level ) )
{
// We dont care about renaming references or adding redirectors. References to this will be old seqact_interps
GEditor->RenameObject( InterpData, Level->GetOutermost(), *InterpData->GetName() );
AMatineeActor* MatineeActor = Level->OwningWorld->SpawnActor<AMatineeActor>(StartLocation, FRotator::ZeroRotator);
StartLocation.Y += 50;
MatineeActor->MatineeData = InterpData;
UProperty* MatineeDataProp = NULL;
for( UProperty* Property = MatineeActor->GetClass()->PropertyLink; Property != NULL; Property = Property->PropertyLinkNext )
{
if( Property->GetName() == TEXT("MatineeData") )
{
MatineeDataProp = Property;
break;
}
}
FPropertyChangedEvent PropertyChangedEvent( MatineeDataProp );
MatineeActor->PostEditChangeProperty( PropertyChangedEvent );
}
}
}
}
bool UK2Node_CallDelegate::CreatePinsForFunctionInputs(const UFunction* Function)
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
// Create the inputs and outputs
bool bAllPinsGood = true;
for (TFieldIterator<UProperty> PropIt(Function); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
{
UProperty* Param = *PropIt;
const bool bIsFunctionInput = !Param->HasAnyPropertyFlags(CPF_OutParm) || Param->HasAnyPropertyFlags(CPF_ReferenceParm);
if (bIsFunctionInput)
{
UEdGraphPin* Pin = CreatePin(EGPD_Input, TEXT(""), TEXT(""), NULL, false, false, Param->GetName());
const bool bPinGood = K2Schema->ConvertPropertyToPinType(Param, /*out*/ Pin->PinType);
bAllPinsGood = bAllPinsGood && bPinGood;
}
}
return bAllPinsGood;
}
static void CheckOutputsParametersInDelegateSignature(const UFunction* SignatureFunc, const UK2Node * DelegateNode, FCompilerResultsLog& MessageLog)
{
for (TFieldIterator<UProperty> PropIt(SignatureFunc); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
{
UProperty* FuncParam = *PropIt;
if (FuncParam->HasAllPropertyFlags(CPF_OutParm) && !FuncParam->HasAllPropertyFlags(CPF_ConstParm))
{
const bool bIsArray = FuncParam->IsA<UArrayProperty>(); // array is always passed by reference, see FKismetCompilerContext::CreatePropertiesFromList
const FString MessageStr = FString::Printf(
*LOCTEXT("DelegatesDontSupportRef", "Event Dispatcher: No value will be return by reference. Parameter '%s'. Node '@@'").ToString(),
*FuncParam->GetName());
if (bIsArray)
{
MessageLog.Note(*MessageStr,DelegateNode);
}
else
{
MessageLog.Warning(*MessageStr, DelegateNode);
}
}
}
}
void UMaterialEditorInstanceConstant::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
if (SourceInstance)
{
UProperty* PropertyThatChanged = PropertyChangedEvent.Property;
FNavigationLockContext NavUpdateLock(ENavigationLockReason::MaterialUpdate);
if(PropertyThatChanged && PropertyThatChanged->GetName()==TEXT("Parent") )
{
UpdateSourceInstanceParent();
FGlobalComponentRecreateRenderStateContext RecreateComponentsRenderState;
// Fully update static parameters before recreating render state for all components
SetSourceInstance(SourceInstance);
}
CopyToSourceInstance();
// Tell our source instance to update itself so the preview updates.
SourceInstance->PostEditChangeProperty(PropertyChangedEvent);
}
}
