1006 lines
41 KiB
C++
1006 lines
41 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
MaterialGraphSchema.cpp
|
|
=============================================================================*/
|
|
|
|
#include "MaterialGraph/MaterialGraphSchema.h"
|
|
#include "Misc/FeedbackContext.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "UObject/UnrealType.h"
|
|
#include "UObject/PropertyPortFlags.h"
|
|
#include "Textures/SlateIcon.h"
|
|
#include "Framework/Commands/UIAction.h"
|
|
#include "Framework/MultiBox/MultiBoxBuilder.h"
|
|
#include "ToolMenus.h"
|
|
#include "EdGraph/EdGraph.h"
|
|
#include "HAL/IConsoleManager.h"
|
|
#include "Materials/MaterialExpression.h"
|
|
#include "Materials/MaterialExpressionMaterialFunctionCall.h"
|
|
#include "Materials/MaterialFunction.h"
|
|
#include "MaterialGraph/MaterialGraph.h"
|
|
#include "Engine/Texture.h"
|
|
#include "MaterialGraph/MaterialGraphNode_Base.h"
|
|
#include "MaterialGraph/MaterialGraphNode.h"
|
|
#include "MaterialGraph/MaterialGraphNode_Root.h"
|
|
#include "Materials/MaterialParameterCollection.h"
|
|
|
|
#include "Materials/MaterialExpressionCollectionParameter.h"
|
|
#include "Materials/MaterialExpressionComment.h"
|
|
#include "Materials/MaterialExpressionFunctionInput.h"
|
|
#include "Materials/MaterialExpressionTextureSample.h"
|
|
#include "Materials/MaterialExpressionFunctionOutput.h"
|
|
#include "Materials/MaterialExpressionReroute.h"
|
|
#include "Materials/MaterialExpressionNamedReroute.h"
|
|
|
|
#include "ScopedTransaction.h"
|
|
#include "MaterialEditorUtilities.h"
|
|
#include "GraphEditorActions.h"
|
|
#include "AssetRegistryModule.h"
|
|
#include "MaterialEditorActions.h"
|
|
#include "MaterialGraphNode_Knot.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "MaterialGraphSchema"
|
|
|
|
int32 UMaterialGraphSchema::CurrentCacheRefreshID = 0;
|
|
|
|
////////////////////////////////////////
|
|
// FMaterialGraphSchemaAction_NewNode //
|
|
|
|
UEdGraphNode* FMaterialGraphSchemaAction_NewNode::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /* = true*/)
|
|
{
|
|
check(MaterialExpressionClass);
|
|
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "MaterialEditorNewExpression", "Material Editor: New Expression"));
|
|
|
|
UMaterialExpression* NewExpression = FMaterialEditorUtilities::CreateNewMaterialExpression(ParentGraph, MaterialExpressionClass, Location, bSelectNewNode, /*bAutoAssignResource*/ true);
|
|
|
|
if (NewExpression)
|
|
{
|
|
if (MaterialExpressionClass == UMaterialExpressionFunctionInput::StaticClass() && FromPin)
|
|
{
|
|
// Set this to be an input of the type we dragged from
|
|
SetFunctionInputType(CastChecked<UMaterialExpressionFunctionInput>(NewExpression), UMaterialGraphSchema::GetMaterialValueType(FromPin));
|
|
}
|
|
|
|
NewExpression->GraphNode->AutowireNewNode(FromPin);
|
|
|
|
return NewExpression->GraphNode;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void FMaterialGraphSchemaAction_NewNode::SetFunctionInputType(UMaterialExpressionFunctionInput* FunctionInput, uint32 MaterialValueType) const
|
|
{
|
|
switch (MaterialValueType)
|
|
{
|
|
case MCT_Float:
|
|
case MCT_Float1:
|
|
FunctionInput->InputType = FunctionInput_Scalar;
|
|
break;
|
|
case MCT_Float2:
|
|
FunctionInput->InputType = FunctionInput_Vector2;
|
|
break;
|
|
case MCT_Float3:
|
|
FunctionInput->InputType = FunctionInput_Vector3;
|
|
break;
|
|
case MCT_Float4:
|
|
FunctionInput->InputType = FunctionInput_Vector4;
|
|
break;
|
|
case MCT_Texture:
|
|
case MCT_Texture2D:
|
|
FunctionInput->InputType = FunctionInput_Texture2D;
|
|
break;
|
|
case MCT_TextureCube:
|
|
FunctionInput->InputType = FunctionInput_TextureCube;
|
|
break;
|
|
case MCT_Texture2DArray:
|
|
FunctionInput->InputType = FunctionInput_Texture2DArray;
|
|
break;
|
|
case MCT_TextureExternal:
|
|
FunctionInput->InputType = FunctionInput_TextureExternal;
|
|
break;
|
|
case MCT_VolumeTexture:
|
|
FunctionInput->InputType = FunctionInput_VolumeTexture;
|
|
break;
|
|
case MCT_StaticBool:
|
|
FunctionInput->InputType = FunctionInput_StaticBool;
|
|
break;
|
|
case MCT_MaterialAttributes:
|
|
FunctionInput->InputType = FunctionInput_MaterialAttributes;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////
|
|
// FMaterialGraphSchemaAction_NewFunctionCall //
|
|
|
|
UEdGraphNode* FMaterialGraphSchemaAction_NewFunctionCall::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /* = true*/)
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "MaterialEditorNewFunctionCall", "Material Editor: New Function Call"));
|
|
|
|
UMaterialExpressionMaterialFunctionCall* FunctionNode = CastChecked<UMaterialExpressionMaterialFunctionCall>(
|
|
FMaterialEditorUtilities::CreateNewMaterialExpression(
|
|
ParentGraph, UMaterialExpressionMaterialFunctionCall::StaticClass(), Location, bSelectNewNode, /*bAutoAssignResource*/ false));
|
|
|
|
if (!FunctionNode->MaterialFunction)
|
|
{
|
|
UMaterialFunction* MaterialFunction = LoadObject<UMaterialFunction>(NULL, *FunctionPath, NULL, 0, NULL);
|
|
UMaterialGraph* MaterialGraph = CastChecked<UMaterialGraph>(ParentGraph);
|
|
if (FunctionNode->SetMaterialFunction(MaterialFunction))
|
|
{
|
|
FunctionNode->PostEditChange();
|
|
FMaterialEditorUtilities::UpdateSearchResults(ParentGraph);
|
|
FunctionNode->GraphNode->AutowireNewNode(FromPin);
|
|
return FunctionNode->GraphNode;
|
|
}
|
|
else
|
|
{
|
|
FMaterialEditorUtilities::AddToSelection(ParentGraph, FunctionNode);
|
|
FMaterialEditorUtilities::DeleteSelectedNodes(ParentGraph);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// FMaterialGraphSchemaAction_NewComment //
|
|
|
|
UEdGraphNode* FMaterialGraphSchemaAction_NewComment::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /* = true*/)
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "MaterialEditorNewComment", "Material Editor: New Comment"));
|
|
|
|
UMaterialExpressionComment* NewComment = FMaterialEditorUtilities::CreateNewMaterialExpressionComment(ParentGraph, Location);
|
|
|
|
if (NewComment)
|
|
{
|
|
return NewComment->GraphNode;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////
|
|
// FMaterialGraphSchemaAction_NewNamedRerouteUsage //
|
|
|
|
UEdGraphNode* FMaterialGraphSchemaAction_NewNamedRerouteUsage::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /*= true*/)
|
|
{
|
|
check(Declaration);
|
|
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "MaterialEditorNewNamedRerouteUsage", "Material Editor: New Named Reroute Usage"));
|
|
|
|
UMaterialExpression* NewExpression = FMaterialEditorUtilities::CreateNewMaterialExpression(ParentGraph, UMaterialExpressionNamedRerouteUsage::StaticClass(), Location, bSelectNewNode, /*bAutoAssignResource*/ true);
|
|
|
|
if (NewExpression)
|
|
{
|
|
auto* Usage = CastChecked<UMaterialExpressionNamedRerouteUsage>(NewExpression);
|
|
Usage->Declaration = Declaration;
|
|
Usage->DeclarationGuid = Declaration->VariableGuid;
|
|
NewExpression->GraphNode->AutowireNewNode(FromPin);
|
|
return NewExpression->GraphNode;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//////////////////////////////////////
|
|
// FMaterialGraphSchemaAction_Paste //
|
|
|
|
UEdGraphNode* FMaterialGraphSchemaAction_Paste::PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode /* = true*/)
|
|
{
|
|
FMaterialEditorUtilities::PasteNodesHere(ParentGraph, Location);
|
|
return NULL;
|
|
}
|
|
|
|
//////////////////////////
|
|
// UMaterialGraphSchema //
|
|
|
|
const FName UMaterialGraphSchema::PC_Mask(TEXT("mask"));
|
|
const FName UMaterialGraphSchema::PC_Required(TEXT("required"));
|
|
const FName UMaterialGraphSchema::PC_Optional(TEXT("optional"));
|
|
const FName UMaterialGraphSchema::PC_MaterialInput(TEXT("materialinput"));
|
|
|
|
const FName UMaterialGraphSchema::PSC_Red(TEXT("red"));
|
|
const FName UMaterialGraphSchema::PSC_Green(TEXT("green"));
|
|
const FName UMaterialGraphSchema::PSC_Blue(TEXT("blue"));
|
|
const FName UMaterialGraphSchema::PSC_Alpha(TEXT("alpha"));
|
|
const FName UMaterialGraphSchema::PSC_RGBA(TEXT("rgba"));
|
|
|
|
const FLinearColor UMaterialGraphSchema::ActivePinColor = FLinearColor::White;
|
|
const FLinearColor UMaterialGraphSchema::InactivePinColor = FLinearColor(0.05f, 0.05f, 0.05f);
|
|
const FLinearColor UMaterialGraphSchema::AlphaPinColor = FLinearColor(0.5f, 0.5f, 0.5f);
|
|
|
|
UMaterialGraphSchema::UMaterialGraphSchema(const FObjectInitializer& ObjectInitializer)
|
|
: Super(ObjectInitializer)
|
|
{
|
|
}
|
|
|
|
void UMaterialGraphSchema::SelectAllInputNodes(UEdGraph* Graph, UEdGraphPin* InGraphPin)
|
|
{
|
|
TArray<UEdGraphPin*> AllPins = InGraphPin->LinkedTo;
|
|
|
|
if (AllPins.Num() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (UEdGraphPin* Pin: AllPins)
|
|
{
|
|
UMaterialGraphNode* MaterialNode = Cast<UMaterialGraphNode>(Pin->GetOwningNode());
|
|
FMaterialEditorUtilities::AddToSelection(Graph, MaterialNode->MaterialExpression);
|
|
|
|
TArray<UEdGraphPin*> LinkedPins = Pin->GetOwningNode()->GetAllPins();
|
|
for (UEdGraphPin* InputPin: LinkedPins)
|
|
{
|
|
if (InputPin->Direction == EEdGraphPinDirection::EGPD_Output)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
SelectAllInputNodes(Graph, InputPin);
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetBreakLinkToSubMenuActions(class UToolMenu* Menu, UEdGraphPin* InGraphPin) const
|
|
{
|
|
FToolMenuSection& Section = Menu->FindOrAddSection("MaterialGraphSchemaPinActions");
|
|
|
|
// Make sure we have a unique name for every entry in the list
|
|
TMap<FString, uint32> LinkTitleCount;
|
|
|
|
// Add all the links we could break from
|
|
for (TArray<class UEdGraphPin*>::TConstIterator Links(InGraphPin->LinkedTo); Links; ++Links)
|
|
{
|
|
UEdGraphPin* Pin = *Links;
|
|
FString TitleString = Pin->GetOwningNode()->GetNodeTitle(ENodeTitleType::ListView).ToString();
|
|
FText Title = FText::FromString(TitleString);
|
|
if (Pin->PinName != TEXT(""))
|
|
{
|
|
TitleString = FString::Printf(TEXT("%s (%s)"), *TitleString, *Pin->PinName.ToString());
|
|
|
|
// Add name of connection if possible
|
|
FFormatNamedArguments Args;
|
|
Args.Add(TEXT("NodeTitle"), Title);
|
|
Args.Add(TEXT("PinName"), Pin->GetDisplayName());
|
|
Title = FText::Format(LOCTEXT("BreakDescPin", "{NodeTitle} ({PinName})"), Args);
|
|
}
|
|
|
|
uint32& Count = LinkTitleCount.FindOrAdd(TitleString);
|
|
|
|
FText Description;
|
|
FFormatNamedArguments Args;
|
|
Args.Add(TEXT("NodeTitle"), Title);
|
|
Args.Add(TEXT("NumberOfNodes"), Count);
|
|
|
|
if (Count == 0)
|
|
{
|
|
Description = FText::Format(LOCTEXT("BreakDesc", "Break link to {NodeTitle}"), Args);
|
|
}
|
|
else
|
|
{
|
|
Description = FText::Format(LOCTEXT("BreakDescMulti", "Break link to {NodeTitle} ({NumberOfNodes})"), Args);
|
|
}
|
|
++Count;
|
|
Section.AddMenuEntry(NAME_None, Description, Description, FSlateIcon(), FUIAction(FExecuteAction::CreateUObject((UMaterialGraphSchema* const)this, &UMaterialGraphSchema::BreakSinglePinLink, const_cast<UEdGraphPin*>(InGraphPin), *Links)));
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::OnConnectToFunctionOutput(UEdGraphPin* InGraphPin, UEdGraphPin* InFuncPin)
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "GraphEd_CreateConnection", "Create Pin Link"));
|
|
|
|
TryCreateConnection(InGraphPin, InFuncPin);
|
|
}
|
|
|
|
void UMaterialGraphSchema::OnConnectToMaterial(class UEdGraphPin* InGraphPin, int32 ConnIndex)
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "GraphEd_CreateConnection", "Create Pin Link"));
|
|
|
|
UMaterialGraph* MaterialGraph = CastChecked<UMaterialGraph>(InGraphPin->GetOwningNode()->GetGraph());
|
|
|
|
TryCreateConnection(InGraphPin, MaterialGraph->RootNode->GetInputPin(ConnIndex));
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetPaletteActions(FGraphActionMenuBuilder& ActionMenuBuilder, const FString& CategoryName, bool bMaterialFunction) const
|
|
{
|
|
if (CategoryName != TEXT("Functions"))
|
|
{
|
|
FMaterialEditorUtilities::GetMaterialExpressionActions(ActionMenuBuilder, bMaterialFunction);
|
|
GetCommentAction(ActionMenuBuilder);
|
|
}
|
|
if (CategoryName != TEXT("Expressions"))
|
|
{
|
|
GetMaterialFunctionActions(ActionMenuBuilder);
|
|
}
|
|
}
|
|
|
|
bool UMaterialGraphSchema::ConnectionCausesLoop(const UEdGraphPin* InputPin, const UEdGraphPin* OutputPin) const
|
|
{
|
|
// Only nodes representing Expressions have outputs
|
|
UMaterialGraphNode* OutputNode = CastChecked<UMaterialGraphNode>(OutputPin->GetOwningNode());
|
|
|
|
TArray<UMaterialExpression*> InputExpressions;
|
|
OutputNode->MaterialExpression->GetAllInputExpressions(InputExpressions);
|
|
|
|
if (UMaterialGraphNode* InputNode = Cast<UMaterialGraphNode>(InputPin->GetOwningNode()))
|
|
{
|
|
return InputExpressions.Contains(InputNode->MaterialExpression);
|
|
}
|
|
|
|
// Simple connection to root node
|
|
return false;
|
|
}
|
|
|
|
bool UMaterialGraphSchema::ArePinsCompatible_Internal(const UEdGraphPin* InputPin, const UEdGraphPin* OutputPin, FText& ResponseMessage) const
|
|
{
|
|
uint32 InputType = GetMaterialValueType(InputPin);
|
|
uint32 OutputType = GetMaterialValueType(OutputPin);
|
|
|
|
bool bPinsCompatible = CanConnectMaterialValueTypes(InputType, OutputType);
|
|
if (!bPinsCompatible)
|
|
{
|
|
TArray<FText> InputDescriptions;
|
|
TArray<FText> OutputDescriptions;
|
|
GetMaterialValueTypeDescriptions(InputType, InputDescriptions);
|
|
GetMaterialValueTypeDescriptions(OutputType, OutputDescriptions);
|
|
|
|
FString CombinedInputDescription;
|
|
FString CombinedOutputDescription;
|
|
for (int32 Index = 0; Index < InputDescriptions.Num(); ++Index)
|
|
{
|
|
if (CombinedInputDescription.Len() > 0)
|
|
{
|
|
CombinedInputDescription += TEXT(", ");
|
|
}
|
|
CombinedInputDescription += InputDescriptions[Index].ToString();
|
|
}
|
|
for (int32 Index = 0; Index < OutputDescriptions.Num(); ++Index)
|
|
{
|
|
if (CombinedOutputDescription.Len() > 0)
|
|
{
|
|
CombinedOutputDescription += TEXT(", ");
|
|
}
|
|
CombinedOutputDescription += OutputDescriptions[Index].ToString();
|
|
}
|
|
|
|
FFormatNamedArguments Args;
|
|
Args.Add(TEXT("InputType"), FText::FromString(CombinedInputDescription));
|
|
Args.Add(TEXT("OutputType"), FText::FromString(CombinedOutputDescription));
|
|
ResponseMessage = FText::Format(LOCTEXT("IncompatibleDesc", "{OutputType} is not compatible with {InputType}"), Args);
|
|
}
|
|
|
|
return bPinsCompatible;
|
|
}
|
|
|
|
uint32 UMaterialGraphSchema::GetMaterialValueType(const UEdGraphPin* MaterialPin)
|
|
{
|
|
if (MaterialPin->Direction == EGPD_Output)
|
|
{
|
|
UMaterialGraphNode* OwningNode = CastChecked<UMaterialGraphNode>(MaterialPin->GetOwningNode());
|
|
return OwningNode->GetOutputType(MaterialPin);
|
|
}
|
|
else
|
|
{
|
|
UMaterialGraphNode_Base* OwningNode = CastChecked<UMaterialGraphNode_Base>(MaterialPin->GetOwningNode());
|
|
return OwningNode->GetInputType(MaterialPin);
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetGraphContextActions(FGraphContextMenuBuilder& ContextMenuBuilder) const
|
|
{
|
|
const UMaterialGraph* MaterialGraph = CastChecked<UMaterialGraph>(ContextMenuBuilder.CurrentGraph);
|
|
|
|
// Run through all nodes and add any menu items they want to add
|
|
Super::GetGraphContextActions(ContextMenuBuilder);
|
|
|
|
// Get the Context Actions from Material Editor Module
|
|
FMaterialEditorUtilities::GetMaterialExpressionActions(ContextMenuBuilder, MaterialGraph->MaterialFunction != NULL);
|
|
|
|
// Get the Material Functions as well
|
|
GetMaterialFunctionActions(ContextMenuBuilder);
|
|
|
|
GetCommentAction(ContextMenuBuilder, ContextMenuBuilder.CurrentGraph);
|
|
|
|
GetNamedRerouteActions(ContextMenuBuilder, ContextMenuBuilder.CurrentGraph);
|
|
|
|
// Add Paste here if appropriate
|
|
if (!ContextMenuBuilder.FromPin && FMaterialEditorUtilities::CanPasteNodes(ContextMenuBuilder.CurrentGraph))
|
|
{
|
|
const FText PasteDesc = LOCTEXT("PasteDesc", "Paste Here");
|
|
const FText PasteToolTip = LOCTEXT("PasteToolTip", "Pastes copied items at this location.");
|
|
TSharedPtr<FMaterialGraphSchemaAction_Paste> PasteAction(new FMaterialGraphSchemaAction_Paste(FText::GetEmpty(), PasteDesc, PasteToolTip, 0));
|
|
ContextMenuBuilder.AddAction(PasteAction);
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetContextMenuActions(UToolMenu* Menu, UGraphNodeContextMenuContext* Context) const
|
|
{
|
|
if (Context && Context->Pin)
|
|
{
|
|
const UEdGraphPin* InGraphPin = Context->Pin;
|
|
const UMaterialGraph* MaterialGraph = CastChecked<UMaterialGraph>(Context->Graph);
|
|
|
|
// add menu items to expression output for material connection
|
|
if (InGraphPin->Direction == EGPD_Output)
|
|
{
|
|
{
|
|
FToolMenuSection& Section = Menu->AddSection("MaterialEditorMenuConnector2");
|
|
// If we are editing a material function, display options to connect to function outputs
|
|
if (MaterialGraph->MaterialFunction)
|
|
{
|
|
for (int32 Index = 0; Index < MaterialGraph->Nodes.Num(); Index++)
|
|
{
|
|
UMaterialGraphNode* GraphNode = Cast<UMaterialGraphNode>(MaterialGraph->Nodes[Index]);
|
|
if (GraphNode)
|
|
{
|
|
UMaterialExpressionFunctionOutput* FunctionOutput = Cast<UMaterialExpressionFunctionOutput>(GraphNode->MaterialExpression);
|
|
if (FunctionOutput)
|
|
{
|
|
FFormatNamedArguments Arguments;
|
|
Arguments.Add(TEXT("Name"), FText::FromName(FunctionOutput->OutputName));
|
|
const FText Label = FText::Format(LOCTEXT("ConnectToFunction", "Connect To {Name}"), Arguments);
|
|
const FText ToolTip = FText::Format(LOCTEXT("ConnectToFunctionTooltip", "Connects to the function output {Name}"), Arguments);
|
|
Section.AddMenuEntry(
|
|
NAME_None,
|
|
Label,
|
|
ToolTip,
|
|
FSlateIcon(),
|
|
FUIAction(FExecuteAction::CreateUObject(const_cast<UMaterialGraphSchema*>(this), &UMaterialGraphSchema::OnConnectToFunctionOutput, const_cast<UEdGraphPin*>(InGraphPin), GraphNode->GetInputPin(0))));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int32 Index = 0; Index < MaterialGraph->MaterialInputs.Num(); ++Index)
|
|
{
|
|
if (MaterialGraph->MaterialInputs[Index].IsVisiblePin(MaterialGraph->Material))
|
|
{
|
|
FFormatNamedArguments Arguments;
|
|
Arguments.Add(TEXT("Name"), MaterialGraph->MaterialInputs[Index].GetName());
|
|
const FText Label = FText::Format(LOCTEXT("ConnectToInput", "Connect To {Name}"), Arguments);
|
|
const FText ToolTip = FText::Format(LOCTEXT("ConnectToInputTooltip", "Connects to the material input {Name}"), Arguments);
|
|
Section.AddMenuEntry(
|
|
NAME_None,
|
|
Label,
|
|
ToolTip,
|
|
FSlateIcon(),
|
|
FUIAction(FExecuteAction::CreateUObject(const_cast<UMaterialGraphSchema*>(this), &UMaterialGraphSchema::OnConnectToMaterial, const_cast<UEdGraphPin*>(InGraphPin), Index)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Moved all functionality to relevant node classes
|
|
}
|
|
|
|
Super::GetContextMenuActions(Menu, Context);
|
|
}
|
|
|
|
static TAutoConsoleVariable<int32> CVarPreventInvalidMaterialConnections(
|
|
TEXT("r.PreventInvalidMaterialConnections"),
|
|
1,
|
|
TEXT("Controls whether users can make connections in the material editor if the system\n")
|
|
TEXT("determines that they may cause compile errors\n")
|
|
TEXT("0: Allow all connections\n")
|
|
TEXT("1: Prevent invalid connections"),
|
|
ECVF_Cheat);
|
|
|
|
const FPinConnectionResponse UMaterialGraphSchema::CanCreateConnection(const UEdGraphPin* A, const UEdGraphPin* B) const
|
|
{
|
|
bool bPreventInvalidConnections = CVarPreventInvalidMaterialConnections.GetValueOnGameThread() != 0;
|
|
|
|
// Make sure the pins are not on the same node
|
|
if (A->GetOwningNode() == B->GetOwningNode())
|
|
{
|
|
return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, LOCTEXT("ConnectionSameNode", "Both are on the same node"));
|
|
}
|
|
|
|
// Compare the directions
|
|
const UEdGraphPin* InputPin = NULL;
|
|
const UEdGraphPin* OutputPin = NULL;
|
|
|
|
if (!CategorizePinsByDirection(A, B, /*out*/ InputPin, /*out*/ OutputPin))
|
|
{
|
|
return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, LOCTEXT("ConnectionIncompatible", "Directions are not compatible"));
|
|
}
|
|
|
|
// Check for new and existing loops
|
|
FText ResponseMessage;
|
|
if (ConnectionCausesLoop(InputPin, OutputPin))
|
|
{
|
|
ResponseMessage = LOCTEXT("ConnectionLoop", "Connection could cause loop");
|
|
// TODO: re-enable this if loops are going to be removed completely
|
|
// return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, LOCTEXT("ConnectionLoop", "Connection would cause loop").ToString());
|
|
}
|
|
|
|
// Check for incompatible pins and get description if they cannot connect
|
|
if (!ArePinsCompatible_Internal(InputPin, OutputPin, ResponseMessage) && bPreventInvalidConnections)
|
|
{
|
|
return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, ResponseMessage);
|
|
}
|
|
|
|
// Break existing connections on inputs only - multiple output connections are acceptable
|
|
if (InputPin->LinkedTo.Num() > 0)
|
|
{
|
|
ECanCreateConnectionResponse ReplyBreakOutputs;
|
|
if (InputPin == A)
|
|
{
|
|
ReplyBreakOutputs = CONNECT_RESPONSE_BREAK_OTHERS_A;
|
|
}
|
|
else
|
|
{
|
|
ReplyBreakOutputs = CONNECT_RESPONSE_BREAK_OTHERS_B;
|
|
}
|
|
if (ResponseMessage.IsEmpty())
|
|
{
|
|
ResponseMessage = LOCTEXT("ConnectionReplace", "Replace existing connections");
|
|
}
|
|
return FPinConnectionResponse(ReplyBreakOutputs, ResponseMessage);
|
|
}
|
|
|
|
return FPinConnectionResponse(CONNECT_RESPONSE_MAKE, ResponseMessage);
|
|
}
|
|
|
|
bool UMaterialGraphSchema::TryCreateConnection(UEdGraphPin* A, UEdGraphPin* B) const
|
|
{
|
|
bool bModified = UEdGraphSchema::TryCreateConnection(A, B);
|
|
|
|
if (bModified)
|
|
{
|
|
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(A->GetOwningNode()->GetGraph());
|
|
}
|
|
|
|
return bModified;
|
|
}
|
|
|
|
FLinearColor UMaterialGraphSchema::GetPinTypeColor(const FEdGraphPinType& PinType) const
|
|
{
|
|
if (PinType.PinCategory == PC_Mask)
|
|
{
|
|
if (PinType.PinSubCategory == PSC_Red)
|
|
{
|
|
return FLinearColor::Red;
|
|
}
|
|
else if (PinType.PinSubCategory == PSC_Green)
|
|
{
|
|
return FLinearColor::Green;
|
|
}
|
|
else if (PinType.PinSubCategory == PSC_Blue)
|
|
{
|
|
return FLinearColor::Blue;
|
|
}
|
|
else if (PinType.PinSubCategory == PSC_Alpha)
|
|
{
|
|
return AlphaPinColor;
|
|
}
|
|
}
|
|
else if (PinType.PinCategory == PC_Required)
|
|
{
|
|
return ActivePinColor;
|
|
}
|
|
else if (PinType.PinCategory == PC_Optional)
|
|
{
|
|
return InactivePinColor;
|
|
}
|
|
|
|
return ActivePinColor;
|
|
}
|
|
|
|
void UMaterialGraphSchema::BreakNodeLinks(UEdGraphNode& TargetNode) const
|
|
{
|
|
bool bHasLinksToBreak = false;
|
|
for (auto PinIt = TargetNode.Pins.CreateConstIterator(); PinIt; ++PinIt)
|
|
{
|
|
UEdGraphPin* Pin = *PinIt;
|
|
for (auto LinkIt = Pin->LinkedTo.CreateConstIterator(); LinkIt; ++LinkIt)
|
|
{
|
|
if (*LinkIt)
|
|
{
|
|
bHasLinksToBreak = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
Super::BreakNodeLinks(TargetNode);
|
|
|
|
if (bHasLinksToBreak)
|
|
{
|
|
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(TargetNode.GetGraph());
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::BreakPinLinks(UEdGraphPin& TargetPin, bool bSendsNodeNotifcation) const
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "GraphEd_BreakPinLinks", "Break Pin Links"));
|
|
|
|
bool bHasLinksToBreak = false;
|
|
for (auto LinkIt = TargetPin.LinkedTo.CreateConstIterator(); LinkIt; ++LinkIt)
|
|
{
|
|
if (*LinkIt)
|
|
{
|
|
bHasLinksToBreak = true;
|
|
}
|
|
}
|
|
|
|
Super::BreakPinLinks(TargetPin, bSendsNodeNotifcation);
|
|
|
|
// if this would notify the node then we need to re-compile material
|
|
if (bSendsNodeNotifcation && bHasLinksToBreak)
|
|
{
|
|
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(TargetPin.GetOwningNode()->GetGraph());
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::BreakSinglePinLink(UEdGraphPin* SourcePin, UEdGraphPin* TargetPin) const
|
|
{
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "GraphEd_BreakSinglePinLink", "Break Pin Link"));
|
|
|
|
bool bHasLinkToBreak = false;
|
|
for (auto LinkIt = SourcePin->LinkedTo.CreateConstIterator(); LinkIt; ++LinkIt)
|
|
{
|
|
if (*LinkIt == TargetPin)
|
|
{
|
|
bHasLinkToBreak = true;
|
|
}
|
|
}
|
|
|
|
Super::BreakSinglePinLink(SourcePin, TargetPin);
|
|
|
|
if (bHasLinkToBreak)
|
|
{
|
|
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(SourcePin->GetOwningNode()->GetGraph());
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::DroppedAssetsOnGraph(const TArray<struct FAssetData>& Assets, const FVector2D& GraphPosition, UEdGraph* Graph) const
|
|
{
|
|
UMaterialGraph* MaterialGraph = CastChecked<UMaterialGraph>(Graph);
|
|
const int32 LocOffsetBetweenNodes = 32;
|
|
|
|
FVector2D ExpressionPosition = GraphPosition;
|
|
|
|
for (int32 AssetIdx = 0; AssetIdx < Assets.Num(); ++AssetIdx)
|
|
{
|
|
bool bAddedNode = false;
|
|
UObject* Asset = Assets[AssetIdx].GetAsset();
|
|
UClass* MaterialExpressionClass = Cast<UClass>(Asset);
|
|
UMaterialFunctionInterface* Func = Cast<UMaterialFunctionInterface>(Asset);
|
|
UTexture* Tex = Cast<UTexture>(Asset);
|
|
UMaterialParameterCollection* ParameterCollection = Cast<UMaterialParameterCollection>(Asset);
|
|
|
|
if (MaterialExpressionClass && MaterialExpressionClass->IsChildOf(UMaterialExpression::StaticClass()))
|
|
{
|
|
FMaterialEditorUtilities::CreateNewMaterialExpression(Graph, MaterialExpressionClass, ExpressionPosition, true, true);
|
|
bAddedNode = true;
|
|
}
|
|
else if (Func)
|
|
{
|
|
UMaterialExpressionMaterialFunctionCall* FunctionNode = CastChecked<UMaterialExpressionMaterialFunctionCall>(
|
|
FMaterialEditorUtilities::CreateNewMaterialExpression(Graph, UMaterialExpressionMaterialFunctionCall::StaticClass(), ExpressionPosition, true, false));
|
|
|
|
if (!FunctionNode->MaterialFunction)
|
|
{
|
|
if (FunctionNode->SetMaterialFunction(Func))
|
|
{
|
|
FunctionNode->PostEditChange();
|
|
FMaterialEditorUtilities::UpdateSearchResults(Graph);
|
|
}
|
|
else
|
|
{
|
|
FMaterialEditorUtilities::AddToSelection(Graph, FunctionNode);
|
|
FMaterialEditorUtilities::DeleteSelectedNodes(Graph);
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
bAddedNode = true;
|
|
}
|
|
else if (Tex)
|
|
{
|
|
UMaterialExpressionTextureSample* TextureSampleNode = CastChecked<UMaterialExpressionTextureSample>(
|
|
FMaterialEditorUtilities::CreateNewMaterialExpression(Graph, UMaterialExpressionTextureSample::StaticClass(), ExpressionPosition, true, true));
|
|
TextureSampleNode->Texture = Tex;
|
|
TextureSampleNode->AutoSetSampleType();
|
|
|
|
FMaterialEditorUtilities::ForceRefreshExpressionPreviews(Graph);
|
|
|
|
bAddedNode = true;
|
|
}
|
|
else if (ParameterCollection)
|
|
{
|
|
UMaterialExpressionCollectionParameter* CollectionParameterNode = CastChecked<UMaterialExpressionCollectionParameter>(
|
|
FMaterialEditorUtilities::CreateNewMaterialExpression(Graph, UMaterialExpressionCollectionParameter::StaticClass(), ExpressionPosition, true, true));
|
|
CollectionParameterNode->Collection = ParameterCollection;
|
|
|
|
FMaterialEditorUtilities::ForceRefreshExpressionPreviews(Graph);
|
|
|
|
bAddedNode = true;
|
|
}
|
|
|
|
if (bAddedNode)
|
|
{
|
|
ExpressionPosition.X += LocOffsetBetweenNodes;
|
|
ExpressionPosition.Y += LocOffsetBetweenNodes;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32 UMaterialGraphSchema::GetNodeSelectionCount(const UEdGraph* Graph) const
|
|
{
|
|
return FMaterialEditorUtilities::GetNumberOfSelectedNodes(Graph);
|
|
}
|
|
|
|
TSharedPtr<FEdGraphSchemaAction> UMaterialGraphSchema::GetCreateCommentAction() const
|
|
{
|
|
return TSharedPtr<FEdGraphSchemaAction>(static_cast<FEdGraphSchemaAction*>(new FMaterialGraphSchemaAction_NewComment));
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetMaterialFunctionActions(FGraphActionMenuBuilder& ActionMenuBuilder) const
|
|
{
|
|
// Get type of dragged pin
|
|
uint32 FromPinType = 0;
|
|
if (ActionMenuBuilder.FromPin)
|
|
{
|
|
FromPinType = GetMaterialValueType(ActionMenuBuilder.FromPin);
|
|
}
|
|
|
|
// Load the asset registry module
|
|
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
|
|
|
|
// Collect a full list of assets with the specified class
|
|
TArray<FAssetData> AssetDataList;
|
|
AssetRegistryModule.Get().GetAssetsByClass(UMaterialFunction::StaticClass()->GetFName(), AssetDataList);
|
|
|
|
for (const FAssetData& AssetData: AssetDataList)
|
|
{
|
|
const bool bExposeToLibrary = AssetData.GetTagValueRef<bool>("bExposeToLibrary");
|
|
|
|
// If this was a function that was selected to be exposed to the library
|
|
if (bExposeToLibrary)
|
|
{
|
|
if (AssetData.IsAssetLoaded())
|
|
{
|
|
if (AssetData.GetAsset()->GetOutermost() == GetTransientPackage())
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (!ActionMenuBuilder.FromPin || HasCompatibleConnection(AssetData, FromPinType, ActionMenuBuilder.FromPin->Direction))
|
|
{
|
|
// Gather the relevant information from the asset data
|
|
const FString FunctionPathName = AssetData.ObjectPath.ToString();
|
|
const FText Description = AssetData.GetTagValueRef<FText>("Description");
|
|
TArray<FString> LibraryCategories;
|
|
{
|
|
const FString LibraryCategoriesString = AssetData.GetTagValueRef<FString>("LibraryCategories");
|
|
if (!LibraryCategoriesString.IsEmpty())
|
|
{
|
|
if (FArrayProperty* LibraryCategoriesProperty = FindFieldChecked<FArrayProperty>(UMaterialFunction::StaticClass(), TEXT("LibraryCategories")))
|
|
{
|
|
uint8* DestAddr = (uint8*)(&LibraryCategories);
|
|
LibraryCategoriesProperty->ImportText(*LibraryCategoriesString, DestAddr, PPF_None, NULL, GWarn);
|
|
}
|
|
}
|
|
}
|
|
TArray<FText> LibraryCategoriesText;
|
|
{
|
|
const FString LibraryCategoriesString = AssetData.GetTagValueRef<FString>("LibraryCategoriesText");
|
|
if (!LibraryCategoriesString.IsEmpty())
|
|
{
|
|
FArrayProperty* LibraryCategoriesProperty = FindFieldChecked<FArrayProperty>(UMaterialFunction::StaticClass(), GET_MEMBER_NAME_CHECKED(UMaterialFunction, LibraryCategoriesText));
|
|
uint8* DestAddr = (uint8*)(&LibraryCategoriesText);
|
|
LibraryCategoriesProperty->ImportText(*LibraryCategoriesString, DestAddr, PPF_None, NULL, GWarn);
|
|
}
|
|
|
|
for (const FString& Category: LibraryCategories)
|
|
{
|
|
if (!LibraryCategoriesText.ContainsByPredicate(
|
|
[&Category](const FText& Text)
|
|
{
|
|
return Text.ToString() == Category;
|
|
}))
|
|
{
|
|
LibraryCategoriesText.Add(FText::FromString(Category));
|
|
}
|
|
}
|
|
|
|
if (LibraryCategoriesText.Num() == 0)
|
|
{
|
|
LibraryCategoriesText.Add(LOCTEXT("UncategorizedMaterialFunction", "Uncategorized"));
|
|
}
|
|
}
|
|
|
|
// Extract the object name from the path
|
|
FString FunctionName = FunctionPathName;
|
|
int32 PeriodIndex = FunctionPathName.Find(TEXT("."), ESearchCase::CaseSensitive, ESearchDir::FromEnd);
|
|
|
|
if (PeriodIndex != INDEX_NONE)
|
|
{
|
|
FunctionName = FunctionPathName.Right(FunctionPathName.Len() - PeriodIndex - 1);
|
|
}
|
|
|
|
// For each category the function should belong to...
|
|
for (const FText& CategoryName: LibraryCategoriesText)
|
|
{
|
|
TSharedPtr<FMaterialGraphSchemaAction_NewFunctionCall> NewFunctionAction(new FMaterialGraphSchemaAction_NewFunctionCall(
|
|
CategoryName,
|
|
FText::FromString(FunctionName),
|
|
Description, 0));
|
|
ActionMenuBuilder.AddAction(NewFunctionAction);
|
|
NewFunctionAction->FunctionPath = FunctionPathName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetCommentAction(FGraphActionMenuBuilder& ActionMenuBuilder, const UEdGraph* CurrentGraph) const
|
|
{
|
|
if (!ActionMenuBuilder.FromPin)
|
|
{
|
|
const bool bIsManyNodesSelected = CurrentGraph ? (FMaterialEditorUtilities::GetNumberOfSelectedNodes(CurrentGraph) > 0) : false;
|
|
const FText CommentDesc = LOCTEXT("CommentDesc", "New Comment");
|
|
const FText MultiCommentDesc = LOCTEXT("MultiCommentDesc", "Create Comment from Selection");
|
|
const FText CommentToolTip = LOCTEXT("CommentToolTip", "Creates a comment.");
|
|
const FText MenuDescription = bIsManyNodesSelected ? MultiCommentDesc : CommentDesc;
|
|
TSharedPtr<FMaterialGraphSchemaAction_NewComment> NewAction(new FMaterialGraphSchemaAction_NewComment(FText::GetEmpty(), MenuDescription, CommentToolTip, 0));
|
|
ActionMenuBuilder.AddAction(NewAction);
|
|
}
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetNamedRerouteActions(FGraphActionMenuBuilder& ActionMenuBuilder, const UEdGraph* CurrentGraph) const
|
|
{
|
|
if (CurrentGraph)
|
|
{
|
|
for (UEdGraphNode* GraphNode: CurrentGraph->Nodes)
|
|
{
|
|
if (auto* MaterialGraphNode = Cast<UMaterialGraphNode>(GraphNode))
|
|
{
|
|
if (auto* Declaration = Cast<UMaterialExpressionNamedRerouteDeclaration>(MaterialGraphNode->MaterialExpression))
|
|
{
|
|
static const FText Category = LOCTEXT("NamedRerouteCategory", "Named Reroutes");
|
|
const FText Name = FText::FromString(Declaration->Name.ToString());
|
|
const FText Tooltip = FText::Format(LOCTEXT("NamedRerouteTooltip", "Add a usage of {0} here"), Name);
|
|
TSharedPtr<FMaterialGraphSchemaAction_NewNamedRerouteUsage> NewAction(new FMaterialGraphSchemaAction_NewNamedRerouteUsage(Category, Name, Tooltip, 1 /* We want named reroutes to be on top */));
|
|
NewAction->Declaration = Declaration;
|
|
ActionMenuBuilder.AddAction(NewAction);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UMaterialGraphSchema::HasCompatibleConnection(const FAssetData& FunctionAssetData, uint32 TestType, EEdGraphPinDirection TestDirection) const
|
|
{
|
|
if (TestType != 0)
|
|
{
|
|
uint32 CombinedInputTypes = FunctionAssetData.GetTagValueRef<uint32>(GET_MEMBER_NAME_CHECKED(UMaterialFunctionInterface, CombinedInputTypes));
|
|
uint32 CombinedOutputTypes = FunctionAssetData.GetTagValueRef<uint32>(GET_MEMBER_NAME_CHECKED(UMaterialFunctionInterface, CombinedOutputTypes));
|
|
|
|
if (CombinedOutputTypes == 0)
|
|
{
|
|
// Need to load function to build combined output types
|
|
UMaterialFunctionInterface* MaterialFunction = Cast<UMaterialFunctionInterface>(FunctionAssetData.GetAsset());
|
|
if (MaterialFunction != nullptr)
|
|
{
|
|
CombinedInputTypes = MaterialFunction->CombinedInputTypes;
|
|
CombinedOutputTypes = MaterialFunction->CombinedOutputTypes;
|
|
}
|
|
}
|
|
|
|
if (TestDirection == EGPD_Output)
|
|
{
|
|
if (CanConnectMaterialValueTypes(CombinedInputTypes, TestType))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (CanConnectMaterialValueTypes(TestType, CombinedOutputTypes))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool UMaterialGraphSchema::IsCacheVisualizationOutOfDate(int32 InVisualizationCacheID) const
|
|
{
|
|
return CurrentCacheRefreshID != InVisualizationCacheID;
|
|
}
|
|
|
|
int32 UMaterialGraphSchema::GetCurrentVisualizationCacheID() const
|
|
{
|
|
return CurrentCacheRefreshID;
|
|
}
|
|
|
|
void UMaterialGraphSchema::ForceVisualizationCacheClear() const
|
|
{
|
|
++CurrentCacheRefreshID;
|
|
}
|
|
|
|
void UMaterialGraphSchema::OnPinConnectionDoubleCicked(UEdGraphPin* PinA, UEdGraphPin* PinB, const FVector2D& GraphPosition) const
|
|
{
|
|
const FScopedTransaction Transaction(LOCTEXT("CreateRerouteNodeOnWire", "Create Reroute Node"));
|
|
|
|
//@TODO: This constant is duplicated from inside of SGraphNodeKnot
|
|
const FVector2D NodeSpacerSize(42.0f, 24.0f);
|
|
const FVector2D KnotTopLeft = GraphPosition - (NodeSpacerSize * 0.5f);
|
|
|
|
// Create a new knot
|
|
UEdGraph* ParentGraph = PinA->GetOwningNode()->GetGraph();
|
|
|
|
{
|
|
UMaterialExpression* Expression = FMaterialEditorUtilities::CreateNewMaterialExpression(ParentGraph, UMaterialExpressionReroute::StaticClass(), KnotTopLeft, true, true);
|
|
|
|
// Move the connections across (only notifying the knot, as the other two didn't really change)
|
|
PinA->BreakLinkTo(PinB);
|
|
PinA->MakeLinkTo((PinA->Direction == EGPD_Output) ? CastChecked<UMaterialGraphNode_Knot>(Expression->GraphNode)->GetInputPin() : CastChecked<UMaterialGraphNode_Knot>(Expression->GraphNode)->GetOutputPin());
|
|
PinB->MakeLinkTo((PinB->Direction == EGPD_Output) ? CastChecked<UMaterialGraphNode_Knot>(Expression->GraphNode)->GetInputPin() : CastChecked<UMaterialGraphNode_Knot>(Expression->GraphNode)->GetOutputPin());
|
|
FMaterialEditorUtilities::UpdateMaterialAfterGraphChange(ParentGraph);
|
|
}
|
|
}
|
|
|
|
bool UMaterialGraphSchema::SafeDeleteNodeFromGraph(UEdGraph* Graph, UEdGraphNode* NodeToDelete) const
|
|
{
|
|
if (NodeToDelete == nullptr || Graph == nullptr || NodeToDelete->GetGraph() != Graph)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TArray<UEdGraphNode*> NodesToDelete;
|
|
NodesToDelete.Add(NodeToDelete);
|
|
FMaterialEditorUtilities::DeleteNodes(Graph, NodesToDelete);
|
|
return true;
|
|
}
|
|
|
|
void UMaterialGraphSchema::GetAssetsGraphHoverMessage(const TArray<FAssetData>& Assets, const UEdGraph* HoverGraph, FString& OutTooltipText, bool& OutOkIcon) const
|
|
{
|
|
OutOkIcon = false;
|
|
|
|
for (int32 AssetIdx = 0; AssetIdx < Assets.Num(); ++AssetIdx)
|
|
{
|
|
UObject* Asset = Assets[AssetIdx].GetAsset();
|
|
UClass* MaterialExpressionClass = Cast<UClass>(Asset);
|
|
UMaterialFunctionInterface* Func = Cast<UMaterialFunctionInterface>(Asset);
|
|
UTexture* Tex = Cast<UTexture>(Asset);
|
|
UMaterialParameterCollection* ParameterCollection = Cast<UMaterialParameterCollection>(Asset);
|
|
|
|
if (MaterialExpressionClass && MaterialExpressionClass->IsChildOf(UMaterialExpression::StaticClass()))
|
|
{
|
|
OutOkIcon = true;
|
|
}
|
|
else if (Func)
|
|
{
|
|
OutOkIcon = true;
|
|
}
|
|
else if (Tex)
|
|
{
|
|
OutOkIcon = true;
|
|
}
|
|
else if (ParameterCollection)
|
|
{
|
|
OutOkIcon = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE |