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); } }