Dron/Machinist_700km
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
da707629e10478cb0c8ed4d6461ba5c9d24502ba
Machinist_700km/Plugins/HoudiniEngine/Source/HoudiniEngineEditor/Private/HoudiniParameterDetails.cpp
T
Andron666 9c38e93fa4 part7
2022-12-05 20:31:35 +05:00

7404 lines
223 KiB
C++
Raw Blame History

/*
* Copyright (c) <2021> Side Effects Software Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. The name of Side Effects Software may not be used to endorse or
* promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
* NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "HoudiniParameterDetails.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniParameter.h"
#include "HoudiniParameterFloat.h"
#include "HoudiniParameterInt.h"
#include "HoudiniParameterString.h"
#include "HoudiniParameterColor.h"
#include "HoudiniParameterButton.h"
#include "HoudiniParameterButtonStrip.h"
#include "HoudiniParameterLabel.h"
#include "HoudiniParameterToggle.h"
#include "HoudiniParameterFile.h"
#include "HoudiniParameterChoice.h"
#include "HoudiniParameterFolder.h"
#include "HoudiniParameterFolderList.h"
#include "HoudiniParameterMultiParm.h"
#include "HoudiniParameterSeparator.h"
#include "HoudiniParameterRamp.h"
#include "HoudiniParameterOperatorPath.h"
#include "HoudiniInput.h"
#include "HoudiniAsset.h"
#include "HoudiniEngine.h"
#include "HoudiniEngineUtils.h"
#include "HoudiniEngineEditor.h"
#include "HoudiniEnginePrivatePCH.h"
#include "HoudiniEngineEditorPrivatePCH.h"
#include "SNewFilePathPicker.h"
#include "DetailCategoryBuilder.h"
#include "DetailLayoutBuilder.h"
#include "IDetailGroup.h"
#include "IDetailCustomization.h"
#include "PropertyCustomizationHelpers.h"
#include "DetailWidgetRow.h"
#include "Math/UnitConversion.h"
#include "ScopedTransaction.h"
#include "EditorDirectories.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SCheckBox.h"
#include "Widgets/Input/SComboBox.h"
#include "Widgets/Input/SVectorInputBox.h"
#include "Widgets/Input/SNumericEntryBox.h"
#include "Widgets/Input/SEditableTextBox.h"
#include "Widgets/Input/SMultiLineEditableTextBox.h"
#include "Widgets/Colors/SColorPicker.h"
#include "Widgets/Views/SExpanderArrow.h"
#include "Widgets/Layout/SExpandableArea.h"
#include "Widgets/Views/STableRow.h"
#include "Widgets/Input/NumericUnitTypeInterface.inl"
#include "Widgets/Images/SImage.h"
#include "Widgets/Layout/SSeparator.h"
#include "Widgets/Layout/SSplitter.h"
#include "SCurveEditorView.h"
#include "SAssetDropTarget.h"
#include "AssetThumbnail.h"
#include "Sound/SoundBase.h"
#include "Engine/SkeletalMesh.h"
#include "Particles/ParticleSystem.h"
#include "FoliageType.h"
#include "HoudiniInputDetails.h"
#include "Framework/SlateDelegates.h"
//#include "Programs/UnrealLightmass/Private/ImportExport/3DVisualizer.h"
#include "Templates/SharedPointer.h"
#define LOCTEXT_NAMESPACE HOUDINI_LOCTEXT_NAMESPACE
int32
SCustomizedButton::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect,
FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
TSharedPtr<SWidget> Content = GetContent();
// 0. Initialize Line Buffer.
TArray<FVector2D> Line;
Line.SetNumUninitialized(2);
// Initialize Color buffer.
FLinearColor Color = FLinearColor::White;
// 1. Draw the radio button.
if (bIsRadioButton)
{
// Construct the radio button circles exactly once,
// All radio buttons share the same circles then
if (FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsOuter().Num() != HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_OUTER ||
FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsInner().Num() != HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_INNER)
{
ConstructRadioButtonCircles();
}
DrawRadioButton(AllottedGeometry, OutDrawElements, LayerId, bChosen);
}
// 2. Draw background color (if selected)
if (bChosen)
{
Line[0].X = AllottedGeometry.Size.X - AllottedGeometry.Size.Y / 2.0f + 2.5f;
Line[0].Y = Content->GetDesiredSize().Y / 2.0f;
Line[1].X = AllottedGeometry.Size.Y / 2.0f - 2.5f;
Line[1].Y = Content->GetDesiredSize().Y / 2.0f;
Color = FLinearColor::White;
Color.A = bIsRadioButton ? 0.05 : 0.1;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, AllottedGeometry.Size.Y);
}
// 3. Drawing square around the text
{
// Switch the point order for each line to save few value assignment cycles
Line[0].X = 0.0f;
Line[0].Y = 0.0f;
Line[1].X = 0.0f;
Line[1].Y = Content->GetDesiredSize().Y;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, FLinearColor::Black, true, 1.0f);
//Line[0].X = 0.0f;
//Line[0].Y = Content->GetDesiredSize().Y;
Line[0].X = AllottedGeometry.Size.X;
Line[0].Y = Content->GetDesiredSize().Y;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, bChosen ? FLinearColor::Gray : FLinearColor::Black, true, 1.0f);
//Line[0].X = AllottedGeometry.Size.X;
//Line[0].Y = Content->GetDesiredSize().Y;
Line[1].X = AllottedGeometry.Size.X;
Line[1].Y = 0.0f;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, FLinearColor::Black, true, 1.0f); /* draw gray bottom line if this tab is selected, black otherwise*/
//Line[0].X = AllottedGeometry.Size.X;
//Line[0].Y = 0.0f;
Line[0].X = 0.0f;
Line[0].Y = 0.0f;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, FLinearColor::Black, true, 1.0f);
}
// 4. Draw child widget
Content->Paint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
return LayerId;
};
void
SCustomizedButton::ConstructRadioButtonCircles() const
{
TArray<FVector2D>& OuterPoints = FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsOuter();
TArray<FVector2D>& InnerPoints = FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsInner();
OuterPoints.Empty();
InnerPoints.Empty();
OuterPoints.SetNumZeroed(HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_OUTER);
InnerPoints.SetNumZeroed(8);
// Construct outer circle
int32 CurDegree = 0;
int32 DegStep = 360 / HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_OUTER;
for (int32 Idx = 0; Idx < HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_OUTER; ++Idx)
{
OuterPoints[Idx].X = HOUDINI_RADIO_BUTTON_CIRCLE_CENTER_X +
HOUDINI_RADIO_BUTTON_CIRCLE_RADIUS_OUTER * FMath::Sin(FMath::DegreesToRadians(CurDegree));
OuterPoints[Idx].Y = HOUDINI_RADIO_BUTTON_CIRCLE_CENTER_X +
HOUDINI_RADIO_BUTTON_CIRCLE_RADIUS_OUTER * FMath::Cos(FMath::DegreesToRadians(CurDegree));
CurDegree += DegStep;
}
// Construct inner circle
CurDegree = 0;
DegStep = 360 / HOUDINI_RADIO_BUTTON_CIRCLE_SAMPLES_NUM_INNER;
for (int32 Idx = 0; Idx < 8; ++Idx)
{
InnerPoints[Idx].X = HOUDINI_RADIO_BUTTON_CIRCLE_CENTER_X +
HOUDINI_RADIO_BUTTON_CIRCLE_RADIUS_INNER * FMath::Sin(FMath::DegreesToRadians(CurDegree));
InnerPoints[Idx].Y = HOUDINI_RADIO_BUTTON_CIRCLE_CENTER_X +
HOUDINI_RADIO_BUTTON_CIRCLE_RADIUS_INNER * FMath::Cos(FMath::DegreesToRadians(CurDegree));
CurDegree += DegStep;
}
}
void
SCustomizedButton::DrawRadioButton(const FGeometry& AllottedGeometry, FSlateWindowElementList& OutDrawElements, int32 LayerId, const bool& bSelected) const
{
TArray<FVector2D>& OuterPoints = FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsOuter();
TArray<FVector2D>& InnerPoints = FHoudiniEngineEditor::Get().GetHoudiniParameterRadioButtonPointsInner();
if (OuterPoints.Num() <= 1 || InnerPoints.Num() <= 1)
return;
FLinearColor ColorNonSelected = FLinearColor::White;
FLinearColor ColorSelected = FLinearColor::Yellow;
// initialize line buffer
TArray<FVector2D> Line;
Line.SetNumZeroed(2);
bool alternator = false;
// Draw outer circle
Line[0] = OuterPoints.Last();
for (int32 Idx = 0; Idx < OuterPoints.Num(); ++Idx)
{
// alternate the points order each time to some some assignment cycles
if (alternator)
{
Line[0].X = OuterPoints[Idx].X;
Line[0].Y = OuterPoints[Idx].Y;
}
else
{
Line[1].X = OuterPoints[Idx].X;
Line[1].Y = OuterPoints[Idx].Y;
}
alternator = !alternator;
// Draw a line segment
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, ColorNonSelected, true, 1.0f);
}
// Draw inner circle
alternator = false;
Line[0] = InnerPoints.Last();
for (int32 Idx = 0; Idx < InnerPoints.Num(); ++Idx)
{
// alternate the points order each time to some some assignment cycles
if (alternator)
{
Line[0].X = InnerPoints[Idx].X;
Line[0].Y = InnerPoints[Idx].Y;
}
else
{
Line[1].X = InnerPoints[Idx].X;
Line[1].Y = InnerPoints[Idx].Y;
}
alternator = !alternator;
// Draw a line segment
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, bSelected ? ColorSelected : ColorNonSelected, true, 3.0f);
}
}
void
SCustomizedBox::SetHoudiniParameter(TArray<UHoudiniParameter*>& InParams)
{
if (InParams.Num() <= 0)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
bool bIsMultiparmInstanceHeader = MainParam->IsDirectChildOfMultiParm() && MainParam->GetChildIndex() == 0;
switch (MainParam->GetParameterType())
{
case EHoudiniParameterType::Button:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_BUTTON_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_BUTTON;
}
break;
case EHoudiniParameterType::ButtonStrip:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_BUTTONSTRIP_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_BUTTONSTRIP;
}
break;
case EHoudiniParameterType::Color:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_COLOR_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_COLOR;
}
break;
case EHoudiniParameterType::ColorRamp:
{
UHoudiniParameterRampColor * ColorRampParameter = Cast<UHoudiniParameterRampColor>(MainParam);
if (!ColorRampParameter || ColorRampParameter->IsPendingKill())
return;
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_COLORRAMP;
if (ColorRampParameter->CachedPoints.Num() > 0)
MarginHeight = MarginHeight + HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_COLORRAMP_INSTANCE * (float)(ColorRampParameter->CachedPoints.Num() - 1);
}
break;
case EHoudiniParameterType::File:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILE;
}
break;
case EHoudiniParameterType::FileDir:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEDIR_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEDIR;
}
break;
case EHoudiniParameterType::FileGeo:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEGEO_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEGEO;
}
break;
case EHoudiniParameterType::FileImage:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEIMAGE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FILEIMAGE;
}
break;
case EHoudiniParameterType::Float:
{
if (MainParam->GetTupleSize() == 3)
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT_VEC3_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT_VEC3;
}
else
{
if (bIsMultiparmInstanceHeader)
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT_MULTIPARMHEADER
+ (MainParam->GetTupleSize() - 1) * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT_INSTANCE_MULTIPARMHEADER;
}
else
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT
+ (MainParam->GetTupleSize() - 1)* HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOAT_INSTANCE;
}
}
}
break;
case EHoudiniParameterType::FloatRamp:
{
UHoudiniParameterRampFloat * FloatRampParameter = Cast<UHoudiniParameterRampFloat>(MainParam);
if (!FloatRampParameter || FloatRampParameter->IsPendingKill())
return;
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOATRAMP;
if (FloatRampParameter->CachedPoints.Num() > 0)
MarginHeight = MarginHeight + Houdini_PARAMETER_UI_ROW_MARGIN_HEIGHT_FLOATRAMP_INSTANCE * (float)(FloatRampParameter->CachedPoints.Num() - 1);
}
break;
case EHoudiniParameterType::Folder:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FOLDER_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FOLDER;
}
break;
case EHoudiniParameterType::FolderList:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FOLDERLIST_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_FOLDERLIST;
}
break;
case EHoudiniParameterType::Input:
{
UHoudiniParameterOperatorPath* InputParam = Cast<UHoudiniParameterOperatorPath>(MainParam);
if (!InputParam || InputParam->IsPendingKill() || !InputParam->HoudiniInput.IsValid())
break;
UHoudiniInput* Input = InputParam->HoudiniInput.Get();
if (!Input || Input->IsPendingKill())
break;
if (bIsMultiparmInstanceHeader)
{
switch (Input->GetInputType())
{
case EHoudiniInputType::Geometry:
{
int32 ExpandedTransformUIs = 0;
for (int32 Idx = 0; Idx < Input->GetNumberOfInputObjects(); ++Idx)
{
if (Input->IsTransformUIExpanded(Idx))
ExpandedTransformUIs += 1;
}
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY_MULTIPARMHEADER
+ Input->GetNumberOfInputObjects() * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY_INSTANCE_MULTIPARMHEADER
+ ExpandedTransformUIs * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY_INSTANCE_TRANSFORM_MULTIPARMHEADER;
}
break;
case EHoudiniInputType::Curve:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_CURVE_MULTIPARMHEADER
+ Input->GetNumberOfInputObjects() * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_CURVE_INSTANCE_MULTIPARMHEADER;
}
break;
case EHoudiniInputType::Asset:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_ASSET_MULTIPARMHEADER;
}
break;
case EHoudiniInputType::Landscape:
{
if (Input->LandscapeExportType == EHoudiniLandscapeExportType::Heightfield)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_LANDSCAPE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_LANDSCAPE_MESH_MULTIPARMHEADER;
}
break;
case EHoudiniInputType::World:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_WORLD_MULTIPARMHEADER;
}
break;
case EHoudiniInputType::Skeletal:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_SKELETAL_MULTIPARMHEADER;
}
break;
default:
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_MULTIPARMHEADER;
break;
}
}
else
{
switch (Input->GetInputType())
{
case EHoudiniInputType::Geometry:
{
int32 ExpandedTransformUIs = 0;
for (int32 Idx = 0; Idx < Input->GetNumberOfInputObjects(); ++Idx)
{
if (Input->IsTransformUIExpanded(Idx))
ExpandedTransformUIs += 1;
}
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY
+ Input->GetNumberOfInputObjects() * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY_INSTANCE
+ ExpandedTransformUIs * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_GEOMETRY_INSTANCE_TRANSFORM;
}
break;
case EHoudiniInputType::Curve:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_CURVE
+ Input->GetNumberOfInputObjects() * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_CURVE_INSTANCE;
}
break;
case EHoudiniInputType::Asset:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_ASSET;
}
break;
case EHoudiniInputType::Landscape:
{
if (Input->LandscapeExportType == EHoudiniLandscapeExportType::Heightfield)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_LANDSCAPE;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_LANDSCAPE_MESH;
}
break;
case EHoudiniInputType::World:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_WORLD;
}
break;
case EHoudiniInputType::Skeletal:
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT_SKELETAL;
}
break;
default:
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INPUT;
break;
}
}
}
break;
case EHoudiniParameterType::Int:
{
if (MainParam->GetTupleSize() == 3)
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT_VEC3_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT_VEC3;
}
else
{
if (bIsMultiparmInstanceHeader)
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT_MULTIPARMHEADER +
(MainParam->GetTupleSize() - 1) * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT_INSTANCE_MULTIPARMHEADER;
}
else
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT
+ (MainParam->GetTupleSize() - 1) * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INT_INSTANCE;
}
}
}
break;
case EHoudiniParameterType::IntChoice:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INTCHOICE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INTCHOICE;
}
break;
case EHoudiniParameterType::Label:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_LABEL_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_LABEL;
}
break;
case EHoudiniParameterType::MultiParm:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_MULTIPARM_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_MULTIPARM;
}
break;
case EHoudiniParameterType::Separator:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_SEPARATOR_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_SEPARATOR;
bIsSeparator = true;
}
break;
case EHoudiniParameterType::String:
{
if (bIsMultiparmInstanceHeader)
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRING_MULTIPARMHEADER
+ (MainParam->GetTupleSize() - 1) * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRING_INSTANCE_MULTIPARMHEADER;
}
else
{
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRING
+ (MainParam->GetTupleSize() - 1) * HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRING_INSTANCE;
}
}
break;
case EHoudiniParameterType::StringAssetRef:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRINGASSETREF_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRINGASSETREF;
}
break;
case EHoudiniParameterType::StringChoice:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRINGCHOICE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_STRINGCHOICE;
}
break;
case EHoudiniParameterType::Toggle:
{
if (bIsMultiparmInstanceHeader)
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_TOGGLE_MULTIPARMHEADER;
else
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_TOGGLE;
}
break;
case EHoudiniParameterType::Invalid:
MarginHeight = HOUDINI_PARAMETER_UI_ROW_MARGIN_HEIGHT_INVALID;
break;
default:
MarginHeight = 0.0f;
break;
}
}
float
SCustomizedBox::AddIndentation(UHoudiniParameter* InParam,
TMap<int32, UHoudiniParameterMultiParm*>& InAllMultiParms, TMap<int32, UHoudiniParameter*>& InAllFoldersAndFolderLists)
{
if (!InParam || InParam->IsPendingKill())
return 0.0f;
bool bIsMainParmSimpleFolder = false;
// Get if this Parameter is a simple / collapsible folder
if (InParam->GetParameterType() == EHoudiniParameterType::Folder)
{
UHoudiniParameterFolder* FolderParm = Cast<UHoudiniParameterFolder>(InParam);
if (FolderParm)
bIsMainParmSimpleFolder = !FolderParm->IsTab();
}
int32 ParentId = InParam->GetParentParmId();
UHoudiniParameter* CurParm = InParam;
float Indentation = 0.0f;
while (ParentId >= 0)
{
UHoudiniParameter* ParentFolder = nullptr;
UHoudiniParameterMultiParm* ParentMultiParm = nullptr;
if (InAllFoldersAndFolderLists.Contains(ParentId))
ParentFolder = InAllFoldersAndFolderLists[ParentId];
if (InAllMultiParms.Contains(ParentId))
ParentMultiParm = InAllMultiParms[ParentId];
// The parent is a folder, add one unit of indentation
if (ParentFolder)
{
// Update the parent parm id
ParentId = ParentFolder->GetParentParmId();
if (ParentFolder->GetParameterType() == EHoudiniParameterType::FolderList)
continue;
UHoudiniParameterFolder* Folder = Cast<UHoudiniParameterFolder>(ParentFolder);
if (!Folder)
continue;
// update the current parm, find the parent of new cur param in the next round
CurParm = Folder;
Indentation += 1.0f;
}
// The parent is a multiparm
else if (ParentMultiParm)
{
// Update the parent parm id
ParentId = ParentMultiParm->GetParentParmId();
if (CurParm->GetChildIndex() == 0)
{
Indentation += 0.0f;
}
else
{
Indentation += 2.0f;
}
// update the current parm, find the parent of new cur param in the next round
CurParm = ParentMultiParm;
}
else
{
// no folder/multiparm parent, end the loop
ParentId = -1;
}
}
float IndentationWidth = INDENTATION_UNIT_WIDTH * Indentation;
// Add a base indentation to non simple/collapsible param
// Since it needs more space to offset the arrow width
if (!bIsMainParmSimpleFolder)
IndentationWidth += NON_FOLDER_OFFSET_WIDTH;
this->AddSlot().AutoWidth()
[
SNew(SBox).WidthOverride(IndentationWidth)
];
return IndentationWidth;
};
int32
SCustomizedBox::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect,
FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
SHorizontalBox::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
// Initialize line buffer
TArray<FVector2D> Line;
Line.SetNumZeroed(2);
// Initialize color buffer
FLinearColor Color = FLinearColor::White;
Color.A = 0.3;
// draw the bottom line if this row is the tab folder list
if (bIsTabFolderListRow)
{
// Get the start position of the tabs bottom line (right bottom pt of the right most child widget)
float VerticalLineStartPosX = 0.0f;
float VerticalLineStartPosY = 0.0f;
float BottomLineStartPosX = 0.0f;
float BottomLineStartPosY = -1.0f;
for (int32 Idx = 0; Idx < Children.Num(); ++Idx)
{
TSharedPtr<const SWidget> CurChild = Children.GetChildAt(Idx);
if (!CurChild.IsValid())
continue;
if (Idx == 0)
{
VerticalLineStartPosX = CurChild->GetDesiredSize().X;
VerticalLineStartPosY = CurChild->GetDesiredSize().Y;
}
BottomLineStartPosX += CurChild->GetDesiredSize().X;
if (BottomLineStartPosY < 0.0f)
BottomLineStartPosY= CurChild->GetDesiredSize().Y;
}
// Draw bottom line
Line[0].X = BottomLineStartPosX;
Line[0].Y = BottomLineStartPosY;
Line[1].X = AllottedGeometry.Size.X;
Line[1].Y = BottomLineStartPosY;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.0f);
}
// Draw divider lines
{
Line[0].Y = -MarginHeight;
Line[1].Y = AllottedGeometry.Size.Y + MarginHeight;
int32 NumOfLinesToDraw = bIsTabFolderListRow ? DividerLinePositions.Num() - 1 : DividerLinePositions.Num();
for (int32 Idx = 0; Idx < NumOfLinesToDraw; ++Idx)
{
const float& CurDivider = DividerLinePositions[Idx];
Line[0].X = CurDivider;
Line[1].X = CurDivider;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.0f);
}
// Draw the last inner most divider line differently when this the tabs' row.
if (bIsTabFolderListRow && DividerLinePositions.Num() > 0)
{
const float& TabDivider = DividerLinePositions.Last();
Line[0].X = TabDivider;
Line[1].X = TabDivider;
Line[0].Y = 0.f;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.0f);
}
}
// Draw tab ending lines
{
float YPos = 0.0f;
for (const float & CurEndingDivider : EndingDividerLinePositions)
{
// Draw cur ending line (vertical)
Line[0].X = CurEndingDivider;
Line[0].Y = -2.3f;
Line[1].X = CurEndingDivider;
Line[1].Y = YPos;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.0f);
// Draw cur ending line (horizontal)
// Line[0].X = CurEndingDivider;
Line[0].Y = YPos;
Line[1].X = AllottedGeometry.Size.X;
// Line[1].Y = YPos;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.0f);
YPos += 2.0f;
}
}
// Draw the separator line if this is the row of a separator parameter
{
if (bIsSeparator)
{
Line[0].X = 25.f;
if (DividerLinePositions.Num() > 0)
Line[0].X += DividerLinePositions.Last();
Line[0].Y = AllottedGeometry.Size.Y / 2.f;
Line[1].X = AllottedGeometry.Size.X - 20.f;
Line[1].Y = Line[0].Y;
Color.A = 0.7;
FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), Line,
ESlateDrawEffect::None, Color, true, 1.5f);
}
}
return LayerId;
};
void
SHoudiniFloatRampCurveEditor::Construct(const FArguments & InArgs)
{
SCurveEditor::Construct(SCurveEditor::FArguments()
.ViewMinInput(InArgs._ViewMinInput)
.ViewMaxInput(InArgs._ViewMaxInput)
.ViewMinOutput(InArgs._ViewMinOutput)
.ViewMaxOutput(InArgs._ViewMaxOutput)
.XAxisName(InArgs._XAxisName)
.YAxisName(InArgs._YAxisName)
.HideUI(InArgs._HideUI)
.DrawCurve(InArgs._DrawCurve)
.TimelineLength(InArgs._TimelineLength)
.AllowZoomOutput(InArgs._AllowZoomOutput)
.ShowInputGridNumbers(InArgs._ShowInputGridNumbers)
.ShowOutputGridNumbers(InArgs._ShowOutputGridNumbers)
.ShowZoomButtons(InArgs._ShowZoomButtons)
.ZoomToFitHorizontal(InArgs._ZoomToFitHorizontal)
.ZoomToFitVertical(InArgs._ZoomToFitVertical)
);
UCurveEditorSettings * CurveEditorSettings = GetSettings();
if (CurveEditorSettings)
{
CurveEditorSettings->SetTangentVisibility(ECurveEditorTangentVisibility::NoTangents);
}
}
void
SHoudiniColorRampCurveEditor::Construct(const FArguments & InArgs)
{
SColorGradientEditor::Construct(SColorGradientEditor::FArguments()
.ViewMinInput(InArgs._ViewMinInput)
.ViewMaxInput(InArgs._ViewMaxInput)
);
}
FReply
SHoudiniFloatRampCurveEditor::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
FReply Reply = SCurveEditor::OnMouseButtonUp(MyGeometry, MouseEvent);
if (!HoudiniFloatRampCurve.IsValid())
return Reply;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
FRichCurve& FloatCurve = HoudiniFloatRampCurve.Get()->FloatCurve;
TArray<TWeakObjectPtr<UHoudiniParameterRampFloat>>& FloatRampParameters = HoudiniFloatRampCurve.Get()->FloatRampParameters;
if (FloatRampParameters.Num() < 1)
return Reply;
if (!FloatRampParameters[0].IsValid())
return Reply;
UHoudiniParameterRampFloat* MainParam = FloatRampParameters[0].Get();
if (!MainParam)
return Reply;
// Do not allow modification when the parent HDA of the main param is being cooked.
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return Reply;
// Push the points of the main float ramp param to other parameters
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(FloatRampParameters);
// Modification is based on the main parameter, use synced points if the main param is on auto update mode, use cached points otherwise.
TArray<UHoudiniParameterRampFloatPoint*> & MainPoints = (MainParam->IsAutoUpdate() && bCookingEnabled) ? MainParam->Points : MainParam->CachedPoints;
int32 NumMainPoints = MainPoints.Num();
// On mouse button up handler handles point modification only
if (FloatCurve.GetNumKeys() != NumMainPoints)
return Reply;
bool bNeedToRefreshEditor= false;
for (int32 Idx = 0; Idx < NumMainPoints; ++Idx)
{
UHoudiniParameterRampFloatPoint* MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
float& CurvePosition = FloatCurve.Keys[Idx].Time;
float& CurveValue = FloatCurve.Keys[Idx].Value;
// This point is modified
if (MainPoint->GetPosition() != CurvePosition || MainPoint->GetValue() != CurveValue)
{
// The editor needs refresh only if the main parameter is on manual mode, and has been modified
if (!(MainParam->IsAutoUpdate() && bCookingEnabled))
bNeedToRefreshEditor = true;
// Iterate through the float ramp parameter of all selected HDAs.
for (auto & NextRampFloat : FloatRampParameters)
{
if (!NextRampFloat.IsValid())
continue;
UHoudiniParameterRampFloat* SelectedRampFloat = NextRampFloat.Get();
if (!SelectedRampFloat)
continue;
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedRampFloat))
continue;
if (SelectedRampFloat->IsAutoUpdate() && bCookingEnabled)
{
// The selected float ramp parameter is on auto update mode, use its synced points.
TArray<UHoudiniParameterRampFloatPoint*> &SelectedRampPoints = SelectedRampFloat->Points;
if (SelectedRampPoints.IsValidIndex(Idx))
{
// Synced points in the selected ramp is more than or the same number as that in the main parameter,
// modify the position and value of the synced point and mark them as changed.
UHoudiniParameterRampFloatPoint*& ModifiedPoint = SelectedRampPoints[Idx];
if (!ModifiedPoint)
continue;
if (ModifiedPoint->GetPosition() != CurvePosition && ModifiedPoint->PositionParentParm)
{
ModifiedPoint->SetPosition(CurvePosition);
ModifiedPoint->PositionParentParm->MarkChanged(true);
}
if (ModifiedPoint->GetValue() != CurveValue && ModifiedPoint->ValueParentParm)
{
ModifiedPoint->SetValue(CurveValue);
ModifiedPoint->ValueParentParm->MarkChanged(true);
}
}
else
{
// Synced points in the selected ramp is less than that in the main parameter
// Since we have pushed the points of the main param to all of the selected ramps,
// We need to modify the insert event.
int32 IndexInEventsArray = Idx - SelectedRampPoints.Num();
if (SelectedRampFloat->ModificationEvents.IsValidIndex(Idx))
{
UHoudiniParameterRampModificationEvent*& ModEvent = SelectedRampFloat->ModificationEvents[Idx];
if (!ModEvent)
continue;
if (ModEvent->InsertPosition != CurvePosition)
ModEvent->InsertPosition = CurvePosition;
if (ModEvent->InsertFloat != CurveValue)
ModEvent->InsertFloat = CurveValue;
}
}
}
else
{
// The selected float ramp is on manual update mode, use the cached points.
TArray<UHoudiniParameterRampFloatPoint*> &FloatRampCachedPoints = SelectedRampFloat->CachedPoints;
// Since we have pushed the points in main param to all the selected float ramp,
// we need to modify the corresponding cached point in the selected float ramp.
if (FloatRampCachedPoints.IsValidIndex(Idx))
{
UHoudiniParameterRampFloatPoint*& ModifiedCachedPoint = FloatRampCachedPoints[Idx];
if (!ModifiedCachedPoint)
continue;
if (ModifiedCachedPoint->Position != CurvePosition)
{
ModifiedCachedPoint->Position = CurvePosition;
SelectedRampFloat->bCaching = true;
if (!bCookingEnabled)
{
//SelectedRampFloat->MarkChanged(true);
if (ModifiedCachedPoint->PositionParentParm)
ModifiedCachedPoint->PositionParentParm->MarkChanged(true);
}
}
if (ModifiedCachedPoint->Value != CurveValue)
{
ModifiedCachedPoint->Value = CurveValue;
SelectedRampFloat->bCaching = true;
if (!bCookingEnabled)
{
//SelectedRampFloat->MarkChanged(true);
if (ModifiedCachedPoint->ValueParentParm)
ModifiedCachedPoint->ValueParentParm->MarkChanged(true);
}
}
}
}
}
}
}
if (bNeedToRefreshEditor)
{
FHoudiniEngineUtils::UpdateEditorProperties(MainParam, true);
}
return Reply;
}
FReply
SHoudiniFloatRampCurveEditor::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
FReply Reply = SCurveEditor::OnKeyDown(MyGeometry, InKeyEvent);
if (InKeyEvent.GetKey().ToString() != FString("Enter"))
return Reply;
if (!HoudiniFloatRampCurve.IsValid() || !HoudiniFloatRampCurve.Get())
return Reply;
TArray<TWeakObjectPtr<UHoudiniParameterRampFloat>> FloatRampParameters = HoudiniFloatRampCurve.Get()->FloatRampParameters;
if (FloatRampParameters.Num() < 1)
return Reply;
if (!FloatRampParameters[0].IsValid())
return Reply;
UHoudiniParameterRampFloat* MainParam = FloatRampParameters[0].Get();
if (!MainParam)
return Reply;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
// Do nothing if the main param is on auto update mode
if (MainParam->IsAutoUpdate() && bCookingEnabled)
return Reply;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return Reply;
// Push the points in the main float ramp to the float ramp parameters in all selected HDAs.
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(FloatRampParameters);
for (auto& NextFloatRamp : FloatRampParameters)
{
if (!NextFloatRamp.IsValid())
continue;
UHoudiniParameterRampFloat* SelectedFloatRamp = NextFloatRamp.Get();
if (!SelectedFloatRamp)
continue;
if (SelectedFloatRamp->IsAutoUpdate() && bCookingEnabled)
continue;
// Do not sync the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedFloatRamp))
continue;
// Sync the cached points if the selected float ramp parameter is on manual update mode
//FHoudiniParameterDetails::SyncCachedFloatRampPoints(SelectedFloatRamp);
SelectedFloatRamp->SyncCachedPoints();
}
return Reply;
}
void
UHoudiniFloatRampCurve::OnCurveChanged(const TArray<FRichCurveEditInfo>& ChangedCurveEditInfos)
{
Super::OnCurveChanged(ChangedCurveEditInfos);
if (FloatRampParameters.Num() < 1)
return;
if (!FloatRampParameters[0].IsValid())
return;
UHoudiniParameterRampFloat* MainParam = FloatRampParameters[0].Get();
if (!MainParam)
return;
// Do not allow modification when the parent HDA of the main param is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
// Push all the points of the Main parameter to other parameters
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(FloatRampParameters);
// Modification is based on the Main Param, use synced points if the Main Param is on auto update mode, otherwise use its cached points.
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
TArray<UHoudiniParameterRampFloatPoint*> & MainPoints = (MainParam->IsAutoUpdate() && bCookingEnabled) ? MainParam->Points : MainParam->CachedPoints;
int32 NumMainPoints = MainPoints.Num();
bool bNeedUpdateEditor = false;
// OnCurveChanged handler handles point delete and insertion only
// A point is deleted.
if (FloatCurve.GetNumKeys() < NumMainPoints)
{
// Find the index of the deleted point
for (int32 Idx = 0; Idx < NumMainPoints; ++Idx)
{
UHoudiniParameterRampFloatPoint* MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
float CurPointPosition = MainPoint->GetPosition();
float CurCurvePosition = -1.0f;
if (FloatCurve.Keys.IsValidIndex(Idx))
CurCurvePosition = FloatCurve.Keys[Idx].Time;
// Delete the point at Idx
if (CurCurvePosition != CurPointPosition)
{
// Iterate through all the float ramp parameter in all the selected HDAs
for (auto & NextFloatRamp : FloatRampParameters)
{
if (!NextFloatRamp.IsValid())
continue;
UHoudiniParameterRampFloat* SelectedFloatRamp = NextFloatRamp.Get();
if (!SelectedFloatRamp)
continue;
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedFloatRamp))
continue;
if (SelectedFloatRamp->IsAutoUpdate() && bCookingEnabled)
{
TArray<UHoudiniParameterRampFloatPoint*> & SelectedRampPoints = SelectedFloatRamp->Points;
// The selected float ramp is on auto update mode:
if (SelectedRampPoints.IsValidIndex(Idx))
{
// If the number of synced points of the selected float ramp is greater or equal to the number of points of that in the main param,
// Create a Houdini engine manager event to delete the point at Idx of the selected float ramp;
UHoudiniParameterRampFloatPoint* PointToDelete = SelectedRampPoints[Idx];
if (!PointToDelete)
continue;
FHoudiniParameterDetails::CreateFloatRampParameterDeleteEvent(SelectedFloatRamp, PointToDelete->InstanceIndex);
SelectedFloatRamp->MarkChanged(true);
}
else
{
// If the number is smaller than that in the main param, since we have pushed all the points in the main param to the selected parameters,
// delete the corresponding inserting event.
int32 IdxInEventsArray = Idx - SelectedRampPoints.Num();
if (SelectedFloatRamp->ModificationEvents.IsValidIndex(IdxInEventsArray))
SelectedFloatRamp->ModificationEvents.RemoveAt(IdxInEventsArray);
}
}
else
{
// The selected float ramp is on manual update mode:
// Since we have pushed all the points in main param to the cached points of the selected float ramp,
// remove the corresponding points from the cached points array.
if (SelectedFloatRamp->CachedPoints.IsValidIndex(Idx))
{
SelectedFloatRamp->CachedPoints.RemoveAt(Idx);
SelectedFloatRamp->bCaching = true;
}
}
}
// Refresh the editor only when the main parameter is on manual update mode and has been modified.
if (!(MainParam->IsAutoUpdate() && bCookingEnabled))
bNeedUpdateEditor = true;
break;
}
}
}
// A point is inserted
else if (FloatCurve.GetNumKeys() > NumMainPoints)
{
// Find the index of the inserted point
for (int32 Idx = 0; Idx < FloatCurve.GetNumKeys(); ++Idx)
{
float CurPointPosition = -1.0f;
float CurCurvePosition = FloatCurve.Keys[Idx].Time;
if (MainPoints.IsValidIndex(Idx))
{
UHoudiniParameterRampFloatPoint*& MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
CurPointPosition = MainPoint->GetPosition();
}
// Insert instance at Idx
if (CurPointPosition != CurCurvePosition)
{
// Iterate through the float ramp parameter of all selected HDAs.
for (auto & NextFloatRamp : FloatRampParameters)
{
if (!NextFloatRamp.IsValid())
continue;
UHoudiniParameterRampFloat* SelectedFloatRamp = NextFloatRamp.Get();
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedFloatRamp))
continue;
if (SelectedFloatRamp->IsAutoUpdate() && bCookingEnabled)
{
// If the selected float ramp is on auto update mode:
// Since we have pushed all the points of main parameter to the selected,
// create a Houdini engine manager event to insert a point.
FHoudiniParameterDetails::CreateFloatRampParameterInsertEvent(
SelectedFloatRamp, CurCurvePosition, FloatCurve.Keys[Idx].Value, EHoudiniRampInterpolationType::LINEAR);
SelectedFloatRamp->MarkChanged(true);
}
else
{
// If the selected float ramp is on manual update mode:
// push a new point to the cached points array
UHoudiniParameterRampFloatPoint* NewCachedPoint = NewObject<UHoudiniParameterRampFloatPoint>(SelectedFloatRamp, UHoudiniParameterRampFloatPoint::StaticClass());
if (!NewCachedPoint)
continue;
NewCachedPoint->Position = CurCurvePosition;
NewCachedPoint->Value = FloatCurve.Keys[Idx].Value;
NewCachedPoint->Interpolation = EHoudiniRampInterpolationType::LINEAR;
if (Idx >= SelectedFloatRamp->CachedPoints.Num())
SelectedFloatRamp->CachedPoints.Add(NewCachedPoint);
else
SelectedFloatRamp->CachedPoints.Insert(NewCachedPoint, Idx);
SelectedFloatRamp->bCaching = true;
if (!bCookingEnabled)
SelectedFloatRamp->MarkChanged(true);
}
}
// Refresh the editor only when the main parameter is on manual update mode and has been modified.
if (!(MainParam->IsAutoUpdate() && bCookingEnabled))
bNeedUpdateEditor = true;
break;
}
}
}
if (bNeedUpdateEditor)
{
FHoudiniEngineUtils::UpdateEditorProperties(MainParam, true);
}
}
FReply
SHoudiniColorRampCurveEditor::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
FReply Reply = SColorGradientEditor::OnMouseButtonDown(MyGeometry, MouseEvent);
if (HoudiniColorRampCurve.IsValid())
{
UHoudiniColorRampCurve* Curve = HoudiniColorRampCurve.Get();
if (Curve)
Curve->bEditing = true;
}
return Reply;
}
FReply
SHoudiniColorRampCurveEditor::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
FReply Reply = SColorGradientEditor::OnMouseButtonUp(MyGeometry, MouseEvent);
if (HoudiniColorRampCurve.IsValid())
{
UHoudiniColorRampCurve* Curve = HoudiniColorRampCurve.Get();
if (Curve)
{
Curve->bEditing = false;
Curve->OnColorRampCurveChanged(true);
}
}
return Reply;
}
FReply
SHoudiniColorRampCurveEditor::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
FReply Reply = SColorGradientEditor::OnKeyDown(MyGeometry, InKeyEvent);
if (InKeyEvent.GetKey().ToString() != FString("Enter"))
return Reply;
if (!HoudiniColorRampCurve.IsValid() || !HoudiniColorRampCurve.Get())
return Reply;
TArray<TWeakObjectPtr<UHoudiniParameterRampColor>> &ColorRampParameters = HoudiniColorRampCurve.Get()->ColorRampParameters;
if (ColorRampParameters.Num() < 1)
return Reply;
UHoudiniParameterRampColor* MainParam = ColorRampParameters[0].Get();
if (!MainParam)
return Reply;
// Do nothing if the main param is on auto update mode
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
if (MainParam->IsAutoUpdate() && bCookingEnabled)
return Reply;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return Reply;
// Push the points in the main color ramp to the color ramp parameters in all selected HDAs.
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(ColorRampParameters);
for (auto& NextColorRamp : ColorRampParameters)
{
if (!NextColorRamp.IsValid())
continue;
UHoudiniParameterRampColor* SelectedColorRamp = NextColorRamp.Get();
if (!SelectedColorRamp)
continue;
if (SelectedColorRamp->IsAutoUpdate() && bCookingEnabled)
continue;
// Do not sync the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedColorRamp))
continue;
// Sync the cached points if the selected color ramp is on manual update mode
FHoudiniParameterDetails::SyncCachedColorRampPoints(SelectedColorRamp);
}
return Reply;
}
void
UHoudiniColorRampCurve::OnCurveChanged(const TArray< FRichCurveEditInfo > & ChangedCurveEditInfos)
{
Super::OnCurveChanged(ChangedCurveEditInfos);
OnColorRampCurveChanged();
}
void
UHoudiniColorRampCurve::OnColorRampCurveChanged(bool bModificationOnly)
{
// Array is always true in this case
// if (!FloatCurves)
// return;
if (ColorRampParameters.Num() < 1)
return;
if (!ColorRampParameters[0].IsValid())
return;
UHoudiniParameterRampColor* MainParam = ColorRampParameters[0].Get();
if (!MainParam)
return;
// Do not allow modification when the parent HDA of the main param is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
// Push all the points of the main parameter to other parameters
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(ColorRampParameters);
// Modification is based on the Main Param, use synced points if the Main Param is on auto update mode,otherwise use its cached points.
bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
TArray<UHoudiniParameterRampColorPoint*> & MainPoints = (MainParam->IsAutoUpdate() && bCookingEnabled) ? MainParam->Points : MainParam->CachedPoints;
int32 NumMainPoints = MainPoints.Num();
bool bNeedUpdateEditor = false;
// OnCurveChanged handler of color ramp curve editor handles point delete, insert and color change
// A point is deleted
if (FloatCurves->GetNumKeys() < NumMainPoints)
{
if (bModificationOnly)
return;
// Find the index of the deleted point
for (int32 Idx = 0; Idx < NumMainPoints; ++Idx)
{
UHoudiniParameterRampColorPoint* MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
float CurPointPosition = MainPoint->GetPosition();
float CurCurvePosition = -1.0f;
if (FloatCurves[0].Keys.IsValidIndex(Idx))
CurCurvePosition = FloatCurves[0].Keys[Idx].Time;
// Delete the point at Idx
if (CurCurvePosition != CurPointPosition)
{
// Iterate through all the color ramp parameter in all the selected HDAs
for (auto & NextColorRamp : ColorRampParameters)
{
if (!NextColorRamp.IsValid())
continue;
UHoudiniParameterRampColor* SelectedColorRamp = NextColorRamp.Get();
if (!SelectedColorRamp)
continue;
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedColorRamp))
continue;
if (SelectedColorRamp->IsAutoUpdate() && bCookingEnabled)
{
TArray<UHoudiniParameterRampColorPoint*> & SelectedRampPoints = SelectedColorRamp->Points;
// The selected color ramp is on auto update mode:
if (SelectedRampPoints.IsValidIndex(Idx))
{
// If the number of synced points of the selected color ramp is greater or equal to the number of points of that in the main param,
// create a Houdini engine manager event to delete the point at Idx of the selected float ramp;
UHoudiniParameterRampColorPoint* PointToDelete = SelectedRampPoints[Idx];
if (!PointToDelete)
continue;
FHoudiniParameterDetails::CreateColorRampParameterDeleteEvent(SelectedColorRamp, PointToDelete->InstanceIndex);
SelectedColorRamp->MarkChanged(true);
}
else
{
// If the number is smaller than that in the main param, since we have pushed all the points in the main param to the selected parameters,
// delete the corresponding inserting event.
int32 IdxInEventsArray = Idx - SelectedRampPoints.Num();
if (SelectedColorRamp->ModificationEvents.IsValidIndex(IdxInEventsArray))
SelectedColorRamp->ModificationEvents.RemoveAt(IdxInEventsArray);
}
}
else
{
// The selected color ramp is on manual update mode:
// Since we have pushed all the points in main param to the cached points of the selected float ramp,
// remove the corresponding points from the cached points array
if (SelectedColorRamp->CachedPoints.IsValidIndex(Idx))
{
SelectedColorRamp->CachedPoints.RemoveAt(Idx);
SelectedColorRamp->bCaching = true;
}
}
}
// Refresh the editor only when the main parameter is on manual update mode and has been modified.
if (!(MainParam->IsAutoUpdate() && bCookingEnabled))
bNeedUpdateEditor = true;
break;
}
}
}
// A point is inserted
else if (FloatCurves[0].GetNumKeys() > NumMainPoints)
{
if (bModificationOnly)
return;
// Find the index of the inserted point
for (int32 Idx = 0; Idx < FloatCurves[0].GetNumKeys(); ++Idx)
{
float CurPointPosition = -1.0f;
float CurCurvePosition = FloatCurves[0].Keys[Idx].Time;
if (MainPoints.IsValidIndex(Idx))
{
UHoudiniParameterRampColorPoint*& MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
CurPointPosition = MainPoint->GetPosition();
}
// Insert a point at Idx
if (CurPointPosition != CurCurvePosition)
{
// Get the interpolation value of inserted color point
FLinearColor ColorPrev = FLinearColor::Black;
FLinearColor ColorNext = FLinearColor::White;
float PositionPrev = 0.0f;
float PositionNext = 1.0f;
if (MainParam->IsAutoUpdate() && bCookingEnabled)
{
// Try to get its previous point's color
if (MainParam->Points.IsValidIndex(Idx - 1))
{
ColorPrev = MainParam->Points[Idx - 1]->GetValue();
PositionPrev = MainParam->Points[Idx - 1]->GetPosition();
}
// Try to get its next point's color
if (MainParam->Points.IsValidIndex(Idx))
{
ColorNext = MainParam->Points[Idx]->GetValue();
PositionNext = MainParam->Points[Idx]->GetPosition();
}
}
else
{
// Try to get its previous point's color
if (MainParam->CachedPoints.IsValidIndex(Idx - 1))
{
ColorPrev = MainParam->CachedPoints[Idx - 1]->GetValue();
PositionPrev = MainParam->CachedPoints[Idx - 1]->GetPosition();
}
// Try to get its next point's color
if (MainParam->CachedPoints.IsValidIndex(Idx))
{
ColorNext = MainParam->CachedPoints[Idx]->GetValue();
PositionNext = MainParam->CachedPoints[Idx]->GetPosition();
}
}
float TotalWeight = FMath::Abs(PositionNext - PositionPrev);
float PrevWeight = FMath::Abs(CurCurvePosition - PositionPrev);
float NextWeight = FMath::Abs(PositionNext - CurCurvePosition);
FLinearColor InsertedColor = ColorPrev * (PrevWeight / TotalWeight) + ColorNext * (NextWeight / TotalWeight);
// Iterate through the color ramp parameter of all selected HDAs.
for (auto & NextColorRamp : ColorRampParameters)
{
if (!NextColorRamp.IsValid())
continue;
UHoudiniParameterRampColor* SelectedColorRamp = NextColorRamp.Get();
if (!SelectedColorRamp)
continue;
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedColorRamp))
continue;
if (SelectedColorRamp->IsAutoUpdate() && bCookingEnabled)
{
// If the selected color ramp is on auto update mode:
// Since we have pushed all the points of main parameter to the selected,
// create a Houdini engine manager event to insert a point.
FHoudiniParameterDetails::CreateColorRampParameterInsertEvent(
SelectedColorRamp, CurCurvePosition, InsertedColor, EHoudiniRampInterpolationType::LINEAR);
SelectedColorRamp->MarkChanged(true);
}
else
{
// If the selected color ramp is on manual update mode:
// Push a new point to the cached points array
UHoudiniParameterRampColorPoint* NewCachedPoint = NewObject<UHoudiniParameterRampColorPoint>(SelectedColorRamp, UHoudiniParameterRampColorPoint::StaticClass());
if (!NewCachedPoint)
continue;
NewCachedPoint->Position = CurCurvePosition;
NewCachedPoint->Value = InsertedColor;
NewCachedPoint->Interpolation = EHoudiniRampInterpolationType::LINEAR;
if (Idx >= SelectedColorRamp->CachedPoints.Num())
SelectedColorRamp->CachedPoints.Add(NewCachedPoint);
else
SelectedColorRamp->CachedPoints.Insert(NewCachedPoint, Idx);
SelectedColorRamp->bCaching = true;
}
}
// Refresh the editor only when the main parameter is on manual update mode and has been modified.
if (!MainParam->IsAutoUpdate() && bCookingEnabled)
bNeedUpdateEditor = true;
break;
}
}
}
// A point's color is changed
else
{
if (bEditing)
return;
for (int32 Idx = 0; Idx < NumMainPoints; ++Idx)
{
UHoudiniParameterRampColorPoint* MainPoint = MainPoints[Idx];
if (!MainPoint)
continue;
// Only handle color change
{
float CurvePosition = FloatCurves[0].Keys[Idx].Time;
float PointPosition = MainPoint->GetPosition();
FLinearColor CurveColor = FLinearColor::Black;
FLinearColor PointColor = MainPoint->GetValue();
CurveColor.R = FloatCurves[0].Keys[Idx].Value;
CurveColor.G = FloatCurves[1].Keys[Idx].Value;
CurveColor.B = FloatCurves[2].Keys[Idx].Value;
// Color is changed at Idx
if (CurveColor != PointColor || CurvePosition != PointPosition)
{
// Iterate through the all selected color ramp parameters
for (auto & NextColorRamp : ColorRampParameters)
{
if (!NextColorRamp.IsValid())
continue;
UHoudiniParameterRampColor* SelectedColorRamp = NextColorRamp.Get();
if (!SelectedColorRamp)
continue;
// Do not modify the selected parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(SelectedColorRamp))
continue;
if (SelectedColorRamp->IsAutoUpdate() && bCookingEnabled)
{
// The selected color ramp parameter is on auto update mode
if (SelectedColorRamp->Points.IsValidIndex(Idx))
{
// If the number of synced points in the selected color ramp is more or equal to that in the main parameter:
// Modify the corresponding synced point of the selected color ramp, and marked it as changed.
UHoudiniParameterRampColorPoint* Point = SelectedColorRamp->Points[Idx];
if (!Point)
continue;
if (Point->GetValue() != CurveColor && Point->ValueParentParm)
{
Point->SetValue(CurveColor);
Point->ValueParentParm->MarkChanged(true);
}
if (Point->GetPosition() != CurvePosition && Point->PositionParentParm)
{
Point->SetPosition(CurvePosition);
Point->PositionParentParm->MarkChanged(true);
}
}
else
{
// If the number of synced points in the selected color ramp is less than that in the main parameter:
// Since we have push the points in the main parameter to all selected parameters,
// we need to modify the corresponding insert event.
int32 IdxInEventsArray = Idx - SelectedColorRamp->Points.Num();
if (SelectedColorRamp->ModificationEvents.IsValidIndex(IdxInEventsArray))
{
UHoudiniParameterRampModificationEvent* Event = SelectedColorRamp->ModificationEvents[IdxInEventsArray];
if (!Event)
continue;
if (Event->InsertColor != CurveColor)
Event->InsertColor = CurveColor;
if (Event->InsertPosition != CurvePosition)
Event->InsertPosition = CurvePosition;
}
}
}
else
{
// The selected color ramp is on manual update mode
// Since we have push the points in the main parameter to all selected parameters,
// modify the corresponding point in the cached points array of the selected color ramp.
if (SelectedColorRamp->CachedPoints.IsValidIndex(Idx))
{
UHoudiniParameterRampColorPoint* CachedPoint = SelectedColorRamp->CachedPoints[Idx];
if (!CachedPoint)
continue;
if (CachedPoint->Value != CurveColor)
{
CachedPoint->Value = CurveColor;
bNeedUpdateEditor = true;
}
if (CachedPoint->Position != CurvePosition)
{
CachedPoint->Position = CurvePosition;
SelectedColorRamp->bCaching = true;
bNeedUpdateEditor = true;
}
}
}
}
}
}
}
}
if (bNeedUpdateEditor)
{
FHoudiniEngineUtils::UpdateEditorProperties(MainParam, true);
}
}
template< class T >
bool FHoudiniParameterDetails::CastParameters(
TArray<UHoudiniParameter*> InParams, TArray<T*>& OutCastedParams )
{
for (auto CurrentParam : InParams)
{
T* CastedParam = Cast<T>(CurrentParam);
if (CastedParam && !CastedParam->IsPendingKill())
OutCastedParams.Add(CastedParam);
}
return (OutCastedParams.Num() == InParams.Num());
}
void
FHoudiniParameterDetails::CreateWidget(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
if (InParams.Num() <= 0)
return;
UHoudiniParameter* InParam = InParams[0];
if (!InParam || InParam->IsPendingKill())
return;
// The directory won't parse if parameter ids are -1
// simply return
if (InParam->GetParmId() < 0)
return;
if (CurrentRampFloat)
{
// CreateWidgetFloatRamp(HouParameterCategory, InParams);
// If this parameter is a part of the last float ramp, skip it
if (InParam->GetIsChildOfMultiParm() && InParam->GetParentParmId() == CurrentRampFloat->GetParmId())
return;
// This parameter is not part of the last float ramp (we've passed all of its points/instances), reset
// CurrentRampFloat in order to continue normal processing of parameters
CurrentRampFloat = nullptr;
}
if (CurrentRampColor)
{
// CreateWidgetColorRamp(HouParameterCategory, InParams);
// if this parameter is a part of the last color ramp, skip it
if (InParam->GetIsChildOfMultiParm() && InParam->GetParentParmId() == CurrentRampColor->GetParmId())
return;
// This parameter is not part of the last color ramp (we've passed all of its points/instances), reset
// CurrentRampColor in order to continue normal processing of parameters
CurrentRampColor = nullptr;
}
switch (InParam->GetParameterType())
{
case EHoudiniParameterType::Float:
{
CreateWidgetFloat(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Int:
{
CreateWidgetInt(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::String:
{
CreateWidgetString(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::IntChoice:
case EHoudiniParameterType::StringChoice:
{
CreateWidgetChoice(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Separator:
{
TArray<UHoudiniParameterSeparator*> SepParams;
if (CastParameters<UHoudiniParameterSeparator>(InParams, SepParams))
{
bool bEnabled = InParams.IsValidIndex(0) ? !SepParams[0]->IsDisabled() : true;
CreateWidgetSeparator(HouParameterCategory, InParams, bEnabled);
}
}
break;
case EHoudiniParameterType::Color:
{
CreateWidgetColor(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Button:
{
CreateWidgetButton(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::ButtonStrip:
{
CreateWidgetButtonStrip(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Label:
{
CreateWidgetLabel(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Toggle:
{
CreateWidgetToggle(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::File:
case EHoudiniParameterType::FileDir:
case EHoudiniParameterType::FileGeo:
case EHoudiniParameterType::FileImage:
{
CreateWidgetFile(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::FolderList:
{
CreateWidgetFolderList(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Folder:
{
CreateWidgetFolder(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::MultiParm:
{
CreateWidgetMultiParm(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::FloatRamp:
{
CreateWidgetFloatRamp(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::ColorRamp:
{
CreateWidgetColorRamp(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Input:
{
CreateWidgetOperatorPath(HouParameterCategory, InParams);
}
break;
case EHoudiniParameterType::Invalid:
{
HandleUnsupportedParmType(HouParameterCategory, InParams);
}
break;
default:
{
HandleUnsupportedParmType(HouParameterCategory, InParams);
}
break;
}
// Remove a divider lines recurrsively if current parameter hits the end of a tabs
RemoveTabDividers(HouParameterCategory, InParam);
}
void
FHoudiniParameterDetails::CreateTabEndingRow(IDetailCategoryBuilder & HouParameterCategory)
{
FDetailWidgetRow & Row = HouParameterCategory.AddCustomRow(FText::GetEmpty());
TSharedPtr<SCustomizedBox> TabEndingRow = SNew(SCustomizedBox);
TabEndingRow->DividerLinePositions = DividerLinePositions;
if (TabEndingRow.IsValid())
CurrentTabEndingRow = TabEndingRow.Get();
Row.WholeRowWidget.Widget = TabEndingRow.ToSharedRef();
Row.WholeRowWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
}
void
FHoudiniParameterDetails::CreateNameWidget(FDetailWidgetRow* Row, TArray<UHoudiniParameter*> &InParams, bool WithLabel)
{
if (InParams.Num() <= 0)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam|| MainParam->IsPendingKill())
return;
if (!Row)
return;
TSharedRef< SCustomizedBox > HorizontalBox = SNew(SCustomizedBox);
HorizontalBox->DividerLinePositions = DividerLinePositions;
HorizontalBox->SetHoudiniParameter(InParams);
HorizontalBox->AddIndentation(MainParam, AllMultiParms, AllFoldersAndFolderLists);
if (MainParam->IsDirectChildOfMultiParm())
{
FString ParameterLabelStr = MainParam->GetParameterLabel();
// If it is head of an multiparm instance
if (MainParam->GetChildIndex() == 0)
{
int32 CurrentMultiParmInstanceIndex = 0;
if (MultiParmInstanceIndices.Contains(MainParam->GetParentParmId()))
{
MultiParmInstanceIndices[MainParam->GetParentParmId()] += 1;
CurrentMultiParmInstanceIndex = MultiParmInstanceIndices[MainParam->GetParentParmId()];
}
ParameterLabelStr += TEXT(" (") + FString("") + FString::FromInt(CurrentMultiParmInstanceIndex + 1) + TEXT(")");
CreateWidgetMultiParmObjectButtons(HorizontalBox, InParams);
}
const FText & FinalParameterLabelText = WithLabel ? FText::FromString(ParameterLabelStr) : FText::GetEmpty();
HorizontalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
[
SNew(STextBlock)
.Text(FinalParameterLabelText)
.ToolTipText(GetParameterTooltip(MainParam))
.Font(FEditorStyle::GetFontStyle(MainParam->IsDefault() ? TEXT("PropertyWindow.NormalFont") : TEXT("PropertyWindow.BoldFont")))
];
}
else
{
const FText & FinalParameterLabelText = WithLabel ? FText::FromString(MainParam->GetParameterLabel()) : FText::GetEmpty();
HorizontalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
[
SNew(STextBlock)
.Text(FinalParameterLabelText)
.ToolTipText(GetParameterTooltip(MainParam))
.Font(FEditorStyle::GetFontStyle(MainParam->IsDefault() ? TEXT("PropertyWindow.NormalFont") : TEXT("PropertyWindow.BoldFont")))
];
}
Row->NameWidget.Widget = HorizontalBox;
}
void
FHoudiniParameterDetails::CreateNameWidgetWithAutoUpdate(FDetailWidgetRow* Row, TArray<UHoudiniParameter*> &InParams, bool WithLabel)
{
if (!Row)
return;
if (InParams.Num() <= 0)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
FString ParameterLabelStr = MainParam->GetParameterLabel();
TSharedRef<SCustomizedBox> HorizontalBox = SNew(SCustomizedBox);
HorizontalBox->DividerLinePositions = DividerLinePositions;
HorizontalBox->SetHoudiniParameter(InParams);
HorizontalBox->AddIndentation(MainParam, AllMultiParms, AllFoldersAndFolderLists);
TSharedPtr<SVerticalBox> VerticalBox;
HorizontalBox->AddSlot()
[
SAssignNew(VerticalBox, SVerticalBox)
];
if (MainParam->IsDirectChildOfMultiParm())
{
// If it is head of an multiparm instance
if (MainParam->GetChildIndex() == 0)
{
int32 CurrentMultiParmInstanceIndex = 0;
if (MultiParmInstanceIndices.Contains(MainParam->GetParentParmId()))
{
MultiParmInstanceIndices[MainParam->GetParentParmId()] += 1;
CurrentMultiParmInstanceIndex = MultiParmInstanceIndices[MainParam->GetParentParmId()];
}
ParameterLabelStr += TEXT(" (") + FString::FromInt(CurrentMultiParmInstanceIndex + 1) + TEXT(")");
CreateWidgetMultiParmObjectButtons(HorizontalBox, InParams);
}
if (MainParam->GetParameterType() == EHoudiniParameterType::ColorRamp)
{
UHoudiniParameterRampColor* RampParameter = Cast<UHoudiniParameterRampColor>(MainParam);
if (RampParameter)
{
if (RampParameter->bCaching)
ParameterLabelStr += "*";
}
}
const FText & FinalParameterLabelText = WithLabel ? FText::FromString(ParameterLabelStr) : FText::GetEmpty();
VerticalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
[
SNew(STextBlock)
.Text(FinalParameterLabelText)
.ToolTipText(GetParameterTooltip(MainParam))
.Font(FEditorStyle::GetFontStyle(MainParam->IsDefault() ? TEXT("PropertyWindow.NormalFont") : TEXT("PropertyWindow.BoldFont")))
];
}
else
{
// TODO: Refactor me...extend 'auto/manual update' to all parameters? (It only applies to color and float ramps for now.)
bool bParamNeedUpdate = false;
if (MainParam->GetParameterType() == EHoudiniParameterType::ColorRamp)
{
UHoudiniParameterRampColor* RampParameter = Cast<UHoudiniParameterRampColor>(MainParam);
if (RampParameter)
bParamNeedUpdate = RampParameter->bCaching;
}
else if (MainParam->GetParameterType() == EHoudiniParameterType::FloatRamp)
{
UHoudiniParameterRampFloat* RampParameter = Cast<UHoudiniParameterRampFloat>(MainParam);
if (RampParameter)
bParamNeedUpdate = RampParameter->bCaching;
}
if (bParamNeedUpdate)
ParameterLabelStr += "*";
const FText & FinalParameterLabelText = WithLabel ? FText::FromString(ParameterLabelStr) : FText::GetEmpty();
VerticalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
[
SNew(STextBlock)
.Text(FinalParameterLabelText)
.ToolTipText(GetParameterTooltip(MainParam))
.Font(FEditorStyle::GetFontStyle(MainParam->IsDefault() ? TEXT("PropertyWindow.NormalFont") : TEXT("PropertyWindow.BoldFont")))
];
}
auto IsAutoUpdateChecked = [MainParam]()
{
if (!MainParam || MainParam->IsPendingKill())
return ECheckBoxState::Unchecked;
return MainParam->IsAutoUpdate() ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
};
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
auto OnAutoUpdateCheckBoxStateChanged = [MainParam, InParams, bCookingEnabled](ECheckBoxState NewState)
{
if (NewState == ECheckBoxState::Checked)
{
for (auto & NextSelectedParam : InParams)
{
if (!NextSelectedParam)
continue;
if (NextSelectedParam->IsAutoUpdate() && bCookingEnabled)
continue;
// Do not allow mode change when the Houdini asset component is cooking
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(NextSelectedParam))
continue;
switch (MainParam->GetParameterType())
{
case EHoudiniParameterType::ColorRamp:
{
UHoudiniParameterRampColor* ColorRampParameter = Cast<UHoudiniParameterRampColor>(NextSelectedParam);
if (!ColorRampParameter)
continue;
// Do not sync the selected color ramp parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(ColorRampParameter))
continue;
// Sync the Cached curve points at update mode switch.
FHoudiniParameterDetails::SyncCachedColorRampPoints(ColorRampParameter);
}
break;
case EHoudiniParameterType::FloatRamp:
{
UHoudiniParameterRampFloat* FloatRampParameter = Cast<UHoudiniParameterRampFloat>(NextSelectedParam);
if (!FloatRampParameter)
continue;
// Do not sync the selected float ramp parameter if its parent HDA is being cooked
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(FloatRampParameter))
continue;
// Sync the Cached curve points at update mode switch.
//FHoudiniParameterDetails::SyncCachedFloatRampPoints(FloatRampParameter);
FloatRampParameter->SyncCachedPoints();
}
break;
default:
break;
}
NextSelectedParam->SetAutoUpdate(true);
}
}
else
{
for (auto & NextSelectedParam : InParams)
{
if (!NextSelectedParam)
continue;
if (!(NextSelectedParam->IsAutoUpdate() && bCookingEnabled))
continue;
// Do not allow mode change when the Houdini asset component is cooking
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(NextSelectedParam))
continue;
NextSelectedParam->SetAutoUpdate(false);
}
}
};
// Auto update check box
TSharedPtr<SCheckBox> CheckBox;
VerticalBox->AddSlot()
.VAlign(VAlign_Center)
.HAlign(HAlign_Left)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
[
SAssignNew(CheckBox, SCheckBox)
.OnCheckStateChanged_Lambda([OnAutoUpdateCheckBoxStateChanged](ECheckBoxState NewState)
{
OnAutoUpdateCheckBoxStateChanged(NewState);
})
.IsChecked_Lambda([IsAutoUpdateChecked]()
{
return IsAutoUpdateChecked();
})
.Content()
[
SNew(STextBlock)
.Text(LOCTEXT("AutoUpdate", "Auto-update"))
.ToolTipText(LOCTEXT("AutoUpdateTip", "When enabled, this parameter will automatically update its value while editing. Turning this off will allow you to more easily update it, and the update can be pushed by checking the toggle again."))
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
]
]
];
if ((MainParam->GetParameterType() != EHoudiniParameterType::FloatRamp) && (MainParam->GetParameterType() != EHoudiniParameterType::ColorRamp))
CheckBox->SetVisibility(EVisibility::Hidden);
Row->NameWidget.Widget = HorizontalBox;
}
FDetailWidgetRow*
FHoudiniParameterDetails::CreateNestedRow(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> InParams, bool bDecreaseChildCount)
{
if (InParams.Num() <= 0)
return nullptr;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return nullptr;
// Created row for the current parameter (if there is not a row created, do not show the parameter).
FDetailWidgetRow* Row = nullptr;
// Current parameter is in a multiparm instance (directly)
if (MainParam->IsDirectChildOfMultiParm())
{
int32 ParentMultiParmId = MainParam->GetParentParmId();
// If this is a folder param, its folder list parent parm is the multiparm
if (MainParam->GetParameterType() == EHoudiniParameterType::Folder)
{
if (!AllFoldersAndFolderLists.Contains(MainParam->GetParentParmId())) // This should not happen
return nullptr;
UHoudiniParameterFolderList* ParentFolderList = Cast<UHoudiniParameterFolderList>(AllFoldersAndFolderLists[MainParam->GetParentParmId()]);
if (!ParentFolderList || ParentFolderList->IsPendingKill())
return nullptr; // This should not happen
ParentMultiParmId = ParentFolderList->GetParentParmId();
}
if (!AllMultiParms.Contains(ParentMultiParmId)) // This should not happen normally
return nullptr;
// Get the parent multiparm
UHoudiniParameterMultiParm* ParentMultiParm = AllMultiParms[ParentMultiParmId];
// The parent multiparm is visible.
if (ParentMultiParm && ParentMultiParm->IsShown() && MainParam->ShouldDisplay())
{
if (MainParam->GetParameterType() != EHoudiniParameterType::FolderList)
Row = &(HouParameterCategory.AddCustomRow(FText::GetEmpty()));
}
}
// This item is not a direct child of a multiparm.
else
{
bool bIsFolder = MainParam->GetParameterType() == EHoudiniParameterType::Folder;
// If this parameter is a folder, its parent folder should be the second top of the stack
int32 NestedMinStackDepth = bIsFolder ? 1 : 0;
// Current parameter is inside a folder.
if (FolderStack.Num() > NestedMinStackDepth)
{
// If the current parameter is a folder, we take the top second queue on the stack, since the top one represents itself.
// Otherwise take the top queue on the stack.
TArray<UHoudiniParameterFolder*> & CurrentLayerFolderQueue = bIsFolder ?
FolderStack[FolderStack.Num() - 2] : FolderStack.Last();
if (CurrentLayerFolderQueue.Num() <= 0) // Error state
return nullptr;
bool bParentFolderVisible = CurrentLayerFolderQueue[0]->IsContentShown();
bool bIsSelectedTabVisible = false;
// If its parent folder is visible, display current parameter,
// Otherwise, just prune the stacks.
if (bParentFolderVisible)
{
int32 ParentFolderId = MainParam->GetParentParmId();
// If the current parameter is a folder, its parent is a folderlist.
// So we need to continue to get the parent of the folderlist.
if (MainParam->GetParameterType() == EHoudiniParameterType::Folder)
{
if (AllFoldersAndFolderLists.Contains(ParentFolderId))
ParentFolderId = AllFoldersAndFolderLists[ParentFolderId]->GetParentParmId();
else
return nullptr; // error state
}
UHoudiniParameterFolder* ParentFolder = nullptr;
if (AllFoldersAndFolderLists.Contains(ParentFolderId))
ParentFolder = Cast<UHoudiniParameterFolder>(AllFoldersAndFolderLists[ParentFolderId]);
bool bShouldDisplayRow = MainParam->ShouldDisplay();
// This row should be shown if its parent folder is shown.
if (ParentFolder)
bShouldDisplayRow &= (ParentFolder->IsTab() && ParentFolder->IsChosen()) || (!ParentFolder->IsTab() && ParentFolder->IsExpanded());
if (bShouldDisplayRow)
{
if (MainParam->GetParameterType() != EHoudiniParameterType::FolderList)
Row = &(HouParameterCategory.AddCustomRow(FText::GetEmpty()));
}
}
// prune the stack finally
if (bDecreaseChildCount)
{
CurrentLayerFolderQueue[0]->GetChildCounter() -= 1;
PruneStack();
}
}
// If this parameter is in the root dir, just create a row.
else
{
if (MainParam->ShouldDisplay())
{
if (MainParam->GetParameterType() != EHoudiniParameterType::FolderList)
Row = &(HouParameterCategory.AddCustomRow(FText::GetEmpty()));
}
}
}
if (!MainParam->IsVisible())
return nullptr;
if (Row)
CurrentTabEndingRow = nullptr;
return Row;
}
void
FHoudiniParameterDetails::HandleUnsupportedParmType(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
if (InParams.Num() < 1)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
CreateNestedRow(HouParameterCategory, (TArray<UHoudiniParameter*>)InParams);
}
void
FHoudiniParameterDetails::CreateWidgetFloat(
IDetailCategoryBuilder & HouParameterCategory,
TArray<UHoudiniParameter*>& InParams )
{
TArray<UHoudiniParameterFloat*> FloatParams;
if (!CastParameters<UHoudiniParameterFloat>(InParams, FloatParams))
return;
if (FloatParams.Num() <= 0)
return;
UHoudiniParameterFloat* MainParam = FloatParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
// Helper function to find a unit from a string (name or abbreviation)
auto ParmUnit = FUnitConversion::UnitFromString(*(MainParam->GetUnit()));
EUnit Unit = EUnit::Unspecified;
if (FUnitConversion::Settings().ShouldDisplayUnits() && ParmUnit.IsSet())
Unit = ParmUnit.GetValue();
TSharedPtr<INumericTypeInterface<float>> paramTypeInterface;
paramTypeInterface = MakeShareable(new TNumericUnitTypeInterface<float>(Unit));
// Lambdas for slider begin
auto SliderBegin = [&](TArray<UHoudiniParameterFloat*> FloatParams)
{
// Record a transaction for undo/redo
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterFloatChange", "Houdini Parameter Float: Changing a value"),
FloatParams[0]->GetOuter());
for (int Idx = 0; Idx < FloatParams.Num(); Idx++)
{
FloatParams[Idx]->Modify();
}
};
// Lambdas for slider end
auto SliderEnd = [&](TArray<UHoudiniParameterFloat*> FloatParams)
{
// Mark the value as changed to trigger an update
for (int Idx = 0; Idx < FloatParams.Num(); Idx++)
{
FloatParams[Idx]->MarkChanged(true);
}
};
// Lambdas for changing the parameter value
auto ChangeFloatValueAt = [&](const float& Value, const int32& Index, const bool& DoChange, TArray<UHoudiniParameterFloat*> FloatParams)
{
// Record a transaction for undo/redo
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterFloatChange", "Houdini Parameter Float: Changing a value"),
FloatParams[0]->GetOuter() );
bool bChanged = false;
for (int Idx = 0; Idx < FloatParams.Num(); Idx++)
{
if (!FloatParams[Idx])
continue;
FloatParams[Idx]->Modify();
if (FloatParams[Idx]->SetValueAt(Value, Index))
{
// Only mark the param has changed if DoChange is true!!!
if(DoChange)
FloatParams[Idx]->MarkChanged(true);
bChanged = true;
}
}
if (!bChanged || !DoChange)
{
// Cancel the transaction if no parameter's value has actually been changed
Transaction.Cancel();
}
};
auto RevertToDefault = [&](const int32& TupleIndex, TArray<UHoudiniParameterFloat*> FloatParams)
{
// Record a transaction for undo/redo
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterFloatChange", "Houdini Parameter Float: Revert to default value"),
FloatParams[0]->GetOuter());
if (TupleIndex < 0)
{
for (int32 Idx = 0; Idx < FloatParams.Num(); Idx++)
{
if (!FloatParams[Idx])
continue;
if (FloatParams[Idx]->IsDefault())
continue;
FloatParams[Idx]->RevertToDefault(-1);
}
}
else
{
for (int32 Idx = 0; Idx < FloatParams.Num(); Idx++)
{
if (!FloatParams[Idx])
continue;
if (FloatParams[Idx]->IsDefaultValueAtIndex(TupleIndex))
continue;
FloatParams[Idx]->RevertToDefault(TupleIndex);
}
}
return FReply::Handled();
};
TSharedRef< SVerticalBox > VerticalBox = SNew(SVerticalBox);
//TSharedRef< SVerticalBox > VerticalBox = SNew(SVerticalBox);
if (MainParam->GetTupleSize() == 3)
{
// Should we swap Y and Z fields (only relevant for Vector3)
// Ignore the swapping if that parameter has the noswap tag
bool SwapVector3 = !MainParam->GetNoSwap();
auto ChangeFloatValueUniformly = [FloatParams, ChangeFloatValueAt](const float& Val, const bool& bDoChange)
{
ChangeFloatValueAt(Val, 0, bDoChange, FloatParams);
ChangeFloatValueAt(Val, 1, bDoChange, FloatParams);
ChangeFloatValueAt(Val, 2, bDoChange, FloatParams);
};
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SVectorInputBox)
.bColorAxisLabels(true)
.AllowSpin(true)
.X(TAttribute<TOptional<float>>::Create(TAttribute<TOptional<float>>::FGetter::CreateUObject(MainParam, &UHoudiniParameterFloat::GetValue, 0)))
.Y(TAttribute<TOptional<float>>::Create(TAttribute<TOptional<float>>::FGetter::CreateUObject(MainParam, &UHoudiniParameterFloat::GetValue, SwapVector3 ? 2 : 1)))
.Z(TAttribute<TOptional<float>>::Create(TAttribute<TOptional<float>>::FGetter::CreateUObject(MainParam, &UHoudiniParameterFloat::GetValue, SwapVector3 ? 1 : 2)))
.OnXCommitted_Lambda( [ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val, ETextCommit::Type TextCommitType)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, true);
else
ChangeFloatValueAt( Val, 0, true, FloatParams);
})
.OnYCommitted_Lambda( [ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val, ETextCommit::Type TextCommitType)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, true);
else
ChangeFloatValueAt( Val, SwapVector3 ? 2 : 1, true, FloatParams);
})
.OnZCommitted_Lambda([ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val, ETextCommit::Type TextCommitType)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, true);
else
ChangeFloatValueAt( Val, SwapVector3 ? 1 : 2, true, FloatParams);
})
.OnXChanged_Lambda([ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, false);
else
ChangeFloatValueAt(Val, 0, false, FloatParams);
})
.OnYChanged_Lambda([ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, false);
else
ChangeFloatValueAt(Val, SwapVector3 ? 2 : 1, false, FloatParams);
})
.OnZChanged_Lambda([ChangeFloatValueAt, ChangeFloatValueUniformly, FloatParams, MainParam, SwapVector3](float Val)
{
if (MainParam->IsUniformLocked())
ChangeFloatValueUniformly(Val, false);
else
ChangeFloatValueAt(Val, SwapVector3 ? 1 : 2, false, FloatParams);
})
.OnBeginSliderMovement_Lambda([SliderBegin, FloatParams]() { SliderBegin(FloatParams); })
.OnEndSliderMovement_Lambda([SliderEnd, FloatParams](const float NewValue) { SliderEnd(FloatParams); })
.TypeInterface(paramTypeInterface)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(2.0f, 0.0f)
.VAlign(VAlign_Center)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().AutoWidth().HAlign(HAlign_Right).VAlign(VAlign_Center)
[
SNew(SButton)
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ClickMethod(EButtonClickMethod::MouseDown)
.ToolTipText(LOCTEXT("FloatParameterLockButtonToolTip", "When locked, change the vector value uniformly."))
.Visibility(EVisibility::Visible)
[
SNew(SImage)
.Image(MainParam->IsUniformLocked() ? FEditorStyle::GetBrush("Genericlock") : FEditorStyle::GetBrush("GenericUnlock"))
]
.OnClicked_Lambda([FloatParams, MainParam]()
{
if (!MainParam || MainParam->IsPendingKill())
return FReply::Handled();
for (auto & CurParam : FloatParams)
{
if (!CurParam || CurParam->IsPendingKill())
continue;
CurParam->SwitchUniformLock();
}
FHoudiniEngineUtils::UpdateEditorProperties(MainParam, true);
return FReply::Handled();
})
]
+ SHorizontalBox::Slot().AutoWidth().HAlign(HAlign_Left).VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RevertToDefault", "Revert to default"))
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ContentPadding(0)
.Visibility_Lambda([FloatParams]()
{
for (auto & SelectedParam : FloatParams)
{
if (!SelectedParam)
continue;
if (!SelectedParam->IsDefault())
return EVisibility::Visible;
}
return EVisibility::Hidden;
})
.OnClicked_Lambda([FloatParams, RevertToDefault]() { return RevertToDefault(-1, FloatParams); })
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("PropertyWindow.DiffersFromDefault"))
]
]
]
];
}
else
{
for (int32 Idx = 0; Idx < MainParam->GetTupleSize(); ++Idx)
{
TSharedPtr<SNumericEntryBox<float>> NumericEntryBox;
VerticalBox->AddSlot()
.Padding(2, 2, 5, 2)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().FillWidth(1.0f)
[
SAssignNew(NumericEntryBox, SNumericEntryBox< float >)
.AllowSpin(true)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.MinValue(MainParam->GetMin())
.MaxValue(MainParam->GetMax())
.MinSliderValue(MainParam->GetUIMin())
.MaxSliderValue(MainParam->GetUIMax())
.Value(TAttribute<TOptional<float>>::Create(TAttribute<TOptional<float>>::FGetter::CreateUObject(MainParam, &UHoudiniParameterFloat::GetValue, Idx)))
.OnValueChanged_Lambda([ChangeFloatValueAt, Idx, FloatParams](float Val) { ChangeFloatValueAt(Val, Idx, false, FloatParams); })
.OnValueCommitted_Lambda([ChangeFloatValueAt, Idx, FloatParams](float Val, ETextCommit::Type TextCommitType) { ChangeFloatValueAt(Val, Idx, true, FloatParams); })
.OnBeginSliderMovement_Lambda([SliderBegin, FloatParams]() { SliderBegin(FloatParams); })
.OnEndSliderMovement_Lambda([SliderEnd, FloatParams](const float NewValue) { SliderEnd(FloatParams); })
.SliderExponent(MainParam->IsLogarithmic() ?8.0f : 1.0f)
.TypeInterface(paramTypeInterface)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(2.0f, 0.0f)
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RevertToDefault", "Revert to default"))
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ContentPadding(0)
.OnClicked_Lambda([Idx, FloatParams, RevertToDefault]() { return RevertToDefault(Idx, FloatParams); })
.Visibility_Lambda([Idx, FloatParams]()
{
for (auto & SelectedParam :FloatParams)
{
if (!SelectedParam)
continue;
if (!SelectedParam->IsDefaultValueAtIndex(Idx))
return EVisibility::Visible;
}
return EVisibility::Hidden;
})
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("PropertyWindow.DiffersFromDefault"))
]
]
];
}
}
Row->ValueWidget.Widget =VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetInt(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterInt*> IntParams;
if (!CastParameters<UHoudiniParameterInt>(InParams, IntParams))
if (IntParams.Num() <= 0)
return;
UHoudiniParameterInt* MainParam = IntParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
TSharedRef< SVerticalBox > VerticalBox = SNew(SVerticalBox);
// Helper function to find a unit from a string (name or abbreviation)
auto ParmUnit = FUnitConversion::UnitFromString(*(MainParam->GetUnit()));
EUnit Unit = EUnit::Unspecified;
if (FUnitConversion::Settings().ShouldDisplayUnits() && ParmUnit.IsSet())
Unit = ParmUnit.GetValue();
TSharedPtr<INumericTypeInterface<int32>> paramTypeInterface;
paramTypeInterface = MakeShareable(new TNumericUnitTypeInterface<int32>(Unit));
// Lambda for slider begin
auto SliderBegin = [&](TArray<UHoudiniParameterInt*> IntParams)
{
// Record a transaction for undo/redo
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterIntChange", "Houdini Parameter Int: Changing a value"),
IntParams[0]->GetOuter());
for (int Idx = 0; Idx < IntParams.Num(); Idx++)
{
IntParams[Idx]->Modify();
}
};
// Lambda for slider end
auto SliderEnd = [&](TArray<UHoudiniParameterInt*> IntParams)
{
// Mark the value as changed to trigger an update
for (int Idx = 0; Idx < IntParams.Num(); Idx++)
{
IntParams[Idx]->MarkChanged(true);
}
};
// Lambda for changing the parameter value
auto ChangeIntValueAt = [&](const int32& Value, const int32& Index, const bool& DoChange, TArray<UHoudiniParameterInt*> IntParams)
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterIntChange", "Houdini Parameter Int: Changing a value"),
IntParams[0]->GetOuter());
bool bChanged = false;
for (int Idx = 0; Idx < IntParams.Num(); Idx++)
{
if (!IntParams[Idx])
continue;
IntParams[Idx]->Modify();
if (IntParams[Idx]->SetValueAt(Value, Index))
{
// Only mark the param has changed if DoChange is true!!!
if (DoChange)
IntParams[Idx]->MarkChanged(true);
bChanged = true;
}
}
if (!bChanged || !DoChange)
{
// Cancel the transaction if there is no param has actually been changed
Transaction.Cancel();
}
};
auto RevertToDefault = [&](const int32& TupleIndex, TArray<UHoudiniParameterInt*> IntParams)
{
for (int32 Idx = 0; Idx < IntParams.Num(); Idx++)
{
if (!IntParams[Idx])
continue;
if (IntParams[Idx]->IsDefaultValueAtIndex(TupleIndex))
continue;
IntParams[Idx]->RevertToDefault(TupleIndex);
}
return FReply::Handled();
};
for (int32 Idx = 0; Idx < MainParam->GetTupleSize(); ++Idx)
{
TSharedPtr< SNumericEntryBox< int32 > > NumericEntryBox;
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SAssignNew(NumericEntryBox, SNumericEntryBox< int32 >)
.AllowSpin(true)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.MinValue(MainParam->GetMin())
.MaxValue(MainParam->GetMax())
.MinSliderValue(MainParam->GetUIMin())
.MaxSliderValue(MainParam->GetUIMax())
.Value( TAttribute<TOptional<int32>>::Create(TAttribute<TOptional<int32>>::FGetter::CreateUObject(MainParam, &UHoudiniParameterInt::GetValue, Idx)))
.OnValueChanged_Lambda( [=](int32 Val) { ChangeIntValueAt(Val, Idx, false, IntParams); } )
.OnValueCommitted_Lambda([=](float Val, ETextCommit::Type TextCommitType) { ChangeIntValueAt(Val, Idx, true, IntParams); })
.OnBeginSliderMovement_Lambda( [=]() { SliderBegin(IntParams); })
.OnEndSliderMovement_Lambda([=](const float NewValue) { SliderEnd(IntParams); })
.SliderExponent(MainParam->IsLogarithmic() ? 8.0f : 1.0f)
.TypeInterface(paramTypeInterface)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(2.0f, 0.0f)
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RevertToDefault", "Revert to default"))
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ContentPadding(0)
.Visibility_Lambda([Idx, IntParams]()
{
for (auto & NextSelectedParam : IntParams)
{
if (!NextSelectedParam)
continue;
if (!NextSelectedParam->IsDefaultValueAtIndex(Idx))
return EVisibility::Visible;
}
return EVisibility::Hidden;
})
.OnClicked_Lambda([Idx, IntParams, RevertToDefault]() { return RevertToDefault(Idx, IntParams); })
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("PropertyWindow.DiffersFromDefault"))
]
]
];
/*
if (NumericEntryBox.IsValid())
NumericEntryBox->SetEnabled(!MainParam->IsDisabled());
*/
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetString( IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterString*> StringParams;
if (!CastParameters<UHoudiniParameterString>(InParams, StringParams))
return;
if (StringParams.Num() <= 0)
return;
UHoudiniParameterString* MainParam = StringParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
bool bIsMultiLine = false;
bool bIsUnrealRef = false;
UClass* UnrealRefClass = UObject::StaticClass();
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
TSharedRef< SVerticalBox > VerticalBox = SNew(SVerticalBox);
TMap<FString, FString>& Tags = MainParam->GetTags();
if (Tags.Contains(HOUDINI_PARAMETER_STRING_REF_TAG) && FCString::Atoi(*Tags[HOUDINI_PARAMETER_STRING_REF_TAG]) == 1)
{
bIsUnrealRef = true;
if (Tags.Contains(HOUDINI_PARAMETER_STRING_REF_CLASS_TAG))
{
UClass * FoundClass = FindObject<UClass>(ANY_PACKAGE, *Tags[HOUDINI_PARAMETER_STRING_REF_CLASS_TAG]);
if (FoundClass != nullptr)
{
UnrealRefClass = FoundClass;
}
}
}
if (Tags.Contains(HOUDINI_PARAMETER_STRING_MULTILINE_TAG))
{
bIsMultiLine = true;
}
for (int32 Idx = 0; Idx < MainParam->GetTupleSize(); ++Idx)
{
// Lambda for changing the parameter value
auto ChangeStringValueAt = [&](const FString& Value, UObject* ChosenObj, const int32& Index, const bool& DoChange, TArray<UHoudiniParameterString*> StringParams)
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterSrtingChange", "Houdini Parameter String: Changing a value"),
StringParams[0]->GetOuter());
bool bChanged = false;
for (int Idx = 0; Idx < StringParams.Num(); Idx++)
{
if (!StringParams[Idx])
continue;
StringParams[Idx]->Modify();
if (StringParams[Idx]->SetValueAt(Value, Index))
{
StringParams[Idx]->MarkChanged(true);
bChanged = true;
}
StringParams[Idx]->SetAssetAt(ChosenObj, Index);
}
if (!bChanged || !DoChange)
{
// Cancel the transaction if there is no param actually has been changed
Transaction.Cancel();
}
FHoudiniEngineUtils::UpdateEditorProperties(StringParams[0], false);
};
auto RevertToDefault = [&](const int32& TupleIndex, TArray<UHoudiniParameterString*> StringParams)
{
for (int32 Idx = 0; Idx < StringParams.Num(); Idx++)
{
if (!StringParams[Idx])
continue;
if (StringParams[Idx]->IsDefaultValueAtIndex(TupleIndex))
continue;
StringParams[Idx]->RevertToDefault(TupleIndex);
}
return FReply::Handled();
};
if (bIsUnrealRef)
{
TSharedPtr<SEditableTextBox> EditableTextBox;
TSharedPtr<SHorizontalBox> HorizontalBox;
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SNew(SAssetDropTarget)
.OnIsAssetAcceptableForDrop_Lambda([UnrealRefClass](const UObject* InObject)
{
return InObject->IsA(UnrealRefClass);
})
.OnAssetDropped_Lambda([=](UObject* InObject)
{
// Get the asset reference string for this object
FString ReferenceStr = UHoudiniParameterString::GetAssetReference(InObject);
ChangeStringValueAt(ReferenceStr, InObject, Idx, true, StringParams);
})
[
SAssignNew(HorizontalBox, SHorizontalBox)
]
];
// Thumbnail
// Get thumbnail pool for this builder.
TSharedPtr< FAssetThumbnailPool > AssetThumbnailPool = HouParameterCategory.GetParentLayout().GetThumbnailPool();
// Create a thumbnail for the selected object / class
UObject* EditObject = nullptr;
const FString AssetPath = MainParam->GetValueAt(Idx);
EditObject = StaticFindObject(nullptr, nullptr, *AssetPath, true);
FAssetData AssetData;
if (IsValid(EditObject))
{
AssetData = FAssetData(EditObject);
}
else
{
AssetData.AssetClass = UnrealRefClass->GetFName();
}
TSharedPtr< FAssetThumbnail > StaticMeshThumbnail = MakeShareable(
new FAssetThumbnail(AssetData, 64, 64, AssetThumbnailPool));
TSharedPtr<SBorder> ThumbnailBorder;
HorizontalBox->AddSlot().Padding(0.f, 0.f, 2.f, 0.f).AutoWidth()
[
SAssignNew(ThumbnailBorder, SBorder)
.OnMouseDoubleClick_Lambda([EditObject, Idx](const FGeometry&, const FPointerEvent&)
{
if (EditObject && GEditor)
GEditor->EditObject(EditObject);
return FReply::Handled();
})
.Padding(5.f)
[
SNew(SBox)
.WidthOverride(64)
.HeightOverride(64)
[
StaticMeshThumbnail->MakeThumbnailWidget()
]
]
];
TWeakPtr<SBorder> WeakThumbnailBorder(ThumbnailBorder);
ThumbnailBorder->SetBorderImage(TAttribute<const FSlateBrush *>::Create(
TAttribute<const FSlateBrush *>::FGetter::CreateLambda(
[WeakThumbnailBorder]()
{
TSharedPtr<SBorder> ThumbnailBorderPtr = WeakThumbnailBorder.Pin();
if (ThumbnailBorderPtr.IsValid() && ThumbnailBorderPtr->IsHovered())
return FEditorStyle::GetBrush("PropertyEditor.AssetThumbnailLight");
else
return FEditorStyle::GetBrush("PropertyEditor.AssetThumbnailShadow");
}
)
));
FText MeshNameText = FText::GetEmpty();
//if (InputObject)
// MeshNameText = FText::FromString(InputObject->GetName());
TSharedPtr<SComboButton> StaticMeshComboButton;
TSharedPtr<SHorizontalBox> ButtonBox;
HorizontalBox->AddSlot()
.Padding(0.0f, 4.0f, 4.0f, 4.0f)
.VAlign(VAlign_Center)
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.HAlign(HAlign_Fill)
[
SAssignNew(ButtonBox, SHorizontalBox)
+ SHorizontalBox::Slot()
[
SAssignNew(StaticMeshComboButton, SComboButton)
.ButtonStyle(FEditorStyle::Get(), "PropertyEditor.AssetComboStyle")
.ForegroundColor(FEditorStyle::GetColor("PropertyEditor.AssetName.ColorAndOpacity"))
.ContentPadding(2.0f)
.ButtonContent()
[
SNew(STextBlock)
.TextStyle(FEditorStyle::Get(), "PropertyEditor.AssetClass")
.Font(FEditorStyle::GetFontStyle(FName(TEXT("PropertyWindow.NormalFont"))))
.Text(FText::FromName(AssetData.AssetName))
.ToolTipText(FText::FromString(MainParam->GetValueAt(Idx)))
]
]
]
];
TWeakPtr<SComboButton> WeakStaticMeshComboButton(StaticMeshComboButton);
StaticMeshComboButton->SetOnGetMenuContent(FOnGetContent::CreateLambda(
[UnrealRefClass, WeakStaticMeshComboButton, ChangeStringValueAt, Idx, StringParams]()
{
TArray<const UClass *> AllowedClasses;
if (UnrealRefClass != UObject::StaticClass())
{
// Use the class specified by the user
AllowedClasses.Add(UnrealRefClass);
}
else
{
// Using UObject would list way too many assets, and take a long time to open the menu,
// so we need to reestrict the classes a bit
AllowedClasses.Add(UStaticMesh::StaticClass());
AllowedClasses.Add(UHoudiniAsset::StaticClass());
AllowedClasses.Add(USkeletalMesh::StaticClass());
AllowedClasses.Add(UBlueprint::StaticClass());
AllowedClasses.Add(UMaterialInterface::StaticClass());
AllowedClasses.Add(UTexture::StaticClass());
AllowedClasses.Add(ULevel::StaticClass());
AllowedClasses.Add(UStreamableRenderAsset::StaticClass());
AllowedClasses.Add(USoundBase::StaticClass());
AllowedClasses.Add(UParticleSystem::StaticClass());
AllowedClasses.Add(UFoliageType::StaticClass());
}
TArray<UFactory *> NewAssetFactories;
return PropertyCustomizationHelpers::MakeAssetPickerWithMenu(
FAssetData(nullptr),
true,
AllowedClasses,
NewAssetFactories,
FOnShouldFilterAsset(),
FOnAssetSelected::CreateLambda(
[WeakStaticMeshComboButton, ChangeStringValueAt, Idx, StringParams](const FAssetData & AssetData)
{
TSharedPtr<SComboButton> StaticMeshComboButtonPtr = WeakStaticMeshComboButton.Pin();
if (StaticMeshComboButtonPtr.IsValid())
{
StaticMeshComboButtonPtr->SetIsOpen(false);
UObject * Object = AssetData.GetAsset();
// Get the asset reference string for this object
// !! Accept null objects to allow clearing the asset picker !!
FString ReferenceStr = UHoudiniParameterString::GetAssetReference(Object);
ChangeStringValueAt(ReferenceStr, Object, Idx, true, StringParams);
}
}
),
FSimpleDelegate::CreateLambda([]() {}));
})
);
}
else if (bIsMultiLine)
{
TSharedPtr< SMultiLineEditableTextBox > MultiLineEditableTextBox;
VerticalBox->AddSlot().Padding(2, 2, 5, 2).AutoHeight()
[
SNew(SAssetDropTarget)
.OnIsAssetAcceptableForDrop_Lambda([](const UObject* InObject)
{return true;})
.OnAssetDropped_Lambda([=](UObject* InObject)
{
// Get the asset reference string for this object
FString ReferenceStr = UHoudiniParameterString::GetAssetReference(InObject);
FString NewString = ReferenceStr;
if (StringParams[0]->GetValueAt(Idx).Len() > 0)
NewString = StringParams[0]->GetValueAt(Idx) + "\n" + NewString;
ChangeStringValueAt(NewString, nullptr, Idx, true, StringParams);
})
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().FillWidth(1.0f).VAlign(VAlign_Top).MaxWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH)
[
SAssignNew(MultiLineEditableTextBox, SMultiLineEditableTextBox)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.Text(FText::FromString(MainParam->GetValueAt(Idx)))
.OnTextCommitted_Lambda([=](const FText& Val, ETextCommit::Type TextCommitType) { ChangeStringValueAt(Val.ToString(), nullptr, Idx, true, StringParams); })
]
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(2.0f, 0.0f)
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RevertToDefault", "Revert to default"))
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ContentPadding(0)
.Visibility_Lambda([Idx, StringParams]()
{
for (auto & NextSelectedParam : StringParams)
{
if (!NextSelectedParam)
continue;
if (!NextSelectedParam->IsDefaultValueAtIndex(Idx))
return EVisibility::Visible;
}
return EVisibility::Hidden;
})
.OnClicked_Lambda([Idx, StringParams, RevertToDefault]() { return RevertToDefault(Idx, StringParams); })
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("PropertyWindow.DiffersFromDefault"))
]
]
]
];
}
else
{
TSharedPtr< SEditableTextBox > EditableTextBox;
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SNew(SAssetDropTarget)
.OnIsAssetAcceptableForDrop_Lambda([](const UObject* InObject)
{return true;})
.OnAssetDropped_Lambda([=](UObject* InObject)
{
// Get the asset reference string for this object
FString ReferenceStr = UHoudiniParameterString::GetAssetReference(InObject);
ChangeStringValueAt(ReferenceStr, nullptr, Idx, true, StringParams);
})
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().FillWidth(1.0f).MaxWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH)
[
SAssignNew(EditableTextBox, SEditableTextBox)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.Text(FText::FromString(MainParam->GetValueAt(Idx)))
.OnTextCommitted_Lambda([=](const FText& Val, ETextCommit::Type TextCommitType)
{ ChangeStringValueAt(Val.ToString(), nullptr, Idx, true, StringParams); })
]
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding(2.0f, 0.0f)
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RevertToDefault", "Revert to default"))
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ContentPadding(0)
.Visibility_Lambda([Idx, StringParams]()
{
for (auto & NextSelectedParam : StringParams)
{
if (!NextSelectedParam)
continue;
if (!NextSelectedParam->IsDefaultValueAtIndex(Idx))
return EVisibility::Visible;
}
return EVisibility::Hidden;
})
.OnClicked_Lambda([Idx, StringParams, RevertToDefault]()
{ return RevertToDefault(Idx, StringParams); })
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("PropertyWindow.DiffersFromDefault"))
]
]
]
];
}
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetColor(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterColor*> ColorParams;
if (!CastParameters<UHoudiniParameterColor>(InParams, ColorParams))
return;
if (ColorParams.Num() <= 0)
return;
UHoudiniParameterColor* MainParam = ColorParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
bool bHasAlpha = (MainParam->GetTupleSize() == 4);
// Add color picker UI.
TSharedPtr<SColorBlock> ColorBlock;
TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SAssignNew(ColorBlock, SColorBlock)
.Color(MainParam->GetColorValue())
.ShowBackgroundForAlpha(bHasAlpha)
.OnMouseButtonDown_Lambda([this, ColorParams, MainParam, bHasAlpha](const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
FColorPickerArgs PickerArgs;
PickerArgs.ParentWidget = FSlateApplication::Get().GetActiveTopLevelWindow();
PickerArgs.bUseAlpha = bHasAlpha;
PickerArgs.DisplayGamma = TAttribute< float >::Create(
TAttribute< float >::FGetter::CreateUObject(GEngine, &UEngine::GetDisplayGamma));
PickerArgs.OnColorCommitted = FOnLinearColorValueChanged::CreateLambda([&](FLinearColor InColor)
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterColorChange", "Houdini Parameter Color: Changing value"),
MainParam->GetOuter(), true);
bool bChanged = false;
for (auto & Param : ColorParams)
{
if (!Param)
continue;
Param->Modify();
if (Param->SetColorValue(InColor))
{
Param->MarkChanged(true);
bChanged = true;
}
}
// cancel the transaction if there is actually no value changed
if (!bChanged)
{
Transaction.Cancel();
}
});
PickerArgs.InitialColorOverride = MainParam->GetColorValue();
PickerArgs.bOnlyRefreshOnOk = true;
OpenColorPicker(PickerArgs);
return FReply::Handled();
})
];
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetButton(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterButton*> ButtonParams;
if (!CastParameters<UHoudiniParameterButton>(InParams, ButtonParams))
return;
if (ButtonParams.Num() <= 0)
return;
UHoudiniParameterButton* MainParam = ButtonParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
FText ParameterLabelText = FText::FromString(MainParam->GetParameterLabel());
FText ParameterTooltip = GetParameterTooltip(MainParam);
TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
TSharedPtr<SButton> Button;
// Add button UI.
HorizontalBox->AddSlot().Padding(1, 2, 4, 2)
[
SAssignNew(Button, SButton)
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.Text(ParameterLabelText)
.ToolTipText(ParameterTooltip)
.OnClicked(FOnClicked::CreateLambda( [MainParam, ButtonParams]()
{
for (auto & Param : ButtonParams)
{
if (!Param)
continue;
// There is no undo redo operation for button
Param->MarkChanged(true);
}
return FReply::Handled();
}))
];
Row->ValueWidget.Widget = HorizontalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetButtonStrip(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterButtonStrip*> ButtonStripParams;
if (!CastParameters<UHoudiniParameterButtonStrip>(InParams, ButtonStripParams))
return;
if (ButtonStripParams.Num() <= 0)
return;
UHoudiniParameterButtonStrip* MainParam = ButtonStripParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
if (!Row)
return;
auto OnButtonStateChanged = [MainParam, ButtonStripParams](ECheckBoxState NewState, int32 Idx)
{
/*
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterButtonStripChange", "Houdini Parameter Button Strip: Changing value"),
MainParam->GetOuter(), true);
*/
int32 StateInt = NewState == ECheckBoxState::Checked ? 1 : 0;
bool bChanged = false;
for (auto & NextParam : ButtonStripParams)
{
if (!NextParam || NextParam->IsPendingKill())
continue;
if (!NextParam->Values.IsValidIndex(Idx))
continue;
//NextParam->Modify();
if (NextParam->SetValueAt(Idx, StateInt))
{
NextParam->MarkChanged(true);
bChanged = true;
}
}
//if (!bChanged)
// Transaction.Cancel();
};
FText ParameterLabelText = FText::FromString(MainParam->GetParameterLabel());
FText ParameterTooltip = GetParameterTooltip(MainParam);
TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
FLinearColor BgColor(0.53f, 0.81f, 0.82f, 1.0f); // Sky Blue Backgroud color
for (int32 Idx = 0; Idx < MainParam->Count; ++Idx)
{
if (!MainParam->Values.IsValidIndex(Idx) || !MainParam->Labels.IsValidIndex(Idx))
continue;
bool bPressed = MainParam->Values[Idx] > 0;
FText LabelText = FText::FromString(MainParam->Labels[Idx]);
TSharedPtr<SCheckBox> Button;
HorizontalBox->AddSlot().Padding(0).FillWidth(1.0f)
[
SAssignNew(Button, SCheckBox)
.Style(FEditorStyle::Get(), "Property.ToggleButton.Middle")
.IsChecked(bPressed ? ECheckBoxState::Checked : ECheckBoxState::Unchecked)
.OnCheckStateChanged_Lambda([OnButtonStateChanged, Idx](ECheckBoxState NewState)
{
OnButtonStateChanged(NewState, Idx);
})
.Content()
[
SNew(STextBlock)
.Text(LabelText)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
]
];
Button->SetColorAndOpacity(BgColor);
}
Row->ValueWidget.Widget = HorizontalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.MaxDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetLabel(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterLabel*> LabelParams;
if (!CastParameters<UHoudiniParameterLabel>(InParams, LabelParams))
return;
if (LabelParams.Num() <= 0)
return;
UHoudiniParameterLabel* MainParam = LabelParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
TSharedRef <SVerticalBox> VerticalBox = SNew(SVerticalBox);
for (int32 Index = 0; Index < MainParam->GetTupleSize(); ++Index)
{
FString NextLabelString = MainParam->GetStringAtIndex(Index);
FText ParameterLabelText = FText::FromString(NextLabelString);
TSharedPtr<STextBlock> TextBlock;
// Add Label UI.
VerticalBox->AddSlot().Padding(1, 2, 4, 2)
[
SAssignNew(TextBlock, STextBlock).Text(ParameterLabelText)
];
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetToggle(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterToggle*> ToggleParams;
if (!CastParameters<UHoudiniParameterToggle>(InParams, ToggleParams))
return;
if (ToggleParams.Num() <= 0)
return;
UHoudiniParameterToggle* MainParam = ToggleParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
FText ParameterLabelText = FText::FromString(MainParam->GetParameterLabel());
TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
auto IsToggleCheckedLambda = [MainParam](int32 Index)
{
if (Index >= MainParam->GetNumValues())
return ECheckBoxState::Unchecked;
if (MainParam->GetValueAt(Index))
return ECheckBoxState::Checked;
return ECheckBoxState::Unchecked;
};
auto OnToggleCheckStateChanged = [MainParam, ToggleParams](ECheckBoxState NewState, int32 Index)
{
if (Index >= MainParam->GetNumValues())
return;
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterToggleChange", "Houdini Parameter Toggle: Changing value"),
MainParam->GetOuter(), true);
bool bState = (NewState == ECheckBoxState::Checked);
bool bChanged = false;
for (auto & Param : ToggleParams)
{
if (!Param)
continue;
Param->Modify();
if (Param->SetValueAt(bState, Index))
{
bChanged = true;
Param->MarkChanged(true);
}
}
// Cancel the transaction if no parameter has actually been changed
if (!bChanged)
{
Transaction.Cancel();
}
};
for (int32 Index = 0; Index < MainParam->GetTupleSize(); ++Index)
{
TSharedPtr< SCheckBox > CheckBox;
VerticalBox->AddSlot()
.Padding(2, 2, 5, 2)
[
SAssignNew(CheckBox, SCheckBox)
.OnCheckStateChanged_Lambda([OnToggleCheckStateChanged, Index](ECheckBoxState NewState) {
OnToggleCheckStateChanged(NewState, Index);
})
.IsChecked_Lambda([IsToggleCheckedLambda, Index]() {
return IsToggleCheckedLambda(Index);
})
.Content()
[
SNew(STextBlock)
.Text(ParameterLabelText)
.ToolTipText(GetParameterTooltip(MainParam))
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
]
];
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void FHoudiniParameterDetails::CreateWidgetFile(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterFile*> FileParams;
if (!CastParameters<UHoudiniParameterFile>(InParams, FileParams))
return;
if (FileParams.Num() <= 0)
return;
UHoudiniParameterFile* MainParam = FileParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
FString FileTypeWidgetFilter = TEXT("All files (*.*)|*.*");
if (!MainParam->GetFileFilters().IsEmpty())
FileTypeWidgetFilter = FString::Printf(TEXT("%s files (%s)|%s"), *MainParam->GetFileFilters(), *MainParam->GetFileFilters(), *MainParam->GetFileFilters());
FString BrowseWidgetDirectory = FEditorDirectories::Get().GetLastDirectory(ELastDirectory::GENERIC_OPEN);
auto UpdateCheckRelativePath = [MainParam](const FString & PickedPath)
{
UHoudiniAssetComponent* HoudiniAssetComponent = Cast<UHoudiniAssetComponent>(MainParam->GetOuter());
if (MainParam->GetOuter() && !PickedPath.IsEmpty() && FPaths::IsRelative(PickedPath))
{
// Check if the path is relative to the UE4 project
FString AbsolutePath = FPaths::ConvertRelativePathToFull(PickedPath);
if (FPaths::FileExists(AbsolutePath))
{
return AbsolutePath;
}
// Check if the path is relative to the asset
if (HoudiniAssetComponent && !HoudiniAssetComponent->IsPendingKill())
{
if (HoudiniAssetComponent->HoudiniAsset && !HoudiniAssetComponent->HoudiniAsset->IsPendingKill())
{
FString AssetFilePath = FPaths::GetPath(HoudiniAssetComponent->HoudiniAsset->AssetFileName);
if (FPaths::FileExists(AssetFilePath))
{
FString UpdatedFileWidgetPath = FPaths::Combine(*AssetFilePath, *PickedPath);
if (FPaths::FileExists(UpdatedFileWidgetPath))
{
return UpdatedFileWidgetPath;
}
}
}
}
}
return PickedPath;
};
for (int32 Idx = 0; Idx < MainParam->GetTupleSize(); ++Idx)
{
FString FileWidgetPath = MainParam->GetValueAt(Idx);
FString FileWidgetBrowsePath = BrowseWidgetDirectory;
if (!FileWidgetPath.IsEmpty())
{
FString FileWidgetDirPath = FPaths::GetPath(FileWidgetPath);
if (!FileWidgetDirPath.IsEmpty())
FileWidgetBrowsePath = FileWidgetDirPath;
}
bool IsDirectoryPicker = MainParam->GetParameterType() == EHoudiniParameterType::FileDir;
bool bIsNewFile = !MainParam->IsReadOnly();
FText BrowseTooltip = LOCTEXT("FileButtonToolTipText", "Choose a file from this computer");
if (IsDirectoryPicker)
BrowseTooltip = LOCTEXT("DirButtonToolTipText", "Choose a directory from this computer");
VerticalBox->AddSlot().Padding(2, 2, 5, 2)
[
SNew(SHorizontalBox) + SHorizontalBox::Slot().FillWidth(1.0f).MaxWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH)
[
SNew(SNewFilePathPicker)
.BrowseButtonImage(FEditorStyle::GetBrush("PropertyWindow.Button_Ellipsis"))
.BrowseButtonStyle(FEditorStyle::Get(), "HoverHintOnly")
.BrowseButtonToolTip(BrowseTooltip)
.BrowseDirectory(FileWidgetBrowsePath)
.BrowseTitle(LOCTEXT("PropertyEditorTitle", "File picker..."))
.FilePath(FileWidgetPath)
.FileTypeFilter(FileTypeWidgetFilter)
.IsNewFile(bIsNewFile)
.IsDirectoryPicker(IsDirectoryPicker)
.ToolTipText_Lambda([MainParam]()
{
// return the current param value as a tooltip
FString FileValue = MainParam ? MainParam->GetValueAt(0) : FString();
return FText::FromString(FileValue);
})
.OnPathPicked(FOnPathPicked::CreateLambda([MainParam, FileParams, UpdateCheckRelativePath, Idx](const FString & PickedPath)
{
if (MainParam->GetNumValues() <= Idx)
return;
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterFileChange", "Houdini Parameter File: Changing a file path"),
MainParam->GetOuter(), true);
bool bChanged = false;
for (auto & Param : FileParams)
{
if (!Param)
continue;
Param->Modify();
if (Param->SetValueAt(UpdateCheckRelativePath(PickedPath), Idx))
{
bChanged = true;
Param->MarkChanged(true);
}
}
// Cancel the transaction if no value has actually been changed
if (!bChanged)
{
Transaction.Cancel();
}
}))
]
];
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetChoice(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams)
{
TArray<UHoudiniParameterChoice*> ChoiceParams;
if (!CastParameters<UHoudiniParameterChoice>(InParams, ChoiceParams))
return;
if (ChoiceParams.Num() <= 0)
return;
UHoudiniParameterChoice* MainParam = ChoiceParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
// Lambda for changing the parameter value
auto ChangeSelectionLambda = [ChoiceParams](TSharedPtr< FString > NewChoice, ESelectInfo::Type SelectType)
{
if (!NewChoice.IsValid())
return;
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterChoiceChange", "Houdini Parameter Choice: Changing selection"),
ChoiceParams[0]->GetOuter());
const int32 NewIntValue = ChoiceParams[0]->GetIntValueFromLabel(*NewChoice);
bool bChanged = false;
for (int Idx = 0; Idx < ChoiceParams.Num(); Idx++)
{
if (!ChoiceParams[Idx])
continue;
ChoiceParams[Idx]->Modify();
if (ChoiceParams[Idx]->SetIntValue(NewIntValue))
{
bChanged = true;
ChoiceParams[Idx]->MarkChanged(true);
ChoiceParams[Idx]->UpdateStringValueFromInt();
}
}
if (!bChanged)
{
// Cancel the transaction if no parameter was changed
Transaction.Cancel();
}
};
//
MainParam->UpdateChoiceLabelsPtr();
TArray<TSharedPtr<FString>>* OptionSource = MainParam->GetChoiceLabelsPtr();
TSharedPtr<FString> IntialSelec;
if (OptionSource && OptionSource->IsValidIndex(MainParam->GetIntValueIndex()))
{
IntialSelec = (*OptionSource)[MainParam->GetIntValueIndex()];
}
TSharedRef< SHorizontalBox > HorizontalBox = SNew(SHorizontalBox);
TSharedPtr< SComboBox< TSharedPtr< FString > > > ComboBox;
HorizontalBox->AddSlot().Padding( 2, 2, 5, 2 )
[
SAssignNew( ComboBox, SComboBox< TSharedPtr< FString > > )
.OptionsSource(OptionSource)
.InitiallySelectedItem(IntialSelec)
.OnGenerateWidget_Lambda(
[]( TSharedPtr< FString > InItem )
{
return SNew(STextBlock).Text(FText::FromString(*InItem));
})
.OnSelectionChanged_Lambda(
[ChangeSelectionLambda](TSharedPtr< FString > NewChoice, ESelectInfo::Type SelectType)
{
ChangeSelectionLambda(NewChoice, SelectType);
})
[
SNew(STextBlock)
.Text_Lambda([MainParam]() { return FText::FromString(MainParam->GetLabel()); })
.Font( FEditorStyle::GetFontStyle( TEXT( "PropertyWindow.NormalFont" ) ) )
]
];
if ( ComboBox.IsValid() )
ComboBox->SetEnabled( !MainParam->IsDisabled() );
Row->ValueWidget.Widget = HorizontalBox;
Row->ValueWidget.MinDesiredWidth( HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH );
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetSeparator(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*>& InParams, const bool& InIsEnabled)
{
if (InParams.Num() <= 0)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam)
return;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
TSharedRef<SCustomizedBox> HorizontalBox = SNew(SCustomizedBox);
HorizontalBox->DividerLinePositions = DividerLinePositions;
HorizontalBox->SetHoudiniParameter(InParams);
Row->WholeRowWidget.Widget = HorizontalBox;
}
void
FHoudiniParameterDetails::CreateWidgetOperatorPath(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterOperatorPath*> OperatorPathParams;
if (!CastParameters<UHoudiniParameterOperatorPath>(InParams, OperatorPathParams))
return;
if (OperatorPathParams.Num() <= 0)
return;
UHoudiniParameterOperatorPath* MainParam = OperatorPathParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
UHoudiniInput* MainInput = MainParam->HoudiniInput.Get();
if (!MainInput)
return;
// Build an array of edited inputs for multi edition
TArray<UHoudiniInput*> EditedInputs;
EditedInputs.Add(MainInput);
// Add the corresponding inputs found in the other HAC
for (int LinkedIdx = 1; LinkedIdx < OperatorPathParams.Num(); LinkedIdx++)
{
UHoudiniInput* LinkedInput = OperatorPathParams[LinkedIdx]->HoudiniInput.Get();
if (!LinkedInput || LinkedInput->IsPendingKill())
continue;
// Linked params should match the main param! If not try to find one that matches
if (!LinkedInput->Matches(*MainInput))
continue;
EditedInputs.Add(LinkedInput);
}
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
return;
// Create the standard parameter name widget.
CreateNameWidget(Row, InParams, true);
FHoudiniInputDetails::CreateWidget(HouParameterCategory, EditedInputs, Row);
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetFloatRamp(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
if (InParams.Num() < 1)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// TODO: remove this once we have verified that updating the Points and CachedPoints arrays in
// TODO: HoudiniParameterTranslator::BuildAllParameters() (via RampParam->UpdatePointsArray()) is sufficient.
// // Parsing a float ramp: 1->(2->3->4)*->5 //
// switch (MainParam->GetParameterType())
// {
// //*****State 1: Float Ramp*****//
// case EHoudiniParameterType::FloatRamp:
// {
// UHoudiniParameterRampFloat* FloatRampParameter = Cast<UHoudiniParameterRampFloat>(MainParam);
// if (FloatRampParameter)
// {
// CurrentRampFloat = FloatRampParameter;
// CurrentRampFloatPointsArray.Empty();
//
// CurrentRampParameterList = InParams;
//
// FDetailWidgetRow *Row = CreateWidgetRampCurveEditor(HouParameterCategory, InParams);
// CurrentRampRow = Row;
// }
// break;
// }
//
// case EHoudiniParameterType::Float:
// {
// UHoudiniParameterFloat* FloatParameter = Cast<UHoudiniParameterFloat>(MainParam);
// if (FloatParameter)
// {
// bool bCreateNewPoint = true;
// if (CurrentRampFloatPointsArray.Num() > 0)
// {
// UHoudiniParameterRampFloatPoint* LastPtInArr = CurrentRampFloatPointsArray.Last();
// if (LastPtInArr && !LastPtInArr->ValueParentParm)
// bCreateNewPoint = false;
// }
//
// //*****State 2: Float Parameter (position)*****//
// if (bCreateNewPoint)
// {
// UHoudiniParameterRampFloatPoint* NewRampFloatPoint = nullptr;
//
// int32 PointIndex = CurrentRampFloatPointsArray.Num();
// if (CurrentRampFloat->Points.IsValidIndex(PointIndex))
// {
//
// // TODO: We should reuse existing point objects, if they exist. Currently
// // this causes results in unexpected behaviour in other parts of this detail code.
// // Give this code a bit of an overhaul at some point.
// // NewRampFloatPoint = CurrentRampFloat->Points[PointIndex];
// }
//
// if (!NewRampFloatPoint)
// {
// // Create a new float ramp point, and add its pointer to the current float points buffer array.
// NewRampFloatPoint = NewObject< UHoudiniParameterRampFloatPoint >(CurrentRampFloat, FName(), CurrentRampFloat->GetMaskedFlags(RF_PropagateToSubObjects));
//
// }
//
// CurrentRampFloatPointsArray.Add(NewRampFloatPoint);
//
// if (FloatParameter->GetNumberOfValues() <= 0)
// return;
// // Set the float ramp point's position parent parm, and value
// NewRampFloatPoint->PositionParentParm = FloatParameter;
// NewRampFloatPoint->SetPosition(FloatParameter->GetValuesPtr()[0]);
// }
// //*****State 3: Float Parameter (value)*****//
// else
// {
// if (FloatParameter->GetNumberOfValues() <= 0)
// return;
// // Get the last point in the buffer array
// if (CurrentRampFloatPointsArray.Num() > 0)
// {
// // Set the last inserted float ramp point's float parent parm, and value
// UHoudiniParameterRampFloatPoint* LastAddedFloatRampPoint = CurrentRampFloatPointsArray.Last();
// LastAddedFloatRampPoint->ValueParentParm = FloatParameter;
// LastAddedFloatRampPoint->SetValue(FloatParameter->GetValuesPtr()[0]);
// }
// }
// }
//
// break;
// }
// //*****State 4: Choice parameter*****//
// case EHoudiniParameterType::IntChoice:
// {
// UHoudiniParameterChoice* ChoiceParameter = Cast<UHoudiniParameterChoice>(MainParam);
// if (ChoiceParameter && CurrentRampFloatPointsArray.Num() > 0)
// {
// // Set the last inserted float ramp point's interpolation parent parm, and value
// UHoudiniParameterRampFloatPoint* LastAddedFloatRampPoint = CurrentRampFloatPointsArray.Last();
//
// LastAddedFloatRampPoint->InterpolationParentParm = ChoiceParameter;
// LastAddedFloatRampPoint->SetInterpolation(UHoudiniParameter::GetHoudiniInterpMethodFromInt(ChoiceParameter->GetIntValue()));
//
// // Set the index of this point in the multi parm.
// LastAddedFloatRampPoint->InstanceIndex = CurrentRampFloatPointsArray.Num() - 1;
// }
//
//
// //*****State 5: All ramp points have been parsed, finish!*****//
// if (CurrentRampFloatPointsArray.Num() >= (int32)CurrentRampFloat->MultiParmInstanceCount)
// {
// CurrentRampFloatPointsArray.Sort([](const UHoudiniParameterRampFloatPoint& P1, const UHoudiniParameterRampFloatPoint& P2) {
// return P1.Position < P2.Position;
// });
//
// CurrentRampFloat->Points = CurrentRampFloatPointsArray;
//
// // Not caching, points are synced, update cached points
// if (!CurrentRampFloat->bCaching)
// {
// const int32 NumPoints = CurrentRampFloat->Points.Num();
// CurrentRampFloat->CachedPoints.SetNum(NumPoints);
// for (int32 i = 0; i < NumPoints; ++i)
// {
// UHoudiniParameterRampFloatPoint* FromPoint = CurrentRampFloat->Points[i];
// UHoudiniParameterRampFloatPoint* ToPoint = CurrentRampFloat->CachedPoints[i];
// ToPoint = nullptr;
// check(FromPoint)
// if (!ToPoint)
// {
// ToPoint = FromPoint->DuplicateAndCopyState(CurrentRampFloat, RF_NoFlags, CurrentRampFloat->GetMaskedFlags(RF_PropagateToSubObjects));
// }
// else
// {
// ToPoint->CopyStateFrom(FromPoint, true);
// }
// CurrentRampFloat->CachedPoints[i] = ToPoint;
// }
// }
//
// CreateWidgetRampPoints(HouParameterCategory, CurrentRampRow, CurrentRampFloat, CurrentRampParameterList);
//
// CurrentRampFloat->SetDefaultValues();
//
// CurrentRampFloat = nullptr;
// CurrentRampRow = nullptr;
// }
//
// break;
// }
//
// default:
// break;
// }
//*****Float Ramp*****//
if (MainParam->GetParameterType() == EHoudiniParameterType::FloatRamp)
{
UHoudiniParameterRampFloat* FloatRampParameter = Cast<UHoudiniParameterRampFloat>(MainParam);
if (FloatRampParameter)
{
CurrentRampFloat = FloatRampParameter;
FDetailWidgetRow *Row = CreateWidgetRampCurveEditor(HouParameterCategory, InParams);
CreateWidgetRampPoints(HouParameterCategory, Row, FloatRampParameter, InParams);
//FloatRampParameter->SetDefaultValues();
}
}
}
void
FHoudiniParameterDetails::CreateWidgetColorRamp(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
if (InParams.Num() < 1)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// TODO: remove this once we have verified that updating the Points and CachedPoints arrays in
// TODO: HoudiniParameterTranslator::BuildAllParameters() (via RampParam->UpdatePointsArray()) is sufficient.
// // Parsing a color ramp: 1->(2->3->4)*->5 //
// switch (MainParam->GetParameterType())
// {
// //*****State 1: Color Ramp*****//
// case EHoudiniParameterType::ColorRamp:
// {
// UHoudiniParameterRampColor* RampColor = Cast<UHoudiniParameterRampColor>(MainParam);
// if (RampColor)
// {
// CurrentRampColor = RampColor;
// CurrentRampColorPointsArray.Empty();
//
// CurrentRampParameterList = InParams;
//
// FDetailWidgetRow *Row = CreateWidgetRampCurveEditor(HouParameterCategory, InParams);
// CurrentRampRow = Row;
// }
//
// break;
// }
// //*****State 2: Float parameter*****//
// case EHoudiniParameterType::Float:
// {
// UHoudiniParameterFloat* FloatParameter = Cast<UHoudiniParameterFloat>(MainParam);
// if (FloatParameter)
// {
// // Create a new color ramp point, and add its pointer to the current color points buffer array.
// UHoudiniParameterRampColorPoint* NewRampColorPoint = nullptr;
// int32 PointIndex = CurrentRampColorPointsArray.Num();
//
// if (CurrentRampColor->Points.IsValidIndex(PointIndex))
// {
// NewRampColorPoint = CurrentRampColor->Points[PointIndex];
// }
//
// if (!NewRampColorPoint)
// {
// NewRampColorPoint = NewObject< UHoudiniParameterRampColorPoint >(CurrentRampColor, FName(), CurrentRampColor->GetMaskedFlags(RF_PropagateToSubObjects));
// }
//
// CurrentRampColorPointsArray.Add(NewRampColorPoint);
//
// if (FloatParameter->GetNumberOfValues() <= 0)
// return;
// // Set the color ramp point's position parent parm, and value
// NewRampColorPoint->PositionParentParm = FloatParameter;
// NewRampColorPoint->SetPosition(FloatParameter->GetValuesPtr()[0]);
// }
//
// break;
// }
// //*****State 3: Color parameter*****//
// case EHoudiniParameterType::Color:
// {
// UHoudiniParameterColor* ColorParameter = Cast<UHoudiniParameterColor>(MainParam);
// if (ColorParameter && CurrentRampColorPointsArray.Num() > 0)
// {
// // Set the last inserted color ramp point's color parent parm, and value
// UHoudiniParameterRampColorPoint* LastAddedColorRampPoint = CurrentRampColorPointsArray.Last();
// LastAddedColorRampPoint->ValueParentParm = ColorParameter;
// LastAddedColorRampPoint->SetValue(ColorParameter->GetColorValue());
// }
//
// break;
// }
// //*****State 4: Choice Parameter*****//
// case EHoudiniParameterType::IntChoice:
// {
// UHoudiniParameterChoice* ChoiceParameter = Cast<UHoudiniParameterChoice>(MainParam);
// if (ChoiceParameter)
// {
// // Set the last inserted color ramp point's interpolation parent parm, and value
// UHoudiniParameterRampColorPoint*& LastAddedColorRampPoint = CurrentRampColorPointsArray.Last();
//
// LastAddedColorRampPoint->InterpolationParentParm = ChoiceParameter;
// LastAddedColorRampPoint->SetInterpolation(UHoudiniParameter::GetHoudiniInterpMethodFromInt(ChoiceParameter->GetIntValue()));
//
// // Set the index of this point in the multi parm.
// LastAddedColorRampPoint->InstanceIndex = CurrentRampColorPointsArray.Num() - 1;
// }
//
//
// //*****State 5: All ramp points have been parsed, finish!*****//
// if (CurrentRampColorPointsArray.Num() >= (int32)CurrentRampColor->MultiParmInstanceCount)
// {
// CurrentRampColorPointsArray.Sort([](const UHoudiniParameterRampColorPoint& P1, const UHoudiniParameterRampColorPoint& P2)
// {
// return P1.Position < P2.Position;
// });
//
// CurrentRampColor->Points = CurrentRampColorPointsArray;
//
// // Not caching, points are synced, update cached points
//
// if (!CurrentRampColor->bCaching)
// {
// const int32 NumPoints = CurrentRampColor->Points.Num();
// CurrentRampColor->CachedPoints.SetNum(NumPoints);
//
// for (int32 i = 0; i < NumPoints; ++i)
// {
// UHoudiniParameterRampColorPoint* FromPoint = CurrentRampColor->Points[i];
// UHoudiniParameterRampColorPoint* ToPoint = CurrentRampColor->CachedPoints[i];
//
// if (!ToPoint)
// {
// ToPoint = FromPoint->DuplicateAndCopyState(CurrentRampColor, RF_NoFlags, CurrentRampColor->GetMaskedFlags(RF_PropagateToSubObjects));
// }
// else
// {
// ToPoint->CopyStateFrom(FromPoint, true);
// }
// CurrentRampColor->CachedPoints[i] = ToPoint;
// }
// }
//
//
// CreateWidgetRampPoints(HouParameterCategory, CurrentRampRow, CurrentRampColor, CurrentRampParameterList);
//
// CurrentRampColor->SetDefaultValues();
//
// CurrentRampColor = nullptr;
// CurrentRampRow = nullptr;
// }
//
// break;
// }
//
// default:
// break;
// }
//*****Color Ramp*****//
if (MainParam->GetParameterType() == EHoudiniParameterType::ColorRamp)
{
UHoudiniParameterRampColor* RampColor = Cast<UHoudiniParameterRampColor>(MainParam);
if (RampColor)
{
CurrentRampColor = RampColor;
FDetailWidgetRow *Row = CreateWidgetRampCurveEditor(HouParameterCategory, InParams);
CreateWidgetRampPoints(HouParameterCategory, Row, RampColor, InParams);
//RampColor->SetDefaultValues();
}
}
}
FDetailWidgetRow*
FHoudiniParameterDetails::CreateWidgetRampCurveEditor(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
if (InParams.Num() <= 0)
return nullptr;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam)
return nullptr;
// Create a new detail row
FDetailWidgetRow* Row = CreateNestedRow(HouParameterCategory, (TArray<UHoudiniParameter*>)InParams);
if (!Row)
return nullptr;
Row->ValueWidget.Widget->SetEnabled(!MainParam->IsDisabled());
// Create the standard parameter name widget with an added autoupdate checkbox.
CreateNameWidgetWithAutoUpdate(Row, InParams, true);
TSharedRef<SVerticalBox> VerticalBox = SNew(SVerticalBox);
if (MainParam->GetParameterType() == EHoudiniParameterType::ColorRamp)
{
UHoudiniParameterRampColor *RampColorParam = Cast<UHoudiniParameterRampColor>(MainParam);
if (!RampColorParam)
return nullptr;
TSharedPtr<SHoudiniColorRampCurveEditor> ColorGradientEditor;
VerticalBox->AddSlot()
.Padding(2, 2, 5, 2)
.AutoHeight()
[
SNew(SBorder)
.VAlign(VAlign_Fill)
[
SAssignNew(ColorGradientEditor, SHoudiniColorRampCurveEditor)
.ViewMinInput(0.0f)
.ViewMaxInput(1.0f)
]
];
if (!ColorGradientEditor.IsValid())
return nullptr;
// Avoid showing tooltips inside of the curve editor
ColorGradientEditor->EnableToolTipForceField(true);
CurrentRampParameterColorCurve = NewObject<UHoudiniColorRampCurve>(
GetTransientPackage(), UHoudiniColorRampCurve::StaticClass(), NAME_None, RF_Transactional | RF_Public);
if (!CurrentRampParameterColorCurve)
return nullptr;
CreatedColorRampCurves.Add(CurrentRampParameterColorCurve);
// Add the ramp curve to root to avoid garabage collected.
CurrentRampParameterColorCurve->AddToRoot();
TArray<UHoudiniParameterRampColor*> ColorRampParameters;
CastParameters<UHoudiniParameterRampColor>(InParams, ColorRampParameters);
for (auto NextColorRamp : ColorRampParameters)
{
CurrentRampParameterColorCurve->ColorRampParameters.Add(NextColorRamp);
}
ColorGradientEditor->HoudiniColorRampCurve = CurrentRampParameterColorCurve;
// Clear default curve points
for (int Idx = 0; Idx < 4; ++Idx)
{
FRichCurve& RichCurve = (CurrentRampParameterColorCurve->FloatCurves)[Idx];
if (RichCurve.GetNumKeys() > 0)
RichCurve.Keys.Empty();
}
ColorGradientEditor->SetCurveOwner(CurrentRampParameterColorCurve);
CreatedColorGradientEditors.Add(ColorGradientEditor);
}
else if(MainParam->GetParameterType() == EHoudiniParameterType::FloatRamp)
{
UHoudiniParameterRampFloat *RampFloatParam = Cast<UHoudiniParameterRampFloat>(MainParam);
if (!RampFloatParam)
return nullptr;
TSharedPtr<SHoudiniFloatRampCurveEditor> FloatCurveEditor;
VerticalBox->AddSlot()
.Padding(2, 2, 5, 2)
.AutoHeight()
[
SNew(SBorder)
.VAlign(VAlign_Fill)
[
SAssignNew(FloatCurveEditor, SHoudiniFloatRampCurveEditor)
.ViewMinInput(0.0f)
.ViewMaxInput(1.0f)
.HideUI(true)
.DrawCurve(true)
.ViewMinInput(0.0f)
.ViewMaxInput(1.0f)
.ViewMinOutput(0.0f)
.ViewMaxOutput(1.0f)
.TimelineLength(1.0f)
.AllowZoomOutput(false)
.ShowInputGridNumbers(false)
.ShowOutputGridNumbers(false)
.ShowZoomButtons(false)
.ZoomToFitHorizontal(false)
.ZoomToFitVertical(false)
.XAxisName(FString("X"))
.YAxisName(FString("Y"))
.ShowCurveSelector(false)
]
];
if (!FloatCurveEditor.IsValid())
return nullptr;
// Avoid showing tooltips inside of the curve editor
FloatCurveEditor->EnableToolTipForceField(true);
CurrentRampParameterFloatCurve = NewObject<UHoudiniFloatRampCurve>(
GetTransientPackage(), UHoudiniFloatRampCurve::StaticClass(), NAME_None, RF_Transactional | RF_Public);
if (!CurrentRampParameterFloatCurve)
return nullptr;
CreatedFloatRampCurves.Add(CurrentRampParameterFloatCurve);
// Add the ramp curve to root to avoid garbage collected
CurrentRampParameterFloatCurve->AddToRoot();
TArray<UHoudiniParameterRampFloat*> FloatRampParameters;
CastParameters<UHoudiniParameterRampFloat>(InParams, FloatRampParameters);
for (auto NextFloatRamp : FloatRampParameters)
{
CurrentRampParameterFloatCurve->FloatRampParameters.Add(NextFloatRamp);
}
FloatCurveEditor->HoudiniFloatRampCurve = CurrentRampParameterFloatCurve;
FloatCurveEditor->SetCurveOwner(CurrentRampParameterFloatCurve, true);
CreatedFloatCurveEditors.Add(FloatCurveEditor);
}
Row->ValueWidget.Widget = VerticalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
Row->ValueWidget.MaxDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
return Row;
}
void
FHoudiniParameterDetails::CreateWidgetRampPoints(IDetailCategoryBuilder& CategoryBuilder, FDetailWidgetRow* Row, UHoudiniParameter* InParameter, TArray<UHoudiniParameter*>& InParams)
{
if (!Row || !InParameter)
return;
if (InParams.Num() < 1)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
UHoudiniParameterRampFloat * MainFloatRampParameter = nullptr;
UHoudiniParameterRampColor * MainColorRampParameter = nullptr;
TArray<UHoudiniParameterRampFloat*> FloatRampParameterList;
TArray<UHoudiniParameterRampColor*> ColorRampParameterList;
if (MainParam->GetParameterType() == EHoudiniParameterType::FloatRamp)
{
MainFloatRampParameter = Cast<UHoudiniParameterRampFloat>(MainParam);
if (!MainFloatRampParameter)
return;
if (!CastParameters<UHoudiniParameterRampFloat>(InParams, FloatRampParameterList))
return;
}
else if (MainParam->GetParameterType() == EHoudiniParameterType::ColorRamp)
{
MainColorRampParameter = Cast<UHoudiniParameterRampColor>(MainParam);
if (!MainColorRampParameter)
return;
if (!CastParameters<UHoudiniParameterRampColor>(InParams, ColorRampParameterList))
return;
}
else
{
return;
}
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
// Lambda for computing the float point to be inserted
auto GetInsertFloatPointLambda = [MainFloatRampParameter](
const int32& InsertAtIndex,
float& OutPosition,
float& OutValue,
EHoudiniRampInterpolationType& OutInterpType) mutable
{
if (!MainFloatRampParameter)
return;
float PrevPosition = 0.0f;
float NextPosition = 1.0f;
TArray<UHoudiniParameterRampFloatPoint*> &CurrentPoints = MainFloatRampParameter->Points;
TArray<UHoudiniParameterRampFloatPoint*> &CachedPoints = MainFloatRampParameter->CachedPoints;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
int32 NumPoints = 0;
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
{
NumPoints = CurrentPoints.Num();
}
else
{
MainFloatRampParameter->SetCaching(true);
NumPoints = CachedPoints.Num();
}
if (InsertAtIndex >= NumPoints)
{
// Insert at the end
if (NumPoints > 0)
{
UHoudiniParameterRampFloatPoint* PrevPoint = nullptr;
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
PrevPoint = CurrentPoints.Last();
else
PrevPoint = CachedPoints.Last();
if (PrevPoint)
{
PrevPosition = PrevPoint->GetPosition();
OutInterpType = PrevPoint->GetInterpolation();
}
}
}
else if (InsertAtIndex <= 0)
{
// Insert at the beginning
if (NumPoints > 0)
{
UHoudiniParameterRampFloatPoint* NextPoint = nullptr;
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
NextPoint = CurrentPoints[0];
else
NextPoint = CachedPoints[0];
if (NextPoint)
{
NextPosition = NextPoint->GetPosition();
OutInterpType = NextPoint->GetInterpolation();
}
}
}
else
{
// Insert in the middle
if (NumPoints > 1)
{
UHoudiniParameterRampFloatPoint* PrevPoint = nullptr;
UHoudiniParameterRampFloatPoint* NextPoint = nullptr;
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
{
PrevPoint = CurrentPoints[InsertAtIndex - 1];
NextPoint = CurrentPoints[InsertAtIndex];
}
else
{
PrevPoint = CachedPoints[InsertAtIndex - 1];
NextPoint = CachedPoints[InsertAtIndex];
}
if (PrevPoint)
{
PrevPosition = PrevPoint->GetPosition();
OutInterpType = PrevPoint->GetInterpolation();
}
if (NextPoint)
{
NextPosition = NextPoint->GetPosition();
}
if (PrevPoint && NextPoint)
{
OutValue = (PrevPoint->GetValue() + NextPoint->GetValue()) / 2.0;
}
}
}
OutPosition = (PrevPosition + NextPosition) / 2.0f;
};
// Lambda for computing the color point to be inserted
auto GetInsertColorPointLambda = [MainColorRampParameter](
const int32& InsertAtIndex,
float& OutPosition,
FLinearColor& OutColor,
EHoudiniRampInterpolationType& OutInterpType) mutable
{
if (!MainColorRampParameter)
return;
float PrevPosition = 0.0f;
float NextPosition = 1.0f;
TArray<UHoudiniParameterRampColorPoint*> &CurrentPoints = MainColorRampParameter->Points;
TArray<UHoudiniParameterRampColorPoint*> &CachedPoints = MainColorRampParameter->CachedPoints;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
int32 NumPoints = 0;
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
NumPoints = CurrentPoints.Num();
else
NumPoints = CachedPoints.Num();
if (InsertAtIndex >= NumPoints)
{
// Insert at the end
if (NumPoints > 0)
{
UHoudiniParameterRampColorPoint* PrevPoint = nullptr;
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
PrevPoint = CurrentPoints.Last();
else
PrevPoint = CachedPoints.Last();
if (PrevPoint)
{
PrevPosition = PrevPoint->GetPosition();
OutInterpType = PrevPoint->GetInterpolation();
}
}
}
else if (InsertAtIndex <= 0)
{
// Insert at the beginning
if (NumPoints > 0)
{
UHoudiniParameterRampColorPoint* NextPoint = nullptr;
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
NextPoint = CurrentPoints[0];
else
NextPoint = CachedPoints[0];
if (NextPoint)
{
NextPosition = NextPoint->GetPosition();
OutInterpType = NextPoint->GetInterpolation();
}
}
}
else
{
// Insert in the middle
if (NumPoints > 1)
{
UHoudiniParameterRampColorPoint* PrevPoint = nullptr;
UHoudiniParameterRampColorPoint* NextPoint = nullptr;
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
{
PrevPoint = CurrentPoints[InsertAtIndex - 1];
NextPoint = CurrentPoints[InsertAtIndex];
}
else
{
PrevPoint = CachedPoints[InsertAtIndex - 1];
NextPoint = CachedPoints[InsertAtIndex];
}
if (PrevPoint)
{
PrevPosition = PrevPoint->GetPosition();
OutInterpType = PrevPoint->GetInterpolation();
}
if (NextPoint)
{
NextPosition = NextPoint->GetPosition();
}
if (PrevPoint && NextPoint)
{
OutColor = (PrevPoint->GetValue() + NextPoint->GetValue()) / 2.0;
}
}
}
OutPosition = (PrevPosition + NextPosition) / 2.0f;
};
int32 RowIndex = 0;
auto InsertRampPoint_Lambda = [GetInsertColorPointLambda, GetInsertFloatPointLambda, &CategoryBuilder, bCookingEnabled](
UHoudiniParameterRampFloat* MainRampFloat,
UHoudiniParameterRampColor* MainRampColor,
TArray<UHoudiniParameterRampFloat*> &RampFloatList,
TArray<UHoudiniParameterRampColor*> &RampColorList,
const int32& Index) mutable
{
if (MainRampFloat)
{
float InsertPosition = 0.0f;
float InsertValue = 1.0f;
EHoudiniRampInterpolationType InsertInterp = EHoudiniRampInterpolationType::LINEAR;
GetInsertFloatPointLambda(Index, InsertPosition, InsertValue, InsertInterp);
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(RampFloatList);
for (auto & NextFloatRamp : RampFloatList)
{
if (NextFloatRamp->IsAutoUpdate() && bCookingEnabled)
{
CreateFloatRampParameterInsertEvent(
NextFloatRamp, InsertPosition, InsertValue, InsertInterp);
NextFloatRamp->MarkChanged(true);
}
else
{
UHoudiniParameterRampFloatPoint* NewCachedPoint = NewObject<UHoudiniParameterRampFloatPoint>
(NextFloatRamp, UHoudiniParameterRampFloatPoint::StaticClass());
NewCachedPoint->Position = InsertPosition;
NewCachedPoint->Value = InsertValue;
NewCachedPoint->Interpolation = InsertInterp;
NextFloatRamp->CachedPoints.Add(NewCachedPoint);
NextFloatRamp->bCaching = true;
if (!bCookingEnabled)
{
// If cooking is not enabled, be sure to mark this parameter as changed
// so that it triggers an update once cooking is enabled again.
NextFloatRamp->MarkChanged(true);
}
}
}
if (!(MainRampFloat->IsAutoUpdate() && bCookingEnabled))
{
CategoryBuilder.GetParentLayout().ForceRefreshDetails();
}
}
else if (MainRampColor)
{
float InsertPosition = 0.0f;
FLinearColor InsertColor = FLinearColor::Black;
EHoudiniRampInterpolationType InsertInterp = EHoudiniRampInterpolationType::LINEAR;
GetInsertColorPointLambda(Index, InsertPosition, InsertColor, InsertInterp);
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(RampColorList);
for (auto& NextColorRamp : RampColorList)
{
if (NextColorRamp->IsAutoUpdate() && bCookingEnabled)
{
CreateColorRampParameterInsertEvent(
NextColorRamp, InsertPosition, InsertColor, InsertInterp);
NextColorRamp->MarkChanged(true);
}
else
{
UHoudiniParameterRampColorPoint* NewCachedPoint = NewObject<UHoudiniParameterRampColorPoint>
(NextColorRamp, UHoudiniParameterRampColorPoint::StaticClass());
NewCachedPoint->Position = InsertPosition;
NewCachedPoint->Value = InsertColor;
NewCachedPoint->Interpolation = InsertInterp;
NextColorRamp->CachedPoints.Add(NewCachedPoint);
NextColorRamp->bCaching = true;
if (!bCookingEnabled)
NextColorRamp->MarkChanged(true);
}
}
if (!(MainRampColor->IsAutoUpdate() && bCookingEnabled))
{
FHoudiniEngineUtils::UpdateEditorProperties(MainRampColor, true);
}
}
};
auto DeleteRampPoint_Lambda = [bCookingEnabled](
UHoudiniParameterRampFloat* MainRampFloat,
UHoudiniParameterRampColor* MainRampColor,
TArray<UHoudiniParameterRampFloat*> &FloatRampList,
TArray<UHoudiniParameterRampColor*> &ColorRampList,
const int32& Index) mutable
{
if (MainRampFloat)
{
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(FloatRampList);
for (auto& NextFloatRamp : FloatRampList)
{
if (NextFloatRamp->IsAutoUpdate() && bCookingEnabled)
{
if (NextFloatRamp->Points.Num() == 0)
return;
UHoudiniParameterRampFloatPoint* PointToDelete = nullptr;
if (Index == -1)
PointToDelete = NextFloatRamp->Points.Last();
else if (NextFloatRamp->Points.IsValidIndex(Index))
PointToDelete = NextFloatRamp->Points[Index];
if (!PointToDelete)
return;
const int32 & InstanceIndexToDelete = PointToDelete->InstanceIndex;
CreateFloatRampParameterDeleteEvent(NextFloatRamp, InstanceIndexToDelete);
NextFloatRamp->MarkChanged(true);
}
else
{
if (NextFloatRamp->CachedPoints.Num() == 0)
return;
if (Index == -1)
NextFloatRamp->CachedPoints.Pop();
else if (NextFloatRamp->CachedPoints.IsValidIndex(Index))
NextFloatRamp->CachedPoints.RemoveAt(Index);
else
return;
NextFloatRamp->bCaching = true;
if (!bCookingEnabled)
NextFloatRamp->MarkChanged(true);
}
}
if (!(MainRampFloat->IsAutoUpdate() && bCookingEnabled))
{
FHoudiniEngineUtils::UpdateEditorProperties(MainRampFloat, true);
}
}
else
{
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(ColorRampList);
for (auto& NextColorRamp : ColorRampList)
{
if (NextColorRamp->IsAutoUpdate() && bCookingEnabled)
{
if (NextColorRamp->Points.Num() == 0)
return;
UHoudiniParameterRampColorPoint* PointToRemove = nullptr;
if (Index == -1)
PointToRemove = NextColorRamp->Points.Last();
else if (NextColorRamp->Points.IsValidIndex(Index))
PointToRemove = NextColorRamp->Points[Index];
if (!PointToRemove)
return;
const int32 & InstanceIndexToDelete = PointToRemove->InstanceIndex;
CreateColorRampParameterDeleteEvent(NextColorRamp, InstanceIndexToDelete);
NextColorRamp->MarkChanged(true);
}
else
{
if (NextColorRamp->CachedPoints.Num() == 0)
return;
if (Index == -1)
NextColorRamp->CachedPoints.Pop();
else if (NextColorRamp->CachedPoints.IsValidIndex(Index))
NextColorRamp->CachedPoints.RemoveAt(Index);
else
return;
NextColorRamp->bCaching = true;
if (!bCookingEnabled)
NextColorRamp->MarkChanged(true);
}
}
if (!(MainRampColor->IsAutoUpdate() && bCookingEnabled))
{
FHoudiniEngineUtils::UpdateEditorProperties(MainRampColor, true);
}
}
};
TSharedRef<SVerticalBox> VerticalBox = StaticCastSharedRef<SVerticalBox>(Row->ValueWidget.Widget);
TSharedPtr<SUniformGridPanel> GridPanel;
VerticalBox->AddSlot()
.Padding(2, 2, 5, 2)
.AutoHeight()
[
SAssignNew(GridPanel, SUniformGridPanel)
];
//AllUniformGridPanels.Add(GridPanel.Get());
GridPanel->SetSlotPadding(FMargin(2.f, 2.f, 5.f, 3.f));
GridPanel->AddSlot(0, RowIndex)
[
SNew(STextBlock)
.Text(FText::FromString(TEXT("Position")))
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
];
FString ValueString = TEXT("Value");
if (!MainFloatRampParameter)
ValueString = TEXT("Color");
GridPanel->AddSlot(1, RowIndex)
[
SNew(STextBlock)
.Text(FText::FromString(ValueString))
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
];
GridPanel->AddSlot(2, RowIndex)
[
SNew(STextBlock)
.Text(FText::FromString(TEXT("Interp.")))
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
];
GridPanel->AddSlot(3, RowIndex)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(3.f, 0.f)
.MaxWidth(35.f)
.AutoWidth()
[
PropertyCustomizationHelpers::MakeAddButton(
FSimpleDelegate::CreateLambda([InsertRampPoint_Lambda, MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList, bCookingEnabled]() mutable
{
int32 InsertAtIndex = -1;
if (MainFloatRampParameter)
{
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
InsertAtIndex = MainFloatRampParameter->Points.Num();
else
InsertAtIndex = MainFloatRampParameter->CachedPoints.Num();
}
else if (MainColorRampParameter)
{
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
InsertAtIndex = MainColorRampParameter->Points.Num();
else
InsertAtIndex = MainColorRampParameter->CachedPoints.Num();
}
InsertRampPoint_Lambda(MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList, InsertAtIndex);
}),
LOCTEXT("AddRampPoint", "Add a ramp point to the end"), true)
]
+ SHorizontalBox::Slot()
.Padding(3.f, 0.f)
.MaxWidth(35.f)
.AutoWidth()
[
PropertyCustomizationHelpers::MakeRemoveButton(
FSimpleDelegate::CreateLambda([DeleteRampPoint_Lambda, MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList]() mutable
{
DeleteRampPoint_Lambda(
MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList, -1);
}),
LOCTEXT("DeleteRampPoint", "Delete the last ramp point"), true)
]
];
EUnit Unit = EUnit::Unspecified;
TSharedPtr<INumericTypeInterface<float>> paramTypeInterface;
paramTypeInterface = MakeShareable(new TNumericUnitTypeInterface<float>(Unit));
int32 PointCount = 0;
// Use Synced points on auto update mode
// Use Cached points on manual update mode
if (MainFloatRampParameter)
{
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
PointCount = MainFloatRampParameter->Points.Num();
else
PointCount = MainFloatRampParameter->CachedPoints.Num();
}
if (MainColorRampParameter)
{
if (MainColorRampParameter->IsAutoUpdate())
PointCount = MainColorRampParameter->Points.Num();
else
PointCount = MainColorRampParameter->CachedPoints.Num();
}
// Lambda function for changing a ramp point
auto OnPointChangeCommit = [bCookingEnabled](
UHoudiniParameterRampFloat* MainRampFloat, UHoudiniParameterRampColor* MainRampColor,
UHoudiniParameterRampFloatPoint* MainRampFloatPoint, UHoudiniParameterRampColorPoint* MainRampColorPoint,
TArray<UHoudiniParameterRampFloat*> &RampFloatList, TArray<UHoudiniParameterRampColor*> &RampColorList,
const int32& Index, const FString& ChangedDataName,
const float& NewPosition, const float& NewFloat,
const FLinearColor& NewColor,
const EHoudiniRampInterpolationType& NewInterpType) mutable
{
if (MainRampFloat && MainRampFloatPoint)
{
if (ChangedDataName == FString("position") && MainRampFloatPoint->GetPosition() == NewPosition)
return;
if (ChangedDataName == FString("value") && MainRampFloatPoint->GetValue() == NewFloat)
return;
if (ChangedDataName == FString("interp") && MainRampFloatPoint->GetInterpolation() == NewInterpType)
return;
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(RampFloatList);
for (auto NextFloatRamp : RampFloatList)
{
if (!NextFloatRamp)
continue;
if (NextFloatRamp->IsAutoUpdate() && bCookingEnabled)
{
if (NextFloatRamp->Points.IsValidIndex(Index))
{
UHoudiniParameterRampFloatPoint* CurrentFloatRampPoint = NextFloatRamp->Points[Index];
if (!CurrentFloatRampPoint)
continue;
if (ChangedDataName == FString("position"))
{
if (!CurrentFloatRampPoint->PositionParentParm)
continue;
CurrentFloatRampPoint->SetPosition(NewPosition);
CurrentFloatRampPoint->PositionParentParm->MarkChanged(true);
}
else if (ChangedDataName == FString("value"))
{
if (!CurrentFloatRampPoint->PositionParentParm)
continue;
CurrentFloatRampPoint->SetValue(NewFloat);
CurrentFloatRampPoint->ValueParentParm->MarkChanged(true);
}
else if (ChangedDataName == FString("interp"))
{
if (!CurrentFloatRampPoint->InterpolationParentParm)
continue;
CurrentFloatRampPoint->SetInterpolation(NewInterpType);
CurrentFloatRampPoint->InterpolationParentParm->MarkChanged(true);
}
}
else
{
int32 IdxInEventsArray = Index - NextFloatRamp->Points.Num();
if (NextFloatRamp->ModificationEvents.IsValidIndex(IdxInEventsArray))
{
UHoudiniParameterRampModificationEvent* Event = NextFloatRamp->ModificationEvents[IdxInEventsArray];
if (!Event)
continue;
if (ChangedDataName == FString("position"))
{
Event->InsertPosition = NewPosition;
}
else if (ChangedDataName == FString("value"))
{
Event->InsertFloat = NewFloat;
}
else if (ChangedDataName == FString("interp"))
{
Event->InsertInterpolation = NewInterpType;
}
}
}
}
else
{
if (NextFloatRamp->CachedPoints.IsValidIndex(Index))
{
UHoudiniParameterRampFloatPoint* CachedPoint = NextFloatRamp->CachedPoints[Index];
if (!CachedPoint)
continue;
if (ChangedDataName == FString("position"))
{
CachedPoint->Position = NewPosition;
}
else if (ChangedDataName == FString("value"))
{
CachedPoint->Value = NewFloat;
}
else if (ChangedDataName == FString("interp"))
{
CachedPoint->Interpolation = NewInterpType;
}
NextFloatRamp->bCaching = true;
}
}
if (!(MainRampFloat->IsAutoUpdate() && bCookingEnabled))
FHoudiniEngineUtils::UpdateEditorProperties(MainRampFloat, true);
}
}
else if (MainRampColor && MainRampColorPoint)
{
if (ChangedDataName == FString("position") && MainRampColorPoint->GetPosition() == NewPosition)
return;
if (ChangedDataName == FString("value") && MainRampColorPoint->GetValue() == NewColor)
return;
if (ChangedDataName == FString("interp") && MainRampColorPoint->GetInterpolation() == NewInterpType)
return;
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(RampColorList);
for (auto NextColorRamp : RampColorList)
{
if (!NextColorRamp)
continue;
if (NextColorRamp->IsAutoUpdate() && bCookingEnabled)
{
if (NextColorRamp->Points.IsValidIndex(Index))
{
UHoudiniParameterRampColorPoint* CurrentColorRampPoint = NextColorRamp->Points[Index];
if (!CurrentColorRampPoint)
continue;
if (ChangedDataName == FString("position"))
{
if (!CurrentColorRampPoint->PositionParentParm)
continue;
CurrentColorRampPoint->SetPosition(NewPosition);
CurrentColorRampPoint->PositionParentParm->MarkChanged(true);
}
else if (ChangedDataName == FString("value"))
{
if (!CurrentColorRampPoint->PositionParentParm)
continue;
CurrentColorRampPoint->SetValue(NewColor);
CurrentColorRampPoint->ValueParentParm->MarkChanged(true);
}
else if (ChangedDataName == FString("interp"))
{
if (!CurrentColorRampPoint->InterpolationParentParm)
continue;
CurrentColorRampPoint->SetInterpolation(NewInterpType);
CurrentColorRampPoint->InterpolationParentParm->MarkChanged(true);
}
}
else
{
int32 IdxInEventsArray = Index - NextColorRamp->Points.Num();
if (NextColorRamp->ModificationEvents.IsValidIndex(IdxInEventsArray))
{
UHoudiniParameterRampModificationEvent* Event = NextColorRamp->ModificationEvents[IdxInEventsArray];
if (!Event)
continue;
if (ChangedDataName == FString("position"))
{
Event->InsertPosition = NewPosition;
}
else if (ChangedDataName == FString("value"))
{
Event->InsertColor = NewColor;
}
else if (ChangedDataName == FString("interp"))
{
Event->InsertInterpolation = NewInterpType;
}
}
}
}
else
{
if (NextColorRamp->CachedPoints.IsValidIndex(Index))
{
UHoudiniParameterRampColorPoint* CachedPoint = NextColorRamp->CachedPoints[Index];
if (!CachedPoint)
continue;
if (ChangedDataName == FString("position"))
{
CachedPoint->Position = NewPosition;
}
else if (ChangedDataName == FString("value"))
{
CachedPoint->Value = NewColor;
}
else if (ChangedDataName == FString("interp"))
{
CachedPoint->Interpolation = NewInterpType;
}
NextColorRamp->bCaching = true;
}
}
if (!(MainRampColor->IsAutoUpdate() && bCookingEnabled))
FHoudiniEngineUtils::UpdateEditorProperties(MainRampColor, true);
}
}
};
for (int32 Index = 0; Index < PointCount; ++Index)
{
UHoudiniParameterRampFloatPoint* NextFloatRampPoint = nullptr;
UHoudiniParameterRampColorPoint* NextColorRampPoint = nullptr;
if (MainFloatRampParameter)
{
if (MainFloatRampParameter->IsAutoUpdate() && bCookingEnabled)
NextFloatRampPoint = MainFloatRampParameter->Points[Index];
else
NextFloatRampPoint = MainFloatRampParameter->CachedPoints[Index];
}
if (MainColorRampParameter)
{
if (MainColorRampParameter->IsAutoUpdate() && bCookingEnabled)
NextColorRampPoint = MainColorRampParameter->Points[Index];
else
NextColorRampPoint = MainColorRampParameter->CachedPoints[Index];
}
if (!NextFloatRampPoint && !NextColorRampPoint)
continue;
RowIndex += 1;
float CurPos = 0.f;
if (NextFloatRampPoint)
CurPos = NextFloatRampPoint->Position;
else
CurPos = NextColorRampPoint->Position;
GridPanel->AddSlot(0, RowIndex)
[
SNew(SNumericEntryBox<float>)
.AllowSpin(true)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.Value(CurPos)
.OnValueChanged_Lambda([](float Val) {})
.OnValueCommitted_Lambda([OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter, NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList, ColorRampParameterList, Index](float Val, ETextCommit::Type TextCommitType) mutable
{
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("position"),
Val, float(-1.0),
FLinearColor(),
EHoudiniRampInterpolationType::LINEAR);
})
.OnBeginSliderMovement_Lambda([]() {})
.OnEndSliderMovement_Lambda([OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter, NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList, ColorRampParameterList, Index](const float Val) mutable
{
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("position"),
Val, float(-1.0),
FLinearColor(),
EHoudiniRampInterpolationType::LINEAR);
})
.SliderExponent(1.0f)
.TypeInterface(paramTypeInterface)
];
if (NextFloatRampPoint)
{
GridPanel->AddSlot(1, RowIndex)
[
SNew(SNumericEntryBox< float >)
.AllowSpin(true)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.Value(NextFloatRampPoint->Value)
.OnValueChanged_Lambda([](float Val){})
.OnValueCommitted_Lambda([OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList, ColorRampParameterList, Index](float Val, ETextCommit::Type TextCommitType) mutable
{
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("value"),
float(-1.0), Val,
FLinearColor(),
EHoudiniRampInterpolationType::LINEAR);
})
.OnBeginSliderMovement_Lambda([]() {})
.OnEndSliderMovement_Lambda([OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList, ColorRampParameterList, Index](const float Val) mutable
{
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("value"),
float(-1.0), Val,
FLinearColor(),
EHoudiniRampInterpolationType::LINEAR);
})
.SliderExponent(1.0f)
.TypeInterface(paramTypeInterface)
];
}
else if (NextColorRampPoint)
{
auto OnColorChangeLambda = [OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList, ColorRampParameterList, Index](FLinearColor InColor) mutable
{
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("value"),
float(-1.0), float(-1.0),
InColor,
EHoudiniRampInterpolationType::LINEAR);
};
// Add color picker UI.
//TSharedPtr<SColorBlock> ColorBlock;
GridPanel->AddSlot(1, RowIndex)
[
SNew(SColorBlock)
.Color(NextColorRampPoint->Value)
.OnMouseButtonDown( FPointerEventHandler::CreateLambda(
[NextColorRampPoint, OnColorChangeLambda](const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
if (MouseEvent.GetEffectingButton() != EKeys::LeftMouseButton)
return FReply::Unhandled();
FColorPickerArgs PickerArgs;
PickerArgs.bUseAlpha = true;
PickerArgs.DisplayGamma = TAttribute< float >::Create(
TAttribute< float >::FGetter::CreateUObject(GEngine, &UEngine::GetDisplayGamma));
PickerArgs.OnColorCommitted = FOnLinearColorValueChanged::CreateLambda(OnColorChangeLambda);
FLinearColor InitColor = NextColorRampPoint->Value;
PickerArgs.InitialColorOverride = InitColor;
PickerArgs.bOnlyRefreshOnOk = true;
OpenColorPicker(PickerArgs);
return FReply::Handled();
}))
];
}
int32 CurChoice = 0;
if (NextFloatRampPoint)
CurChoice = (int)NextFloatRampPoint->Interpolation;
else
CurChoice = (int)NextColorRampPoint->Interpolation;
TSharedPtr <SComboBox<TSharedPtr< FString >>> ComboBoxCurveMethod;
GridPanel->AddSlot(2, RowIndex)
[
SAssignNew(ComboBoxCurveMethod, SComboBox<TSharedPtr<FString>>)
.OptionsSource(FHoudiniEngineEditor::Get().GetHoudiniParameterRampInterpolationMethodLabels())
.InitiallySelectedItem((*FHoudiniEngineEditor::Get().GetHoudiniParameterRampInterpolationMethodLabels())[CurChoice])
.OnGenerateWidget_Lambda([](TSharedPtr<FString> ChoiceEntry)
{
FText ChoiceEntryText = FText::FromString(*ChoiceEntry);
return SNew(STextBlock)
.Text(ChoiceEntryText)
.ToolTipText(ChoiceEntryText)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")));
})
.OnSelectionChanged_Lambda(
[OnPointChangeCommit, MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint, FloatRampParameterList,
ColorRampParameterList, Index](TSharedPtr<FString> NewChoice, ESelectInfo::Type SelectType) mutable
{
EHoudiniRampInterpolationType NewInterpType = UHoudiniParameter::GetHoudiniInterpMethodFromString(*NewChoice.Get());
OnPointChangeCommit(MainFloatRampParameter, MainColorRampParameter,
NextFloatRampPoint, NextColorRampPoint,
FloatRampParameterList, ColorRampParameterList,
Index, FString("interp"),
float(-1.0), float(-1.0),
FLinearColor(),
NewInterpType);
})
[
SNew(STextBlock)
.Text_Lambda([NextFloatRampPoint, NextColorRampPoint]()
{
EHoudiniRampInterpolationType CurInterpType = EHoudiniRampInterpolationType::InValid;
if (NextFloatRampPoint)
CurInterpType = NextFloatRampPoint->GetInterpolation();
else
CurInterpType = NextColorRampPoint->GetInterpolation();
return FText::FromString(UHoudiniParameter::GetStringFromHoudiniInterpMethod(CurInterpType));
})
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
]
];
GridPanel->AddSlot(3, RowIndex)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(3.f, 0.f)
.MaxWidth(35.f)
.AutoWidth()
[
PropertyCustomizationHelpers::MakeAddButton( FSimpleDelegate::CreateLambda(
[InsertRampPoint_Lambda, MainFloatRampParameter,
MainColorRampParameter, FloatRampParameterList,
ColorRampParameterList, Index]() mutable
{
InsertRampPoint_Lambda(MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList, Index);
}),
LOCTEXT("AddRampPoint", "Add a ramp point before this point"), true)
]
+ SHorizontalBox::Slot()
.Padding(3.f, 0.f)
.MaxWidth(35.f)
.AutoWidth()
[
PropertyCustomizationHelpers::MakeDeleteButton(FSimpleDelegate::CreateLambda(
[DeleteRampPoint_Lambda, MainFloatRampParameter,
MainColorRampParameter, FloatRampParameterList,
ColorRampParameterList, Index]() mutable
{
DeleteRampPoint_Lambda(MainFloatRampParameter, MainColorRampParameter, FloatRampParameterList, ColorRampParameterList, Index);
}),
LOCTEXT("DeleteFloatRampPoint", "Delete this ramp point"), true)
]
];
if (MainFloatRampParameter && CurrentRampParameterFloatCurve)
{
ERichCurveInterpMode RichCurveInterpMode = UHoudiniParameter::EHoudiniRampInterpolationTypeToERichCurveInterpMode(NextFloatRampPoint->GetInterpolation());
FRichCurve & RichCurve = CurrentRampParameterFloatCurve->FloatCurve;
FKeyHandle const KeyHandle = RichCurve.AddKey(NextFloatRampPoint->GetPosition(), NextFloatRampPoint->GetValue());
RichCurve.SetKeyInterpMode(KeyHandle, RichCurveInterpMode);
}
if (MainColorRampParameter && CurrentRampParameterColorCurve)
{
ERichCurveInterpMode RichCurveInterpMode = UHoudiniParameter::EHoudiniRampInterpolationTypeToERichCurveInterpMode(NextColorRampPoint->GetInterpolation());
for (int32 CurveIdx = 0; CurveIdx < 4; ++CurveIdx)
{
FRichCurve & RichCurve = CurrentRampParameterColorCurve->FloatCurves[CurveIdx];
FKeyHandle const KeyHandle = RichCurve.AddKey(NextColorRampPoint->GetPosition(), NextColorRampPoint->GetValue().Component(CurveIdx));
RichCurve.SetKeyInterpMode(KeyHandle, RichCurveInterpMode);
}
}
}
if (MainFloatRampParameter)
GridPanel->SetEnabled(!MainFloatRampParameter->IsDisabled());
if (MainColorRampParameter)
GridPanel->SetEnabled(!MainColorRampParameter->IsDisabled());
}
void
FHoudiniParameterDetails::CreateWidgetFolderList(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterFolderList*> FolderListParams;
if (!CastParameters<UHoudiniParameterFolderList>(InParams, FolderListParams))
return;
if (FolderListParams.Num() <= 0)
return;
UHoudiniParameterFolderList* MainParam = FolderListParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Add this folder list to the folder map
AllFoldersAndFolderLists.Add(MainParam->GetParmId(), MainParam);
MainParam->GetTabs().Empty();
// A folder list will be followed by all its child folders,
// so set the CurrentFolderListSize to the tuple size, we'll process such many folder parameters right after
CurrentFolderListSize = MainParam->GetTupleSize();
if (MainParam->IsDirectChildOfMultiParm())
MultiParmInstanceIndices.Add(MainParam->GetParmId(), -1);
if (CurrentFolderListSize <= 0) // There should not be empty folder list, this will not happen normally
return;
// The following folders belong to current folder list
CurrentFolderList = MainParam;
// If the tab is either a tabs or radio button and the parameter is visible
if (MainParam->IsTabMenu() && MainParam->ShouldDisplay())
{
// Set the current tabs to be not shown by default now. CreateWidgetTab will decide if the tabs is shown.
CurrentFolderList->SetTabsShown(false);
// Create a row to hold tab buttons if the folder list is a tabs or radio button
// CreateNestedRow does not actually create a row for tabs, it is responsible to prune the folder stack.
// ( CreateWidgetTab will be responsible to create a row according to the visibility of its outer level folders )
FDetailWidgetRow* TabRow = CreateNestedRow(HouParameterCategory, InParams, false);
}
// When see a folder list, go depth first search at this step.
// Push an empty queue to the stack.
FolderStack.Add(TArray<UHoudiniParameterFolder*>());
}
void
FHoudiniParameterDetails::CreateWidgetFolder(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterFolder*> FolderParams;
if (!CastParameters<UHoudiniParameterFolder>(InParams, FolderParams))
return;
if (FolderParams.Num() <= 0)
return;
UHoudiniParameterFolder* MainParam = FolderParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
if (!CurrentFolderList || CurrentFolderList->IsPendingKill()) // This should not happen
return;
// If a folder is invisible, its children won't be listed by HAPI.
// So just reduce FolderListSize by 1, reduce the child counter of its parent folder by 1 if necessary,
// and prune the stack in such case.
if (!MainParam->IsVisible())
{
CurrentFolderListSize -= 1;
if (CurrentFolderListSize == 0)
{
if (FolderStack.Num() > 1)
{
TArray<UHoudiniParameterFolder*> &ParentFolderQueue = FolderStack[FolderStack.Num() - 2];
if (ParentFolderQueue.Num() > 0 && ParentFolderQueue[0] && !ParentFolderQueue[0]->IsPendingKill())
ParentFolderQueue[0]->GetChildCounter() -= 1;
}
PruneStack();
}
return;
}
// We expect 'TupleSize' children param of this folder after finish processing all the child folders of cur folderlist
MainParam->ResetChildCounter();
// Add this folder to the folder map
AllFoldersAndFolderLists.Add(MainParam->GetParmId(), MainParam);
// Set the parent param to current folderList.
// it was parent multiparm's id if this folder is a child of a multiparms.
// This will cause problem if the folder is inside of a multiparm
MainParam->SetParentParmId(CurrentFolderList->GetParmId());
// Case 1: The folder is a direct child of a multiparm.
if (MainParam->IsDirectChildOfMultiParm())
{
if (FolderStack.Num() <= 0) // This should not happen
return;
// Get its parent multiparm first
UHoudiniParameterMultiParm* ParentMultiParm = nullptr;
{
UHoudiniParameterFolderList * ParentFolderList = nullptr;
if (!AllFoldersAndFolderLists.Contains(MainParam->GetParentParmId()))
return;
ParentFolderList = Cast<UHoudiniParameterFolderList>(AllFoldersAndFolderLists[MainParam->GetParentParmId()]);
if (!ParentFolderList)
return;
if (AllMultiParms.Contains(ParentFolderList->GetParentParmId()))
ParentMultiParm = AllMultiParms[ParentFolderList->GetParentParmId()];
if (!ParentMultiParm) // This should not happen
return;
}
bool bShown = ParentMultiParm->IsShown();
// Case 1-1: The folder is NOT tabs
if (!MainParam->IsTab())
{
bShown = MainParam->IsExpanded() && bShown;
// If the parent multiparm is shown.
if (ParentMultiParm->IsShown())
{
FDetailWidgetRow* FolderHeaderRow = CreateNestedRow(HouParameterCategory, InParams, false);
CreateFolderHeaderUI(FolderHeaderRow, InParams);
}
}
// Case 1-2: The folder IS tabs.
else
{
CreateWidgetTab(HouParameterCategory, MainParam, ParentMultiParm->IsShown());
}
// Push the folder to the queue if it is not a tab folder
// This step is handled by CreateWidgetTab() if it is tabs
if ((!MainParam->IsTab() || !ParentMultiParm->IsShown()) && MainParam->GetTupleSize() > 0)
{
TArray<UHoudiniParameterFolder*> & MyQueue = FolderStack.Last();
MainParam->SetIsContentShown(bShown);
MyQueue.Add(MainParam);
}
}
// Case 2: The folder is NOT a direct child of a multiparm.
else
{
// Case 2-1: The folder is in another folder.
if (FolderStack.Num() > 1 && CurrentFolderListSize > 0)
{
TArray <UHoudiniParameterFolder*> & MyFolderQueue = FolderStack.Last();
TArray<UHoudiniParameterFolder*> & ParentFolderQueue = FolderStack[FolderStack.Num() - 2];
if (ParentFolderQueue.Num() <= 0) //This should happen
return;
// Peek the folder queue of the last layer to get its parent folder parm.
bool ParentFolderVisible = ParentFolderQueue[0]->IsContentShown();
// If this folder is expanded (selected if is tabs)
bool bExpanded = ParentFolderVisible;
// Case 2-1-1: The folder is NOT in a tab menu.
if (!MainParam->IsTab())
{
bExpanded &= MainParam->IsExpanded();
// The parent folder is visible.
if (ParentFolderVisible)
{
// Add the folder header UI.
FDetailWidgetRow* FolderHeaderRow = CreateNestedRow(HouParameterCategory, InParams, false);
CreateFolderHeaderUI(FolderHeaderRow, InParams);
}
MainParam->SetIsContentShown(bExpanded);
MyFolderQueue.Add(MainParam);
}
// Case 2-1-2: The folder IS in a tab menu.
else
{
bExpanded &= MainParam->IsChosen();
CreateWidgetTab(HouParameterCategory, MainParam, ParentFolderVisible);
}
}
// Case 2-2: The folder is in the root.
else
{
bool bExpanded = true;
// Case 2-2-1: The folder is NOT under a tab menu.
if (!MainParam->IsTab())
{
if (FolderStack.Num() <= 0) // This will not happen
return;
// Create Folder header under root.
FDetailWidgetRow* FolderRow = CreateNestedRow(HouParameterCategory, InParams, false);
CreateFolderHeaderUI(FolderRow, InParams);
if (FolderStack.Num() == 0) // This should not happen
return;
TArray<UHoudiniParameterFolder*>& MyFolderQueue = FolderStack[0];
bExpanded &= MainParam->IsExpanded();
MainParam->SetIsContentShown(bExpanded);
MyFolderQueue.Add(MainParam);
}
// Case 2-2-2: The folder IS under a tab menu.
else
{
// Tabs in root is always visible
CreateWidgetTab(HouParameterCategory, MainParam, true);
}
}
}
CurrentFolderListSize -= 1;
// Prune the stack if finished parsing current folderlist
if (CurrentFolderListSize == 0)
{
if (FolderStack.Num() > 1 && !MainParam->IsDirectChildOfMultiParm())
{
TArray<UHoudiniParameterFolder*> & ParentFolderQueue = FolderStack[FolderStack.Num() - 2];
if (ParentFolderQueue.Num() > 0 && ParentFolderQueue[0] && !ParentFolderQueue[0]->IsPendingKill())
ParentFolderQueue[0]->GetChildCounter() -= 1;
}
PruneStack();
CurrentFolderList = nullptr;
}
}
void
FHoudiniParameterDetails::CreateFolderHeaderUI(FDetailWidgetRow* HeaderRow, TArray<UHoudiniParameter*> &InParams)
{
if (!HeaderRow) // The folder is invisible.
return;
TArray<UHoudiniParameterFolder*> FolderParams;
if (!CastParameters<UHoudiniParameterFolder>(InParams, FolderParams))
return;
if (FolderParams.Num() <= 0)
return;
UHoudiniParameterFolder* MainParam = FolderParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
TSharedPtr<SVerticalBox> VerticalBox;
FString LabelStr = MainParam->GetParameterLabel();
TSharedPtr<SCustomizedBox> HorizontalBox;
TSharedPtr<SButton> ExpanderArrow;
TSharedPtr<SImage> ExpanderImage;
HeaderRow->NameWidget.Widget = SAssignNew(HorizontalBox, SCustomizedBox);
HorizontalBox->AddIndentation(MainParam, AllMultiParms, AllFoldersAndFolderLists);
HorizontalBox->DividerLinePositions = DividerLinePositions;
HorizontalBox->SetHoudiniParameter(InParams);
if (MainParam->IsDirectChildOfMultiParm() && MainParam->GetChildIndex() == 1)
{
int32 CurrentMultiParmInstanceIndex = 0;
if (MultiParmInstanceIndices.Contains(MainParam->GetParentParmId()))
{
MultiParmInstanceIndices[MainParam->GetParentParmId()] += 1;
CurrentMultiParmInstanceIndex = MultiParmInstanceIndices[MainParam->GetParentParmId()];
LabelStr = LabelStr + TEXT(" (") + FString::FromInt(CurrentMultiParmInstanceIndex) + TEXT(")");
}
CreateWidgetMultiParmObjectButtons(HorizontalBox, InParams);
}
HorizontalBox->AddSlot().Padding(1.0f).VAlign(VAlign_Center).AutoWidth()
[
SAssignNew(ExpanderArrow, SButton)
.ButtonStyle(FEditorStyle::Get(), "NoBorder")
.ClickMethod(EButtonClickMethod::MouseDown)
.Visibility(EVisibility::Visible)
.OnClicked_Lambda([=]()
{
MainParam->ExpandButtonClicked();
FHoudiniEngineUtils::UpdateEditorProperties(MainParam, true);
return FReply::Handled();
})
[
SAssignNew(ExpanderImage, SImage)
.ColorAndOpacity(FSlateColor::UseForeground())
]
];
FText LabelText = FText::FromString(LabelStr);
HorizontalBox->AddSlot().Padding(1.0f).VAlign(VAlign_Center).AutoWidth()
[
SNew(STextBlock)
.Text(LabelText)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
];
TWeakPtr<SButton> WeakExpanderArrow(ExpanderArrow);
ExpanderImage->SetImage(
TAttribute<const FSlateBrush*>::Create(
TAttribute<const FSlateBrush*>::FGetter::CreateLambda([MainParam, WeakExpanderArrow]()
{
FName ResourceName;
TSharedPtr<SButton> ExpanderArrowPtr = WeakExpanderArrow.Pin();
if (MainParam->IsExpanded())
{
ResourceName = ExpanderArrowPtr.IsValid() && ExpanderArrowPtr->IsHovered() ? "TreeArrow_Expanded_Hovered" : "TreeArrow_Expanded";
}
else
{
ResourceName = ExpanderArrowPtr.IsValid() && ExpanderArrowPtr->IsHovered() ? "TreeArrow_Collapsed_Hovered" : "TreeArrow_Collapsed";
}
return FEditorStyle::GetBrush(ResourceName);
}
)
));
if(MainParam->GetFolderType() == EHoudiniFolderParameterType::Simple)
ExpanderArrow->SetEnabled(false);
}
void FHoudiniParameterDetails::CreateWidgetTab(IDetailCategoryBuilder & HouParameterCategory, UHoudiniParameterFolder* InFolder, const bool& bIsShown)
{
if (!InFolder || InFolder->IsPendingKill() || !CurrentFolderList)
return;
if (FolderStack.Num() <= 0) // error state
return;
TArray<UHoudiniParameterFolder*> & FolderQueue = FolderStack.Last();
// Cache all tabs of current tab folder list.
CurrentFolderList->AddTabFolder(InFolder);
// If the tabs is not shown, just push the folder param into the queue.
if (!bIsShown)
{
InFolder->SetIsContentShown(bIsShown);
FolderQueue.Add(InFolder);
return;
}
// tabs currently being processed
CurrentTabs.Add(InFolder);
if (CurrentFolderListSize > 1)
return;
// The tabs belong to current folder list
UHoudiniParameterFolderList* CurrentTabMenuFolderList = CurrentFolderList;
// Create a row (UI) for current tabs
TSharedPtr<SCustomizedBox> HorizontalBox;
FDetailWidgetRow &Row = HouParameterCategory.AddCustomRow(FText::GetEmpty())
[
SAssignNew(HorizontalBox, SCustomizedBox)
];
// Put current tab folder list param into an array
TArray<UHoudiniParameter*> CurrentTabMenuFolderListArr;
CurrentTabMenuFolderListArr.Add(CurrentTabMenuFolderList);
HorizontalBox->SetHoudiniParameter(CurrentTabMenuFolderListArr);
DividerLinePositions.Add(HorizontalBox->AddIndentation(InFolder, AllMultiParms, AllFoldersAndFolderLists));
HorizontalBox->DividerLinePositions = DividerLinePositions;
float DesiredHeight = 0.0f;
float DesiredWidth = 0.0f;
// Process all tabs of current folder list at once when done.
for (auto & CurTab : CurrentTabs)
{
if (!CurTab || CurTab->IsPendingKill())
continue;
CurTab->SetIsContentShown(CurTab->IsChosen());
FolderQueue.Add(CurTab);
auto OnTabClickedLambda = [CurrentTabMenuFolderList, CurTab, &HouParameterCategory]()
{
if (CurrentTabMenuFolderList)
{
if (!CurrentTabMenuFolderList->bIsTabMenu || CurrentTabMenuFolderList->TabFolders.Num() <= 0)
return FReply::Handled();
if (CurTab->IsChosen())
return FReply::Handled();
CurTab->SetChosen(true);
for (UHoudiniParameterFolder* NextFolder : CurrentTabMenuFolderList->TabFolders)
{
if (CurTab->GetParmId() != NextFolder->GetParmId() && NextFolder->IsChosen())
NextFolder->SetChosen(false);
}
HouParameterCategory.GetParentLayout().ForceRefreshDetails();
}
return FReply::Handled();
};
FString FolderLabelString = TEXT(" ") + CurTab->GetParameterLabel();
if (CurTab->GetFolderType() == EHoudiniFolderParameterType::Radio)
FolderLabelString = TEXT(" ") + FolderLabelString;
bool bChosen = CurTab->IsTab() && CurTab->IsChosen();
TSharedPtr<SCustomizedButton> CurCustomizedButton;
HorizontalBox->AddSlot().VAlign(VAlign_Bottom)
.AutoWidth()
.Padding(0.f)
.HAlign(HAlign_Left)
[
SAssignNew(CurCustomizedButton, SCustomizedButton)
.OnClicked_Lambda(OnTabClickedLambda)
.Content()
[
SNew(STextBlock)
.Text(FText::FromString(FolderLabelString))
]
];
CurCustomizedButton->bChosen = bChosen;
CurCustomizedButton->bIsRadioButton = CurTab->GetFolderType() == EHoudiniFolderParameterType::Radio;
DesiredHeight = CurCustomizedButton->GetDesiredSize().Y;
DesiredWidth += CurCustomizedButton->GetDesiredSize().X;
}
HorizontalBox->bIsTabFolderListRow = true;
Row.WholeRowWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
// Set the current tabs to be shown, since slate widgets have been created
CurrentTabMenuFolderList->SetTabsShown(true);
// Clear the temporary tabs
CurrentTabs.Empty();
}
void
FHoudiniParameterDetails::CreateWidgetMultiParm(IDetailCategoryBuilder & HouParameterCategory, TArray<UHoudiniParameter*> &InParams)
{
TArray<UHoudiniParameterMultiParm*> MultiParmParams;
if (!CastParameters<UHoudiniParameterMultiParm>(InParams, MultiParmParams))
return;
if (MultiParmParams.Num() <= 0)
return;
UHoudiniParameterMultiParm* MainParam = MultiParmParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
// Add current multiparm parameter to AllmultiParms map
AllMultiParms.Add(MainParam->GetParmId(), MainParam);
// Create a new detail row
FDetailWidgetRow * Row = CreateNestedRow(HouParameterCategory, InParams);
if (!Row)
{
MainParam->SetIsShown(false);
return;
}
MainParam->SetIsShown(true);
MultiParmInstanceIndices.Add(MainParam->GetParmId(), -1);
CreateNameWidget(Row, InParams, true);
auto OnInstanceValueChangedLambda = [MainParam](int32 InValue)
{
if (InValue < 0)
return;
int32 ChangesCount = FMath::Abs(MainParam->MultiParmInstanceLastModifyArray.Num() - InValue);
if (MainParam->MultiParmInstanceLastModifyArray.Num() > InValue)
{
for (int32 Idx = 0; Idx < ChangesCount; ++Idx)
MainParam->RemoveElement(-1);
MainParam->MarkChanged(true);
}
else if (MainParam->MultiParmInstanceLastModifyArray.Num() < InValue)
{
for (int32 Idx = 0; Idx < ChangesCount; ++Idx)
MainParam->InsertElement();
MainParam->MarkChanged(true);
}
};
// Add multiparm UI.
TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox);
TSharedPtr< SNumericEntryBox< int32 > > NumericEntryBox;
int32 NumericalCount = MainParam->MultiParmInstanceCount;
HorizontalBox->AddSlot().Padding(2, 2, 5, 2)
[
SAssignNew(NumericEntryBox, SNumericEntryBox< int32 >)
.AllowSpin(true)
.Font(FEditorStyle::GetFontStyle(TEXT("PropertyWindow.NormalFont")))
.OnValueChanged(SNumericEntryBox<int32>::FOnValueChanged::CreateLambda([OnInstanceValueChangedLambda](int32 InValue) {
OnInstanceValueChangedLambda(InValue);
}))
.Value(NumericalCount)
];
HorizontalBox->AddSlot().AutoWidth().Padding(2.0f, 0.0f)
[
PropertyCustomizationHelpers::MakeAddButton(FSimpleDelegate::CreateLambda([MainParam, MultiParmParams]()
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterMultiParamAddInstance", "Houdini Parameter Multi Parameter: Adding an instance"),
MainParam->GetOuter(), true);
for (auto& Param : MultiParmParams)
{
if (!Param)
continue;
// Add a reverse step for redo/undo
Param->MultiParmInstanceLastModifyArray.Add(EHoudiniMultiParmModificationType::Removed);
Param->MarkChanged(true);
Param->Modify();
if (Param->MultiParmInstanceLastModifyArray.Num() > 0)
Param->MultiParmInstanceLastModifyArray.RemoveAt(Param->MultiParmInstanceLastModifyArray.Num() - 1);
Param->InsertElement();
}
}),
LOCTEXT("AddMultiparmInstanceToolTipAddLastInstance", "Add an Instance"), true)
];
HorizontalBox->AddSlot().AutoWidth().Padding(2.0f, 0.0f)
[
// Remove the last multiparm instance
PropertyCustomizationHelpers::MakeRemoveButton(FSimpleDelegate::CreateLambda([MainParam, MultiParmParams]()
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterMultiParamDeleteInstance", "Houdini Parameter Multi Parameter: Deleting an instance"),
MainParam->GetOuter(), true);
for (auto & Param : MultiParmParams)
{
TArray<EHoudiniMultiParmModificationType>& LastModifiedArray = Param->MultiParmInstanceLastModifyArray;
int32 RemovedIndex = LastModifiedArray.Num() - 1;
while (LastModifiedArray.IsValidIndex(RemovedIndex) && LastModifiedArray[RemovedIndex] == EHoudiniMultiParmModificationType::Removed)
RemovedIndex -= 1;
// Add a reverse step for redo/undo
EHoudiniMultiParmModificationType PreviousModType = EHoudiniMultiParmModificationType::None;
if (LastModifiedArray.IsValidIndex(RemovedIndex))
{
PreviousModType = LastModifiedArray[RemovedIndex];
LastModifiedArray[RemovedIndex] = EHoudiniMultiParmModificationType::Inserted;
}
Param->MarkChanged(true);
Param->Modify();
if (LastModifiedArray.IsValidIndex(RemovedIndex))
{
LastModifiedArray[RemovedIndex] = PreviousModType;
}
Param->RemoveElement(RemovedIndex);
}
}),
LOCTEXT("RemoveLastMultiParamLastToolTipRemoveLastInstance", "Remove the last instance"), true)
];
HorizontalBox->AddSlot().AutoWidth().Padding(2.0f, 0.0f)
[
PropertyCustomizationHelpers::MakeEmptyButton(FSimpleDelegate::CreateLambda([MainParam, MultiParmParams]()
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterMultiParamDeleteAllInstances", "Houdini Parameter Multi Parameter: Deleting all instances"),
MainParam->GetOuter(), true);
for (auto & Param : MultiParmParams)
{
TArray<EHoudiniMultiParmModificationType>& LastModifiedArray = Param->MultiParmInstanceLastModifyArray;
TArray<int32> IndicesToReverse;
for (int32 Index = 0; Index < LastModifiedArray.Num(); ++Index)
{
if (LastModifiedArray[Index] == EHoudiniMultiParmModificationType::None)
{
LastModifiedArray[Index] = EHoudiniMultiParmModificationType::Inserted;
IndicesToReverse.Add(Index);
}
}
Param->MarkChanged(true);
Param->Modify();
for (int32 & Index : IndicesToReverse)
{
if (LastModifiedArray.IsValidIndex(Index))
LastModifiedArray[Index] = EHoudiniMultiParmModificationType::None;
}
Param->EmptyElements();
}
}),
LOCTEXT("HoudiniParameterRemoveAllMultiparmInstancesToolTip", "Remove all instances"), true)
];
Row->ValueWidget.Widget = HorizontalBox;
Row->ValueWidget.MinDesiredWidth(HAPI_UNREAL_DESIRED_ROW_VALUE_WIDGET_WIDTH);
}
void
FHoudiniParameterDetails::CreateWidgetMultiParmObjectButtons(TSharedPtr<SHorizontalBox> HorizontalBox, TArray<UHoudiniParameter*> InParams)
{
if (InParams.Num() <= 0)
return;
UHoudiniParameter* MainParam = InParams[0];
if (!MainParam || MainParam->IsPendingKill())
return;
if (!HorizontalBox || !AllMultiParms.Contains(MainParam->GetParentParmId()) || !MultiParmInstanceIndices.Contains(MainParam->GetParentParmId()))
return;
UHoudiniParameterMultiParm* MainParentMultiParm = AllMultiParms[MainParam->GetParentParmId()];
if (!MainParentMultiParm)
return;
if (!MainParentMultiParm->IsShown())
return;
// push all parent multiparm of the InParams to the array
TArray<UHoudiniParameterMultiParm*> ParentMultiParams;
for (auto & InParam : InParams)
{
if (!InParam)
continue;
if (!MultiParmInstanceIndices.Contains(InParam->GetParentParmId()))
continue;
if (InParam->GetChildIndex() == 0)
{
UHoudiniParameterMultiParm* ParentMultiParm = AllMultiParms[InParam->GetParentParmId()];
if (ParentMultiParm)
ParentMultiParams.Add(ParentMultiParm);
}
}
int32 InstanceIndex = MultiParmInstanceIndices[MainParam->GetParentParmId()];
TSharedRef<SWidget> AddButton = PropertyCustomizationHelpers::MakeAddButton(FSimpleDelegate::CreateLambda([ParentMultiParams, InstanceIndex]()
{
for (auto & ParentParam : ParentMultiParams)
{
// Add button call back
if (!ParentParam)
continue;
TArray<EHoudiniMultiParmModificationType>& LastModifiedArray = ParentParam->MultiParmInstanceLastModifyArray;
if (!LastModifiedArray.IsValidIndex(InstanceIndex))
continue;
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterMultiParmAddBeforeCurInstance", "Houdini Parameter Multi Parm: Adding an instance"),
ParentParam->GetOuter(), true);
int32 Index = InstanceIndex;
// Add a reverse step for undo/redo
if (Index >= LastModifiedArray.Num())
LastModifiedArray.Add(EHoudiniMultiParmModificationType::Removed);
else
LastModifiedArray.Insert(EHoudiniMultiParmModificationType::Removed, Index);
ParentParam->MarkChanged(true);
ParentParam->Modify();
if (Index >= LastModifiedArray.Num() - 1 && LastModifiedArray.Num())
LastModifiedArray.RemoveAt(LastModifiedArray.Num() - 1);
else
LastModifiedArray.RemoveAt(Index);
ParentParam->InsertElementAt(InstanceIndex);
}
}),
LOCTEXT("HoudiniParameterMultiParamAddBeforeCurrentInstanceToolTip", "Insert an instance before this instance"));
TSharedRef<SWidget> RemoveButton = PropertyCustomizationHelpers::MakeRemoveButton(FSimpleDelegate::CreateLambda([ParentMultiParams, InstanceIndex]()
{
for (auto & ParentParam : ParentMultiParams)
{
FScopedTransaction Transaction(
TEXT(HOUDINI_MODULE_RUNTIME),
LOCTEXT("HoudiniParameterMultiParmDeleteCurInstance", "Houdini Parameter Multi Parm: Deleting an instance"),
ParentParam->GetOuter(), true);
TArray<EHoudiniMultiParmModificationType>& LastModifiedArray = ParentParam->MultiParmInstanceLastModifyArray;
int32 Index = InstanceIndex;
EHoudiniMultiParmModificationType PreviousModType = EHoudiniMultiParmModificationType::None;
while (LastModifiedArray.IsValidIndex(Index) && LastModifiedArray[Index] == EHoudiniMultiParmModificationType::Removed)
{
Index -= 1;
}
if (LastModifiedArray.IsValidIndex(Index))
{
PreviousModType = LastModifiedArray[Index];
LastModifiedArray[Index] = EHoudiniMultiParmModificationType::Inserted;
}
ParentParam->MarkChanged(true);
ParentParam->Modify();
if (LastModifiedArray.IsValidIndex(Index))
{
LastModifiedArray[Index] = PreviousModType;
}
ParentParam->RemoveElement(InstanceIndex);
}
}),
LOCTEXT("HoudiniParameterMultiParamDeleteCurrentInstanceToolTip", "Remove an instance"), true);
HorizontalBox->AddSlot().AutoWidth().Padding(0.0f, 0.0f)[AddButton];
HorizontalBox->AddSlot().AutoWidth().Padding(0.0f, 0.0f)[RemoveButton];
int32 StartIdx = MainParam->GetParameterType() == EHoudiniParameterType::Folder ? 1 : 0;
if (MainParam->GetChildIndex() != StartIdx)
{
AddButton.Get().SetVisibility(EVisibility::Hidden);
RemoveButton.Get().SetVisibility(EVisibility::Hidden);
}
}
void
FHoudiniParameterDetails::PruneStack()
{
for (int32 StackItr = FolderStack.Num() - 1; StackItr >= 0; --StackItr)
{
TArray<UHoudiniParameterFolder*> &CurrentQueue = FolderStack[StackItr];
for (int32 QueueItr = CurrentQueue.Num() - 1; QueueItr >= 0; --QueueItr)
{
UHoudiniParameterFolder * CurrentFolder = CurrentQueue[QueueItr];
if (!CurrentFolder || CurrentFolder->IsPendingKill())
continue;
if (CurrentFolder->GetChildCounter() == 0)
{
CurrentQueue.RemoveAt(QueueItr);
}
}
if (CurrentQueue.Num() == 0)
{
FolderStack.RemoveAt(StackItr);
}
}
}
FText
FHoudiniParameterDetails::GetParameterTooltip(UHoudiniParameter* InParam)
{
if (!InParam || InParam->IsPendingKill())
return FText();
// Tooltip starts with Label (name)
FString Tooltip = InParam->GetParameterLabel() + TEXT(" (") + InParam->GetParameterName() + TEXT(")");
// Append the parameter type
FString ParmTypeStr = GetParameterTypeString(InParam->GetParameterType(), InParam->GetTupleSize());
if (!ParmTypeStr.IsEmpty())
Tooltip += TEXT("\n") + ParmTypeStr;
// If the parameter has some help, append it
FString Help = InParam->GetParameterHelp();
if (!Help.IsEmpty())
Tooltip += TEXT("\n") + Help;
// If the parameter has an expression, append it
if (InParam->HasExpression())
{
FString Expr = InParam->GetExpression();
if (!Expr.IsEmpty())
Tooltip += TEXT("\nExpression: ") + Expr;
}
return FText::FromString(Tooltip);
}
FString
FHoudiniParameterDetails::GetParameterTypeString(const EHoudiniParameterType& InType, const int32& InTupleSize)
{
FString ParamStr;
switch (InType)
{
case EHoudiniParameterType::Button:
ParamStr = TEXT("Button");
break;
case EHoudiniParameterType::ButtonStrip:
ParamStr = TEXT("Button Strip");
break;
case EHoudiniParameterType::Color:
{
if (InTupleSize == 4)
ParamStr = TEXT("Color with Alpha");
else
ParamStr = TEXT("Color");
}
break;
case EHoudiniParameterType::ColorRamp:
ParamStr = TEXT("Color Ramp");
break;
case EHoudiniParameterType::File:
ParamStr = TEXT("File (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::FileDir:
ParamStr = TEXT("File Dir (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::FileGeo:
ParamStr = TEXT("File Geo (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::FileImage:
ParamStr = TEXT("File Image (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::Float:
ParamStr = TEXT("Float (VEC") + FString::FromInt(InTupleSize) + TEXT(")");
break;
case EHoudiniParameterType::FloatRamp:
ParamStr = TEXT("Float Ramp");
break;
case EHoudiniParameterType::Folder:
case EHoudiniParameterType::FolderList:
break;
case EHoudiniParameterType::Input:
ParamStr = TEXT("Opearator Path");
break;
case EHoudiniParameterType::Int:
ParamStr = TEXT("Integer (VEC") + FString::FromInt(InTupleSize) + TEXT(")");
break;
case EHoudiniParameterType::IntChoice:
ParamStr = TEXT("Int Choice");
break;
case EHoudiniParameterType::Label:
ParamStr = TEXT("Label (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::MultiParm:
ParamStr = TEXT("MultiParm");
break;
case EHoudiniParameterType::Separator:
break;
case EHoudiniParameterType::String:
ParamStr = TEXT("String (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::StringAssetRef:
ParamStr = TEXT("String Asset Ref (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
case EHoudiniParameterType::StringChoice:
ParamStr = TEXT("String Choice");
break;
case EHoudiniParameterType::Toggle:
ParamStr = TEXT("Toggle (") + FString::FromInt(InTupleSize) + TEXT(" tuple)");
break;
default:
ParamStr = TEXT("invalid parameter type");
break;
}
return ParamStr;
}
void
FHoudiniParameterDetails::SyncCachedColorRampPoints(UHoudiniParameterRampColor* ColorRampParameter)
{
if (!ColorRampParameter)
return;
// Do not sync when the Houdini asset component is cooking
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(ColorRampParameter))
return;
TArray<UHoudiniParameterRampColorPoint*> &CachedPoints = ColorRampParameter->CachedPoints;
TArray<UHoudiniParameterRampColorPoint*> &CurrentPoints = ColorRampParameter->Points;
bool bCurveNeedsUpdate = false;
bool bRampParmNeedsUpdate = false;
int32 Idx = 0;
while (Idx < CachedPoints.Num() && Idx < CurrentPoints.Num())
{
UHoudiniParameterRampColorPoint* CachedPoint = CachedPoints[Idx];
UHoudiniParameterRampColorPoint* CurrentPoint = CurrentPoints[Idx];
if (!CachedPoint || !CurrentPoint)
continue;
if (CachedPoint->GetPosition() != CurrentPoint->GetPosition())
{
if (CurrentPoint->PositionParentParm)
{
CurrentPoint->SetPosition(CachedPoint->GetPosition());
CurrentPoint->PositionParentParm->MarkChanged(true);
bCurveNeedsUpdate = true;
}
}
if (CachedPoint->GetValue() != CurrentPoint->GetValue())
{
if (CurrentPoint->ValueParentParm)
{
CurrentPoint->SetValue(CachedPoint->GetValue());
CurrentPoint->ValueParentParm->MarkChanged(true);
bCurveNeedsUpdate = true;
}
}
if (CachedPoint->GetInterpolation() != CurrentPoint->GetInterpolation())
{
if (CurrentPoint->InterpolationParentParm)
{
CurrentPoint->SetInterpolation(CachedPoint->GetInterpolation());
CurrentPoint->InterpolationParentParm->MarkChanged(true);
bCurveNeedsUpdate = true;
}
}
Idx += 1;
}
// Insert points
for (int32 IdxCachedPointLeft = Idx; IdxCachedPointLeft < CachedPoints.Num(); ++IdxCachedPointLeft)
{
UHoudiniParameterRampColorPoint* CachedPoint = CachedPoints[IdxCachedPointLeft];
CreateColorRampParameterInsertEvent(
ColorRampParameter, CachedPoint->Position, CachedPoint->Value, CachedPoint->Interpolation);
bCurveNeedsUpdate = true;
bRampParmNeedsUpdate = true;
}
// Delete points
for (int32 IdxCurrentPointLeft = Idx; IdxCurrentPointLeft < CurrentPoints.Num(); ++IdxCurrentPointLeft)
{
ColorRampParameter->RemoveElement(IdxCurrentPointLeft);
UHoudiniParameterRampColorPoint* Point = CurrentPoints[IdxCurrentPointLeft];
if (!Point)
continue;
CreateColorRampParameterDeleteEvent(ColorRampParameter, Point->InstanceIndex);
bCurveNeedsUpdate = true;
bRampParmNeedsUpdate = true;
}
ColorRampParameter->MarkChanged(bRampParmNeedsUpdate);
}
//void
//FHoudiniParameterDetails::SyncCachedFloatRampPoints(UHoudiniParameterRampFloat* FloatRampParameter)
//{
// if (!FloatRampParameter)
// return;
//
// // Do not sync when the Houdini asset component is cooking
// if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(FloatRampParameter))
// return;
//
// TArray<UHoudiniParameterRampFloatPoint*> &CachedPoints = FloatRampParameter->CachedPoints;
// TArray<UHoudiniParameterRampFloatPoint*> &CurrentPoints = FloatRampParameter->Points;
//
// int32 Idx = 0;
//
// while (Idx < CachedPoints.Num() && Idx < CurrentPoints.Num())
// {
// UHoudiniParameterRampFloatPoint* &CachedPoint = CachedPoints[Idx];
// UHoudiniParameterRampFloatPoint* &CurrentPoint = CurrentPoints[Idx];
//
// if (!CachedPoint || !CurrentPoint)
// continue;
//
// if (CachedPoint->GetPosition() != CurrentPoint->GetPosition())
// {
// if (CurrentPoint->PositionParentParm)
// {
// CurrentPoint->SetPosition(CachedPoint->GetPosition());
// CurrentPoint->PositionParentParm->MarkChanged(true);
// }
// }
//
// if (CachedPoint->GetValue() != CurrentPoint->GetValue())
// {
// if (CurrentPoint->ValueParentParm)
// {
// CurrentPoint->SetValue(CachedPoint->GetValue());
// CurrentPoint->ValueParentParm->MarkChanged(true);
// }
// }
//
// if (CachedPoint->GetInterpolation() != CurrentPoint->GetInterpolation())
// {
// if (CurrentPoint->InterpolationParentParm)
// {
// CurrentPoint->SetInterpolation(CachedPoint->GetInterpolation());
// CurrentPoint->InterpolationParentParm->MarkChanged(true);
// }
// }
//
// Idx += 1;
// }
//
// // Insert points
// for (int32 IdxCachedPointLeft = Idx; IdxCachedPointLeft < CachedPoints.Num(); ++IdxCachedPointLeft)
// {
// UHoudiniParameterRampFloatPoint *&CachedPoint = CachedPoints[IdxCachedPointLeft];
// if (!CachedPoint)
// continue;
//
// CreateFloatRampParameterInsertEvent(
// FloatRampParameter, CachedPoint->Position, CachedPoint->Value, CachedPoint->Interpolation);
//
// FloatRampParameter->MarkChanged(true);
// }
//
// // Remove points
// for (int32 IdxCurrentPointLeft = Idx; IdxCurrentPointLeft < CurrentPoints.Num(); ++IdxCurrentPointLeft)
// {
// FloatRampParameter->RemoveElement(IdxCurrentPointLeft);
//
// UHoudiniParameterRampFloatPoint* Point = CurrentPoints[IdxCurrentPointLeft];
//
// if (!Point)
// continue;
//
// CreateFloatRampParameterDeleteEvent(FloatRampParameter, Point->InstanceIndex);
//
// FloatRampParameter->MarkChanged(true);
// }
//}
void
FHoudiniParameterDetails::CreateFloatRampParameterDeleteEvent(UHoudiniParameterRampFloat* InParam, const int32 &InDeleteIndex)
{
if (!InParam || InParam->IsPendingKill())
return;
UHoudiniParameterRampModificationEvent* DeleteEvent = NewObject<UHoudiniParameterRampModificationEvent>(
InParam, UHoudiniParameterRampModificationEvent::StaticClass());
if (!DeleteEvent)
return;
DeleteEvent->SetFloatRampEvent();
DeleteEvent->SetDeleteEvent();
DeleteEvent->DeleteInstanceIndex = InDeleteIndex;
InParam->ModificationEvents.Add(DeleteEvent);
}
void
FHoudiniParameterDetails::CreateColorRampParameterDeleteEvent(UHoudiniParameterRampColor* InParam, const int32 &InDeleteIndex)
{
if (!InParam || InParam->IsPendingKill())
return;
UHoudiniParameterRampModificationEvent* DeleteEvent = NewObject<UHoudiniParameterRampModificationEvent>(
InParam, UHoudiniParameterRampModificationEvent::StaticClass());
if (!DeleteEvent)
return;
DeleteEvent->SetColorRampEvent();
DeleteEvent->SetDeleteEvent();
DeleteEvent->DeleteInstanceIndex = InDeleteIndex;
InParam->ModificationEvents.Add(DeleteEvent);
}
void
FHoudiniParameterDetails::CreateFloatRampParameterInsertEvent(UHoudiniParameterRampFloat* InParam,
const float& InPosition, const float& InValue, const EHoudiniRampInterpolationType &InInterp)
{
if (!InParam || InParam->IsPendingKill())
return;
UHoudiniParameterRampModificationEvent* InsertEvent = NewObject<UHoudiniParameterRampModificationEvent>(
InParam, UHoudiniParameterRampModificationEvent::StaticClass());
if (!InsertEvent)
return;
InsertEvent->SetFloatRampEvent();
InsertEvent->SetInsertEvent();
InsertEvent->InsertPosition = InPosition;
InsertEvent->InsertFloat = InValue;
InsertEvent->InsertInterpolation = InInterp;
InParam->ModificationEvents.Add(InsertEvent);
}
void
FHoudiniParameterDetails::CreateColorRampParameterInsertEvent(UHoudiniParameterRampColor* InParam,
const float& InPosition, const FLinearColor& InColor, const EHoudiniRampInterpolationType &InInterp)
{
if (!InParam || InParam->IsPendingKill())
return;
UHoudiniParameterRampModificationEvent* InsertEvent = NewObject<UHoudiniParameterRampModificationEvent>(
InParam, UHoudiniParameterRampModificationEvent::StaticClass());
if (!InsertEvent)
return;
InsertEvent->SetColorRampEvent();
InsertEvent->SetInsertEvent();
InsertEvent->InsertPosition = InPosition;
InsertEvent->InsertColor = InColor;
InsertEvent->InsertInterpolation = InInterp;
InParam->ModificationEvents.Add(InsertEvent);
}
void
FHoudiniParameterDetails:: ReplaceAllFloatRampParameterPointsWithMainParameter(TArray<UHoudiniParameterRampFloat*>& FloatRampParameters)
{
if (FloatRampParameters.Num() < 1)
return;
UHoudiniParameterRampFloat* MainParam = FloatRampParameters[0];
if (!MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
for (int32 Idx = 1; Idx < FloatRampParameters.Num(); ++Idx)
{
UHoudiniParameterRampFloat* NextFloatRampParameter = FloatRampParameters[Idx];
if (!NextFloatRampParameter)
continue;
FHoudiniParameterDetails::ReplaceFloatRampParameterPointsWithMainParameter(MainParam, NextFloatRampParameter);
}
}
void
FHoudiniParameterDetails::ReplaceAllFloatRampParameterPointsWithMainParameter(TArray<TWeakObjectPtr<UHoudiniParameterRampFloat>>& FloatRampParameters)
{
if (FloatRampParameters.Num() < 1)
return;
if (!FloatRampParameters[0].IsValid())
return;
UHoudiniParameterRampFloat* MainParam = FloatRampParameters[0].Get();
if (!MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
for (int32 Idx = 1; Idx < FloatRampParameters.Num(); ++Idx)
{
if (!FloatRampParameters[Idx].IsValid())
continue;
UHoudiniParameterRampFloat* NextFloatRampParameter = FloatRampParameters[Idx].Get();
if (!NextFloatRampParameter)
continue;
FHoudiniParameterDetails::ReplaceFloatRampParameterPointsWithMainParameter(MainParam, NextFloatRampParameter);
}
}
void
FHoudiniParameterDetails:: ReplaceFloatRampParameterPointsWithMainParameter(UHoudiniParameterRampFloat* Param, UHoudiniParameterRampFloat* MainParam)
{
if (!Param || !MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(Param))
return;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
// Use Synced points if the MainParam is on auto update mode
// Use Cached points if the Mainparam is on manual update mode
TArray<UHoudiniParameterRampFloatPoint*> & MainPoints = (MainParam->IsAutoUpdate() && bCookingEnabled) ? MainParam->Points : MainParam->CachedPoints;
if (Param->IsAutoUpdate() && bCookingEnabled)
{
TArray<UHoudiniParameterRampFloatPoint*> & Points = Param->Points;
int32 PointIdx = 0;
while (MainPoints.IsValidIndex(PointIdx) && Points.IsValidIndex(PointIdx))
{
UHoudiniParameterRampFloatPoint*& MainPoint = MainPoints[PointIdx];
UHoudiniParameterRampFloatPoint*& Point = Points[PointIdx];
if (!MainPoint || !Point)
continue;
if (MainPoint->GetPosition() != Point->GetPosition())
{
if (Point->PositionParentParm)
{
Point->SetPosition(MainPoint->GetPosition());
Point->PositionParentParm->MarkChanged(true);
}
}
if (MainPoint->GetValue() != Point->GetValue())
{
if (Point->ValueParentParm)
{
Point->SetValue(MainPoint->GetValue());
Point->ValueParentParm->MarkChanged(true);
}
}
if (MainPoint->GetInterpolation() != Point->GetInterpolation())
{
if (Point->InterpolationParentParm)
{
Point->SetInterpolation(MainPoint->GetInterpolation());
Point->InterpolationParentParm->MarkChanged(true);
}
}
PointIdx += 1;
}
int32 PointInsertIdx = PointIdx;
int32 PointDeleteIdx = PointIdx;
// skip the pending modification events
for (auto & Event : Param->ModificationEvents)
{
if (!Event)
continue;
if (Event->IsInsertEvent())
PointInsertIdx += 1;
if (Event->IsDeleteEvent())
PointDeleteIdx += 1;
}
// There are more points in MainPoints array
for (; PointInsertIdx < MainPoints.Num(); ++PointInsertIdx)
{
UHoudiniParameterRampFloatPoint*& NextMainPoint = MainPoints[PointInsertIdx];
if (!NextMainPoint)
continue;
FHoudiniParameterDetails::CreateFloatRampParameterInsertEvent(Param,
NextMainPoint->GetPosition(), NextMainPoint->GetValue(), NextMainPoint->GetInterpolation());
Param->MarkChanged(true);
}
// There are more points in Points array
for (; PointDeleteIdx < Points.Num(); ++PointDeleteIdx)
{
UHoudiniParameterRampFloatPoint*& NextPoint = Points[PointDeleteIdx];
if (!NextPoint)
continue;
FHoudiniParameterDetails::CreateFloatRampParameterDeleteEvent(Param, NextPoint->InstanceIndex);
Param->MarkChanged(true);
}
}
else
{
TArray<UHoudiniParameterRampFloatPoint*> &Points = Param->CachedPoints;
int32 PointIdx = 0;
while (MainPoints.IsValidIndex(PointIdx) && Points.IsValidIndex(PointIdx))
{
UHoudiniParameterRampFloatPoint*& MainPoint = MainPoints[PointIdx];
UHoudiniParameterRampFloatPoint*& Point = Points[PointIdx];
if (!MainPoint || !Point)
continue;
if (Point->Position != MainPoint->Position)
{
Point->Position = MainPoint->Position;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->InterpolationParentParm)
Point->PositionParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
if (Point->Value != MainPoint->Value)
{
Point->Value = MainPoint->Value;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->ValueParentParm)
Point->ValueParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
if (Point->Interpolation != MainPoint->Interpolation)
{
Point->Interpolation = MainPoint->Interpolation;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->InterpolationParentParm)
Point->InterpolationParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
PointIdx += 1;
}
// There are more points in MainPoints array
for (int32 MainPointsLeftIdx = PointIdx; MainPointsLeftIdx < MainPoints.Num(); ++MainPointsLeftIdx)
{
UHoudiniParameterRampFloatPoint* NextMainPoint = MainPoints[MainPointsLeftIdx];
if (!NextMainPoint)
continue;
UHoudiniParameterRampFloatPoint* NewCachedPoint = NewObject<UHoudiniParameterRampFloatPoint>(Param, UHoudiniParameterRampFloatPoint::StaticClass());
if (!NewCachedPoint)
continue;
NewCachedPoint->Position = NextMainPoint->GetPosition();
NewCachedPoint->Value = NextMainPoint->GetValue();
NewCachedPoint->Interpolation = NextMainPoint->GetInterpolation();
Points.Add(NewCachedPoint);
Param->bCaching = true;
}
// there are more points in Points array
for (int32 PointsLeftIdx = PointIdx; PointIdx < Points.Num(); ++PointIdx)
{
Points.Pop();
Param->bCaching = true;
}
}
}
void
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(TArray<UHoudiniParameterRampColor*>& ColorRampParameters)
{
if (ColorRampParameters.Num() < 1)
return;
UHoudiniParameterRampColor* MainParam = ColorRampParameters[0];
if (!MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
for (int32 Idx = 1; Idx < ColorRampParameters.Num(); ++Idx)
{
UHoudiniParameterRampColor* NextColorRampParam = ColorRampParameters[Idx];
if (!NextColorRampParam)
continue;
FHoudiniParameterDetails::ReplaceColorRampParameterPointsWithMainParameter(MainParam, NextColorRampParam);
}
}
void
FHoudiniParameterDetails::ReplaceAllColorRampParameterPointsWithMainParameter(TArray<TWeakObjectPtr<UHoudiniParameterRampColor>>& ColorRampParameters)
{
if (ColorRampParameters.Num() < 1)
return;
if (!ColorRampParameters[0].IsValid())
return;
UHoudiniParameterRampColor* MainParam = ColorRampParameters[0].Get();
if (!MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(MainParam))
return;
for (int32 Idx = 1; Idx < ColorRampParameters.Num(); ++Idx)
{
if (!ColorRampParameters[Idx].IsValid())
continue;
UHoudiniParameterRampColor* NextColorRampParameter = ColorRampParameters[Idx].Get();
if (!NextColorRampParameter)
continue;
FHoudiniParameterDetails::ReplaceColorRampParameterPointsWithMainParameter(MainParam, NextColorRampParameter);
}
}
void
FHoudiniParameterDetails::ReplaceColorRampParameterPointsWithMainParameter(UHoudiniParameterRampColor* Param, UHoudiniParameterRampColor* MainParam)
{
if (!Param || !MainParam)
return;
if (FHoudiniEngineUtils::IsHoudiniAssetComponentCooking(Param))
return;
const bool bCookingEnabled = FHoudiniEngine::Get().IsCookingEnabled();
// Use Synced points if the MainParam is on auto update mode
// Use Cached points if the Mainparam is on manual update mode
TArray<UHoudiniParameterRampColorPoint*> & MainPoints = (MainParam->IsAutoUpdate() && bCookingEnabled) ? MainParam->Points : MainParam->CachedPoints;
if (Param->IsAutoUpdate() && bCookingEnabled)
{
TArray<UHoudiniParameterRampColorPoint*> & Points = Param->Points;
int32 PointIdx = 0;
while (MainPoints.IsValidIndex(PointIdx) && Points.IsValidIndex(PointIdx))
{
UHoudiniParameterRampColorPoint*& MainPoint = MainPoints[PointIdx];
UHoudiniParameterRampColorPoint*& Point = Points[PointIdx];
if (!MainPoint || !Point)
continue;
if (MainPoint->GetPosition() != Point->GetPosition())
{
if (Point->PositionParentParm)
{
Point->SetPosition(MainPoint->GetPosition());
Point->PositionParentParm->MarkChanged(true);
}
}
if (MainPoint->GetValue() != Point->GetValue())
{
if (Point->ValueParentParm)
{
Point->SetValue(MainPoint->GetValue());
Point->ValueParentParm->MarkChanged(true);
}
}
if (MainPoint->GetInterpolation() != Point->GetInterpolation())
{
if (Point->InterpolationParentParm)
{
Point->SetInterpolation(MainPoint->GetInterpolation());
Point->InterpolationParentParm->MarkChanged(true);
}
}
PointIdx += 1;
}
int32 PointInsertIdx = PointIdx;
int32 PointDeleteIdx = PointIdx;
// skip the pending modification events
for (auto & Event : Param->ModificationEvents)
{
if (!Event)
continue;
if (Event->IsInsertEvent())
PointInsertIdx += 1;
if (Event->IsDeleteEvent())
PointDeleteIdx += 1;
}
// There are more points in MainPoints array
for (; PointInsertIdx < MainPoints.Num(); ++PointInsertIdx)
{
UHoudiniParameterRampColorPoint*& NextMainPoint = MainPoints[PointInsertIdx];
if (!NextMainPoint)
continue;
FHoudiniParameterDetails::CreateColorRampParameterInsertEvent(Param,
NextMainPoint->GetPosition(), NextMainPoint->GetValue(), NextMainPoint->GetInterpolation());
Param->MarkChanged(true);
}
// There are more points in Points array
for (; PointDeleteIdx < Points.Num(); ++PointDeleteIdx)
{
UHoudiniParameterRampColorPoint*& NextPoint = Points[PointDeleteIdx];
if (!NextPoint)
continue;
FHoudiniParameterDetails::CreateColorRampParameterDeleteEvent(Param, NextPoint->InstanceIndex);
Param->MarkChanged(true);
}
}
else
{
TArray<UHoudiniParameterRampColorPoint*> &Points = Param->CachedPoints;
int32 PointIdx = 0;
while (MainPoints.IsValidIndex(PointIdx) && Points.IsValidIndex(PointIdx))
{
UHoudiniParameterRampColorPoint*& MainPoint = MainPoints[PointIdx];
UHoudiniParameterRampColorPoint*& Point = Points[PointIdx];
if (!MainPoint || !Point)
continue;
if (Point->Position != MainPoint->Position)
{
Point->Position = MainPoint->Position;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->PositionParentParm)
Point->PositionParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
if (Point->Value != MainPoint->Value)
{
Point->Value = MainPoint->Value;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->ValueParentParm)
Point->ValueParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
if (Point->Interpolation != MainPoint->Interpolation)
{
Point->Interpolation = MainPoint->Interpolation;
Param->bCaching = true;
if (!bCookingEnabled)
{
if (Point->InterpolationParentParm)
Point->InterpolationParentParm->MarkChanged(true);
Param->MarkChanged(true);
}
}
PointIdx += 1;
}
// There are more points in Main Points array.
for (int32 MainPointsLeftIdx = PointIdx; MainPointsLeftIdx < MainPoints.Num(); ++MainPointsLeftIdx)
{
UHoudiniParameterRampColorPoint* NextMainPoint = MainPoints[MainPointsLeftIdx];
if (!NextMainPoint)
continue;
UHoudiniParameterRampColorPoint* NewCachedPoint = NewObject<UHoudiniParameterRampColorPoint>(Param, UHoudiniParameterRampColorPoint::StaticClass());
if (!NewCachedPoint)
continue;
NewCachedPoint->Position = NextMainPoint->Position;
NewCachedPoint->Value = NextMainPoint->Value;
NewCachedPoint->Interpolation = NextMainPoint->Interpolation;
Points.Add(NewCachedPoint);
Param->bCaching = true;
}
// There are more points in Points array
for (int32 PointsleftIdx = PointIdx; PointIdx < MainPoints.Num(); ++PointsleftIdx)
{
Points.Pop();
Param->bCaching = true;
}
}
}
// Check recursively if a parameter hits the end of a visible tabs
void
FHoudiniParameterDetails::RemoveTabDividers(IDetailCategoryBuilder& HouParameterCategory, UHoudiniParameter* InParam)
{
if (!InParam || InParam->IsPendingKill())
return;
// When the paramId is invalid, the directory won't parse.
// So simply return the function
if (InParam->GetParmId() < 0)
return;
// Do not end the tab if this param is a non empty parent type, leave it to its children
EHoudiniParameterType ParmType = InParam->GetParameterType();
if ((ParmType == EHoudiniParameterType::FolderList ||
ParmType == EHoudiniParameterType::Folder) && InParam->GetTupleSize() > 0)
return;
if (ParmType == EHoudiniParameterType::MultiParm)
{
UHoudiniParameterMultiParm* InMultiParm = Cast<UHoudiniParameterMultiParm>(InParam);
if (!InMultiParm)
return;
if (InMultiParm->MultiParmInstanceCount * InMultiParm->MultiParmInstanceLength > 0)
return;
}
int32 ParentParamId = InParam->GetParentParmId();
UHoudiniParameter* CurParam = InParam;
while (AllFoldersAndFolderLists.Contains(ParentParamId) || AllMultiParms.Contains(ParentParamId))
{
if (AllMultiParms.Contains(ParentParamId))
{
// The parent is a multiparm
UHoudiniParameterMultiParm* ParentMultiParm = AllMultiParms[ParentParamId];
if (!ParentMultiParm || ParentMultiParm->IsPendingKill())
return;
if (ParentMultiParm->MultiParmInstanceCount * ParentMultiParm->MultiParmInstanceLength - 1 == CurParam->GetChildIndex())
{
ParentParamId = ParentMultiParm->GetParentParmId();
CurParam = ParentMultiParm;
continue;
}
else
{
// return directly if the parameter is not the last child param of the multiparm
return;
}
}
else
{
// The parent is a folder or folderlist
UHoudiniParameter* ParentFolderParam = AllFoldersAndFolderLists[ParentParamId];
CurParam = ParentFolderParam;
if (!ParentFolderParam || ParentFolderParam->IsPendingKill())
return;
if (ParentFolderParam->GetParameterType() == EHoudiniParameterType::Folder)
{
// The parent is a folder
ParentParamId = ParentFolderParam->GetParentParmId();
continue;
}
else
{
// The parent is a folderlist
UHoudiniParameterFolderList* ParentFolderList = Cast<UHoudiniParameterFolderList>(ParentFolderParam);
if (!ParentFolderList || ParentFolderList->IsPendingKill())
return;
if (ParentFolderList->IsTabMenu() && ParentFolderList->IsTabsShown() && ParentFolderList->IsTabParseFinished() && DividerLinePositions.Num() > 0)
{
if (!CurrentTabEndingRow)
CreateTabEndingRow(HouParameterCategory);
if (CurrentTabEndingRow)
{
CurrentTabEndingRow->EndingDividerLinePositions.Add(DividerLinePositions.Top());
CurrentTabEndingRow->DividerLinePositions.Pop();
}
DividerLinePositions.Pop();
ParentParamId = ParentFolderList->GetParentParmId();
}
else
{
return;
}
}
}
}
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink