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

2606 lines
71 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 "HoudiniInput.h"
#include "HoudiniEngineRuntime.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniOutput.h"
#include "HoudiniSplineComponent.h"
#include "HoudiniAsset.h"
#include "HoudiniGeoPartObject.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniAssetBlueprintComponent.h"
#include "EngineUtils.h"
#include "Engine/Brush.h"
#include "Engine/Engine.h"
#include "Engine/DataTable.h"
#include "Model.h"
#include "Engine/StaticMesh.h"
#include "Engine/SkeletalMesh.h"
#include "UObject/UObjectGlobals.h"
#include "FoliageType_InstancedStaticMesh.h"
#include "Components/SplineComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Landscape.h"
#if WITH_EDITOR
#include "Kismet2/BlueprintEditorUtils.h"
#include "Kismet2/KismetEditorUtilities.h"
#endif
//
UHoudiniInput::UHoudiniInput()
: Type(EHoudiniInputType::Invalid)
, PreviousType(EHoudiniInputType::Invalid)
, AssetNodeId(-1)
, InputNodeId(-1)
, InputIndex(0)
, ParmId(-1)
, bIsObjectPathParameter(false)
, bHasChanged(false)
, bPackBeforeMerge(false)
, bExportLODs(false)
, bExportSockets(false)
, bExportColliders(false)
, bCookOnCurveChanged(true)
, bStaticMeshChanged(false)
, bInputAssetConnectedInHoudini(false)
, DefaultCurveOffset(0.f)
, bAddRotAndScaleAttributesOnCurves(false)
, bIsWorldInputBoundSelector(false)
, bWorldInputBoundSelectorAutoUpdate(false)
, UnrealSplineResolution(50.0f)
, bUpdateInputLandscape(false)
, LandscapeExportType(EHoudiniLandscapeExportType::Heightfield)
, bLandscapeExportSelectionOnly(false)
, bLandscapeAutoSelectComponent(false)
, bLandscapeExportMaterials(false)
, bLandscapeExportLighting(false)
, bLandscapeExportNormalizedUVs(false)
, bLandscapeExportTileUVs(false)
{
Name = TEXT("");
Label = TEXT("");
SetFlags(RF_Transactional);
// Geometry inputs always have one null default object
GeometryInputObjects.Add(nullptr);
KeepWorldTransform = GetDefaultXTransformType();
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault<UHoudiniRuntimeSettings>();
UnrealSplineResolution = HoudiniRuntimeSettings ? HoudiniRuntimeSettings->MarshallingSplineResolution : 50.0f;
bAddRotAndScaleAttributesOnCurves = HoudiniRuntimeSettings ? HoudiniRuntimeSettings->bAddRotAndScaleAttributesOnCurves : false;
}
void
UHoudiniInput::BeginDestroy()
{
InvalidateData();
// DO NOT MANUALLY DESTROY OUR INPUT OBJECTS!
// This messes up unreal's Garbage collection and would cause crashes on duplication
// Mark all our input objects for destruction
ForAllHoudiniInputObjectArrays([](TArray<UHoudiniInputObject*>& ObjectArray) {
ObjectArray.Empty();
});
Super::BeginDestroy();
}
#if WITH_EDITOR
void UHoudiniInput::PostEditUndo()
{
Super::PostEditUndo();
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
if (!InputObjectsPtr)
return;
MarkChanged(true);
bool bBlueprintStructureChanged = false;
if (HasInputTypeChanged())
{
// If the input type has changed on undo, previousType becomes new type
/* This does not work properly, see the corresponding part in FHoudiniInputDetails::AddInputTypeComboBox(...), after Transaction(...
)
{
EHoudiniInputType NewType = PreviousType;
SetInputType(NewType);
}
*/
EHoudiniInputType Temp = Type;
Type = PreviousType;
PreviousType = EHoudiniInputType::Invalid;
// If the undo action caused input type changing, treat it as a regular type changing
// after set up the new and prev types properly
SetInputType(Temp, bBlueprintStructureChanged);
}
else
{
if (Type == EHoudiniInputType::Asset)
{
// Mark the input asset object as changed, since only undo changing asset will get into here.
// The input array will be empty when undo adding asset (only support single asset input object in an input now)
for (auto & NextAssetInputObj : *InputObjectsPtr)
{
if (!NextAssetInputObj || NextAssetInputObj->IsPendingKill())
continue;
NextAssetInputObj->MarkChanged(true);
}
}
if (Type == EHoudiniInputType::World)
{
if (WorldInputObjects.Num() == 0 && InputNodeId >= 0)
{
for (auto & NextNodeId : CreatedDataNodeIds)
{
if (bCanDeleteHoudiniNodes)
FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(NextNodeId, true);
}
CreatedDataNodeIds.Empty();
if (bCanDeleteHoudiniNodes)
FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
InputNodeId = -1;
}
}
if (Type == EHoudiniInputType::Curve)
{
if (PreviousType != EHoudiniInputType::Curve)
{
for (auto& NextInput : *GetHoudiniInputObjectArray(Type))
{
UHoudiniInputHoudiniSplineComponent* SplineInput = Cast< UHoudiniInputHoudiniSplineComponent>(NextInput);
if (!SplineInput || SplineInput->IsPendingKill())
continue;
UHoudiniSplineComponent * HoudiniSplineComponent = SplineInput->GetCurveComponent();
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
continue;
USceneComponent* OuterComponent = Cast<USceneComponent>(GetOuter());
// Attach the new Houdini spline component to it's owner
HoudiniSplineComponent->RegisterComponent();
HoudiniSplineComponent->AttachToComponent(OuterComponent, FAttachmentTransformRules::KeepRelativeTransform);
HoudiniSplineComponent->SetVisibility(true, true);
HoudiniSplineComponent->SetHoudiniSplineVisible(true);
HoudiniSplineComponent->SetHiddenInGame(false, true);
HoudiniSplineComponent->MarkChanged(true);
}
return;
}
bool bUndoDelete = false;
bool bUndoInsert = false;
bool bUndoDeletedObjArrayEmptied = false;
TArray< USceneComponent* > childActor;
UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
if (OuterHAC && !OuterHAC->IsPendingKill())
childActor = OuterHAC->GetAttachChildren();
// Undo delete input objects action
for (int Index = 0; Index < GetNumberOfInputObjects(); ++Index)
{
UHoudiniInputObject* InputObject = (*InputObjectsPtr)[Index];
if (!InputObject || InputObject->IsPendingKill())
continue;
UHoudiniInputHoudiniSplineComponent * HoudiniSplineInputObject = Cast<UHoudiniInputHoudiniSplineComponent>(InputObject);
if (!HoudiniSplineInputObject || HoudiniSplineInputObject->IsPendingKill())
continue;
UHoudiniSplineComponent* SplineComponent = HoudiniSplineInputObject->GetCurveComponent();
if (!SplineComponent || SplineComponent->IsPendingKill())
continue;
// If the last change deleted this curve input, recreate this Houdini Spline input.
if (!SplineComponent->GetAttachParent())
{
bUndoDelete = true;
if (!bUndoDeletedObjArrayEmptied)
LastUndoDeletedInputs.Empty();
bUndoDeletedObjArrayEmptied = true;
UHoudiniSplineComponent * ReconstructedSpline = NewObject<UHoudiniSplineComponent>(
GetOuter(), UHoudiniSplineComponent::StaticClass());
if (!ReconstructedSpline || ReconstructedSpline->IsPendingKill())
continue;
ReconstructedSpline->SetFlags(RF_Transactional);
ReconstructedSpline->CopyHoudiniData(SplineComponent);
UHoudiniInputObject * ReconstructedInputObject = UHoudiniInputHoudiniSplineComponent::Create(
ReconstructedSpline, GetOuter(), ReconstructedSpline->GetHoudiniSplineName());
UHoudiniInputHoudiniSplineComponent *ReconstructedHoudiniSplineInput = (UHoudiniInputHoudiniSplineComponent*)ReconstructedInputObject;
(*InputObjectsPtr)[Index] = ReconstructedHoudiniSplineInput;
ReconstructedSpline->RegisterComponent();
ReconstructedSpline->SetFlags(RF_Transactional);
CreateHoudiniSplineInput(ReconstructedHoudiniSplineInput, true, true, bBlueprintStructureChanged);
// Cast the reconstructed Houdini Spline Input to a generic HoudiniInput object.
UHoudiniInputObject * ReconstructedHoudiniInput = Cast<UHoudiniInputObject>(ReconstructedHoudiniSplineInput);
LastUndoDeletedInputs.Add(ReconstructedHoudiniInput);
// Reset the LastInsertedInputsArray for redoing this undo action.
}
}
if (bUndoDelete)
return;
// Undo insert input objects action
for (int Index = 0; Index < LastInsertedInputs.Num(); ++Index)
{
bUndoInsert = true;
UHoudiniInputHoudiniSplineComponent* SplineInputComponent = LastInsertedInputs[Index];
if (!SplineInputComponent || SplineInputComponent->IsPendingKill())
continue;
UHoudiniSplineComponent* HoudiniSplineComponent = SplineInputComponent->GetCurveComponent();
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
continue;
HoudiniSplineComponent->DestroyComponent();
}
if (bUndoInsert)
return;
for (int Index = 0; Index < LastUndoDeletedInputs.Num(); ++Index)
{
UHoudiniInputObject* NextInputObject = LastUndoDeletedInputs[Index];
UHoudiniInputHoudiniSplineComponent* SplineInputComponent = Cast<UHoudiniInputHoudiniSplineComponent>(NextInputObject);
if (!SplineInputComponent || SplineInputComponent->IsPendingKill())
continue;
UHoudiniSplineComponent* HoudiniSplineComponent = SplineInputComponent->GetCurveComponent();
if (!HoudiniSplineComponent || SplineInputComponent->IsPendingKill())
continue;
FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
HoudiniSplineComponent->DetachFromComponent(DetachTransRules);
HoudiniSplineComponent->DestroyComponent();
}
}
}
if (bBlueprintStructureChanged)
{
UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(OuterHAC);
}
}
#endif
FBox
UHoudiniInput::GetBounds() const
{
FBox BoxBounds(ForceInitToZero);
switch (Type)
{
case EHoudiniInputType::Curve:
{
for (int32 Idx = 0; Idx < CurveInputObjects.Num(); ++Idx)
{
const UHoudiniInputHoudiniSplineComponent* CurInCurve = Cast<UHoudiniInputHoudiniSplineComponent>(CurveInputObjects[Idx]);
if (!CurInCurve || CurInCurve->IsPendingKill())
continue;
UHoudiniSplineComponent* CurCurve = CurInCurve->GetCurveComponent();
if (!CurCurve || CurCurve->IsPendingKill())
continue;
FBox CurCurveBound(ForceInitToZero);
for (auto & Trans : CurCurve->CurvePoints)
{
CurCurveBound += Trans.GetLocation();
}
UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
if (OuterHAC && !OuterHAC->IsPendingKill())
BoxBounds += CurCurveBound.MoveTo(OuterHAC->GetComponentLocation());
}
}
break;
case EHoudiniInputType::Asset:
{
for (int32 Idx = 0; Idx < AssetInputObjects.Num(); ++Idx)
{
UHoudiniInputHoudiniAsset* CurInAsset = Cast<UHoudiniInputHoudiniAsset>(AssetInputObjects[Idx]);
if (!CurInAsset || CurInAsset->IsPendingKill())
continue;
UHoudiniAssetComponent* CurInHAC = CurInAsset->GetHoudiniAssetComponent();
if (!CurInHAC || CurInHAC->IsPendingKill())
continue;
BoxBounds += CurInHAC->GetAssetBounds(nullptr, false);
}
}
break;
case EHoudiniInputType::World:
{
for (int32 Idx = 0; Idx < WorldInputObjects.Num(); ++Idx)
{
UHoudiniInputActor* CurInActor = Cast<UHoudiniInputActor>(WorldInputObjects[Idx]);
if (CurInActor && !CurInActor->IsPendingKill())
{
AActor* Actor = CurInActor->GetActor();
if (!Actor || Actor->IsPendingKill())
continue;
FVector Origin, Extent;
Actor->GetActorBounds(false, Origin, Extent);
BoxBounds += FBox::BuildAABB(Origin, Extent);
}
else
{
// World Input now also support HoudiniAssets
UHoudiniInputHoudiniAsset* CurInAsset = Cast<UHoudiniInputHoudiniAsset>(WorldInputObjects[Idx]);
if (CurInAsset && !CurInAsset->IsPendingKill())
{
UHoudiniAssetComponent* CurInHAC = CurInAsset->GetHoudiniAssetComponent();
if (!CurInHAC || CurInHAC->IsPendingKill())
continue;
BoxBounds += CurInHAC->GetAssetBounds(nullptr, false);
continue;
}
}
}
}
break;
case EHoudiniInputType::Landscape:
{
for (int32 Idx = 0; Idx < LandscapeInputObjects.Num(); ++Idx)
{
UHoudiniInputLandscape* CurInLandscape = Cast<UHoudiniInputLandscape>(LandscapeInputObjects[Idx]);
if (!CurInLandscape || CurInLandscape->IsPendingKill())
continue;
ALandscapeProxy* CurLandscape = CurInLandscape->GetLandscapeProxy();
if (!CurLandscape || CurLandscape->IsPendingKill())
continue;
FVector Origin, Extent;
CurLandscape->GetActorBounds(false, Origin, Extent);
BoxBounds += FBox::BuildAABB(Origin, Extent);
}
}
break;
case EHoudiniInputType::Skeletal:
case EHoudiniInputType::Invalid:
default:
break;
}
return BoxBounds;
}
FString
UHoudiniInput::InputTypeToString(const EHoudiniInputType& InInputType)
{
FString InputTypeStr;
switch (InInputType)
{
case EHoudiniInputType::Geometry:
{
InputTypeStr = TEXT("Geometry Input");
}
break;
case EHoudiniInputType::Asset:
{
InputTypeStr = TEXT("Asset Input");
}
break;
case EHoudiniInputType::Curve:
{
InputTypeStr = TEXT("Curve Input");
}
break;
case EHoudiniInputType::Landscape:
{
InputTypeStr = TEXT("Landscape Input");
}
break;
case EHoudiniInputType::World:
{
InputTypeStr = TEXT("World Outliner Input");
}
break;
case EHoudiniInputType::Skeletal:
{
InputTypeStr = TEXT("Skeletal Mesh Input");
}
break;
}
return InputTypeStr;
}
EHoudiniInputType
UHoudiniInput::StringToInputType(const FString& InInputTypeString)
{
if (InInputTypeString.StartsWith(TEXT("Geometry"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::Geometry;
}
else if (InInputTypeString.StartsWith(TEXT("Asset"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::Asset;
}
else if (InInputTypeString.StartsWith(TEXT("Curve"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::Curve;
}
else if (InInputTypeString.StartsWith(TEXT("Landscape"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::Landscape;
}
else if (InInputTypeString.StartsWith(TEXT("World"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::World;
}
else if (InInputTypeString.StartsWith(TEXT("Skeletal"), ESearchCase::IgnoreCase))
{
return EHoudiniInputType::Skeletal;
}
return EHoudiniInputType::Invalid;
}
EHoudiniCurveType UHoudiniInput::StringToHoudiniCurveType(const FString& HoudiniCurveTypeString)
{
if (HoudiniCurveTypeString.StartsWith(TEXT("Polygon"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveType::Polygon;
}
else if (HoudiniCurveTypeString.StartsWith(TEXT("Nurbs"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveType::Nurbs;
}
else if (HoudiniCurveTypeString.StartsWith(TEXT("Bezier"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveType::Bezier;
}
else if (HoudiniCurveTypeString.StartsWith(TEXT("Points"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveType::Points;
}
return EHoudiniCurveType::Invalid;
}
EHoudiniCurveMethod UHoudiniInput::StringToHoudiniCurveMethod(const FString& HoudiniCurveMethodString)
{
if (HoudiniCurveMethodString.StartsWith(TEXT("CVs"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveMethod::CVs;
}
else if (HoudiniCurveMethodString.StartsWith(TEXT("Breakpoints"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveMethod::Breakpoints;
}
else if (HoudiniCurveMethodString.StartsWith(TEXT("Freehand"), ESearchCase::IgnoreCase))
{
return EHoudiniCurveMethod::Freehand;
}
return EHoudiniCurveMethod::Invalid;
}
//
void
UHoudiniInput::SetSOPInput(const int32& InInputIndex)
{
// Set the input index
InputIndex = InInputIndex;
// Invalidate objpath parameter
ParmId = -1;
bIsObjectPathParameter = false;
}
void
UHoudiniInput::SetObjectPathParameter(const int32& InParmId)
{
// Set as objpath parameter
ParmId = InParmId;
bIsObjectPathParameter = true;
// Invalidate the geo input
InputIndex = -1;
}
EHoudiniXformType
UHoudiniInput::GetDefaultXTransformType()
{
switch (Type)
{
case EHoudiniInputType::Curve:
case EHoudiniInputType::Geometry:
case EHoudiniInputType::Skeletal:
return EHoudiniXformType::None;
case EHoudiniInputType::Asset:
case EHoudiniInputType::Landscape:
case EHoudiniInputType::World:
return EHoudiniXformType::IntoThisObject;
}
return EHoudiniXformType::Auto;
}
bool
UHoudiniInput::GetKeepWorldTransform() const
{
bool bReturn = false;
switch (KeepWorldTransform)
{
case EHoudiniXformType::Auto:
{
// Return default values corresponding to the input type:
if (Type == EHoudiniInputType::Curve
|| Type == EHoudiniInputType::Geometry
|| Type == EHoudiniInputType::Skeletal )
{
// NONE for Geo, Curve and skeletal mesh IN
bReturn = false;
}
else
{
// INTO THIS OBJECT for Asset, Landscape and World IN
bReturn = true;
}
break;
}
case EHoudiniXformType::None:
{
bReturn = false;
break;
}
case EHoudiniXformType::IntoThisObject:
{
bReturn = true;
break;
}
}
return bReturn;
}
void
UHoudiniInput::SetKeepWorldTransform(const bool& bInKeepWorldTransform)
{
if (bInKeepWorldTransform)
{
KeepWorldTransform = EHoudiniXformType::IntoThisObject;
}
else
{
KeepWorldTransform = EHoudiniXformType::None;
}
}
void
UHoudiniInput::SetInputType(const EHoudiniInputType& InInputType, bool& bOutBlueprintStructureModified)
{
if (InInputType == Type)
return;
SetPreviousInputType(Type);
// Mark this input as changed
MarkChanged(true);
bOutBlueprintStructureModified = true;
// Check previous input type
switch (PreviousType)
{
case EHoudiniInputType::Asset:
{
break;
}
case EHoudiniInputType::Curve:
{
// detach the input curves from the asset component
if (GetNumberOfInputObjects() > 0)
{
for (UHoudiniInputObject * CurrentInput : *GetHoudiniInputObjectArray(Type))
{
UHoudiniInputHoudiniSplineComponent * CurrentInputHoudiniSpline = Cast<UHoudiniInputHoudiniSplineComponent>(CurrentInput);
if (!CurrentInputHoudiniSpline || CurrentInputHoudiniSpline->IsPendingKill())
continue;
UHoudiniSplineComponent * HoudiniSplineComponent = CurrentInputHoudiniSpline->GetCurveComponent();
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
continue;
HoudiniSplineComponent->Modify();
const bool bIsArchetype = HoudiniSplineComponent->HasAnyFlags(RF_ArchetypeObject|RF_ClassDefaultObject);
if (bIsArchetype)
{
#if WITH_EDITOR
check(HoudiniSplineComponent->IsTemplate());
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bVisible", false);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHiddenInGame", true);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bIsHoudiniSplineVisible", false);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHasChanged", true);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bNeedsToTriggerUpdate", true);
#endif
}
else
{
AActor* OwningActor = HoudiniSplineComponent->GetOwner();
check(OwningActor);
FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
HoudiniSplineComponent->DetachFromComponent(DetachTransRules);
HoudiniSplineComponent->SetVisibility(false, true);
HoudiniSplineComponent->SetHoudiniSplineVisible(false);
HoudiniSplineComponent->SetHiddenInGame(true, true);
// This NodeId shouldn't be invalidated like this. If a spline component
// or curve input is no longer valid, the input object should be removed from the HoudinInput
// to get cleaned up properly.
// HoudiniSplineComponent->SetNodeId(-1);
HoudiniSplineComponent->MarkChanged(true);
}
bOutBlueprintStructureModified = true;
}
}
break;
}
case EHoudiniInputType::Geometry:
{
break;
}
case EHoudiniInputType::Landscape:
{
TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(PreviousType);
if (!InputObjectsArray)
break;
for (int32 Idx = 0; Idx < InputObjectsArray->Num(); ++Idx)
{
UHoudiniInputObject* InputObj = (*InputObjectsArray)[Idx];
if (!InputObj || InputObj->IsPendingKill())
continue;
UHoudiniInputLandscape* InputLandscape = Cast<UHoudiniInputLandscape>(InputObj);
if (!InputLandscape || InputLandscape->IsPendingKill())
continue;
// do something?
}
break;
}
case EHoudiniInputType::Skeletal:
{
break;
}
case EHoudiniInputType::World:
{
break;
}
default:
break;
}
Type = InInputType;
// TODO: NOPE, not needed
// Set keep world transform to default w.r.t to new input type.
//KeepWorldTransform = GetDefaultXTransformType();
// Check current input type
switch (InInputType)
{
case EHoudiniInputType::World:
case EHoudiniInputType::Asset:
{
UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
if (OuterHAC && !bImportAsReference)
{
for (auto& CurrentInput : *GetHoudiniInputObjectArray(Type))
{
UHoudiniInputHoudiniAsset* HoudiniAssetInput = Cast<UHoudiniInputHoudiniAsset>(CurrentInput);
if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill())
continue;
UHoudiniAssetComponent* CurrentHAC = HoudiniAssetInput->GetHoudiniAssetComponent();
if (!CurrentHAC || CurrentHAC->IsPendingKill())
continue;
CurrentHAC->AddDownstreamHoudiniAsset(OuterHAC);
}
}
}
break;
case EHoudiniInputType::Curve:
{
if (GetNumberOfInputObjects() == 0)
{
CreateNewCurveInputObject(bOutBlueprintStructureModified);
MarkChanged(true);
}
else
{
for (auto& CurrentInput : *GetHoudiniInputObjectArray(Type))
{
UHoudiniInputHoudiniSplineComponent* SplineInput = Cast< UHoudiniInputHoudiniSplineComponent>(CurrentInput);
if (!IsValid(SplineInput))
continue;
UHoudiniSplineComponent * HoudiniSplineComponent = SplineInput->GetCurveComponent();
if (!IsValid(HoudiniSplineComponent))
continue;
HoudiniSplineComponent->Modify();
const bool bIsArchetype = HoudiniSplineComponent->HasAnyFlags(RF_ArchetypeObject|RF_ClassDefaultObject);
if (bIsArchetype)
{
#if WITH_EDITOR
check(HoudiniSplineComponent->IsTemplate());
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bVisible", true);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHiddenInGame", false);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bIsHoudiniSplineVisible", true);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bHasChanged", true);
FHoudiniEngineRuntimeUtils::SetTemplatePropertyValue(HoudiniSplineComponent, "bNeedsToTriggerUpdate", true);
#endif
}
else
{
// Attach the new Houdini spline component to it's owner
AActor* OwningActor = HoudiniSplineComponent->GetOwner();
check(OwningActor);
USceneComponent* OuterComponent = Cast<USceneComponent>(GetOuter());
HoudiniSplineComponent->RegisterComponent();
HoudiniSplineComponent->AttachToComponent(OuterComponent, FAttachmentTransformRules::KeepRelativeTransform);
HoudiniSplineComponent->SetHoudiniSplineVisible(true);
HoudiniSplineComponent->SetHiddenInGame(false, true);
HoudiniSplineComponent->SetVisibility(true, true);
HoudiniSplineComponent->MarkChanged(true);
}
bOutBlueprintStructureModified = true;
}
}
}
break;
case EHoudiniInputType::Geometry:
{
}
break;
case EHoudiniInputType::Landscape:
{
// Need to do anything on select?
}
break;
case EHoudiniInputType::Skeletal:
{
}
break;
default:
{
}
break;
}
}
UHoudiniInputObject*
UHoudiniInput::CreateNewCurveInputObject(bool& bOutBlueprintStructureModified)
{
if (CurveInputObjects.Num() > 0)
return nullptr;
UHoudiniInputHoudiniSplineComponent* NewCurveInputObject = CreateHoudiniSplineInput(nullptr, true, false, bOutBlueprintStructureModified);
if (!NewCurveInputObject || NewCurveInputObject->IsPendingKill())
return nullptr;
UHoudiniSplineComponent * HoudiniSplineComponent = NewCurveInputObject->GetCurveComponent();
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
return nullptr;
// Default Houdini spline component input should not be visible at initialization
HoudiniSplineComponent->SetVisibility(true, true);
HoudiniSplineComponent->SetHoudiniSplineVisible(true);
HoudiniSplineComponent->SetHiddenInGame(false, true);
CurveInputObjects.Add(NewCurveInputObject);
SetInputObjectsNumber(EHoudiniInputType::Curve, 1);
CurveInputObjects.SetNum(1);
return NewCurveInputObject;
}
void
UHoudiniInput::MarkAllInputObjectsChanged(const bool& bInChanged)
{
MarkDataUploadNeeded(bInChanged);
// Mark all the objects from this input has changed so they upload themselves
TSet<EHoudiniInputType> InputTypes;
InputTypes.Add(Type);
InputTypes.Add(EHoudiniInputType::Curve);
TArray<UHoudiniInputObject*>* NewInputObjects = GetHoudiniInputObjectArray(Type);
if (NewInputObjects)
{
for (auto CurInputObject : *NewInputObjects)
{
if (CurInputObject && !CurInputObject->IsPendingKill())
CurInputObject->MarkChanged(bInChanged);
}
}
}
UHoudiniInput * UHoudiniInput::DuplicateAndCopyState(UObject * DestOuter, bool bInCanDeleteHoudiniNodes)
{
UHoudiniInput* NewInput = Cast<UHoudiniInput>(StaticDuplicateObject(this, DestOuter));
NewInput->CopyStateFrom(this, false, bInCanDeleteHoudiniNodes);
return NewInput;
}
void UHoudiniInput::CopyStateFrom(UHoudiniInput* InInput, bool bCopyAllProperties, bool bInCanDeleteHoudiniNodes)
{
// Preserve the current input objects before the copy to ensure we don't lose
// access to input objects and have them end up in the garbage.
TMap<EHoudiniInputType, TArray<UHoudiniInputObject*>*> PrevInputObjectsMap;
for(EHoudiniInputType InputType : HoudiniInputTypeList)
{
PrevInputObjectsMap.Add(InputType, GetHoudiniInputObjectArray(InputType));
}
// TArray<UHoudiniInputObject*> PrevInputObjects;
// TArray<UHoudiniInputObject*>* OldToInputObjects = GetHoudiniInputObjectArray(Type);
// if (OldToInputObjects)
// PrevInputObjects = *OldToInputObjects;
// Copy the state of this UHoudiniInput object.
if (bCopyAllProperties)
{
UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
Params.bDoDelta = false; // Perform a deep copy
Params.bClearReferences = false; // References will be replaced afterwards.
UEngine::CopyPropertiesForUnrelatedObjects(InInput, this, Params);
}
AssetNodeId = InInput->AssetNodeId;
InputNodeId = InInput->InputNodeId;
ParmId = InInput->ParmId;
bCanDeleteHoudiniNodes = bInCanDeleteHoudiniNodes;
//if (bInCanDeleteHoudiniNodes)
//{
// // Delete stale data nodes before they get overwritten.
// TSet<int32> NewNodeIds(InInput->CreatedDataNodeIds);
// for (int32 NodeId : CreatedDataNodeIds)
// {
// if (!NewNodeIds.Contains(NodeId))
// {
// FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(NodeId);
// }
// }
//}
CreatedDataNodeIds = InInput->CreatedDataNodeIds;
// Important note: At this point the new object may still share objects with InInput.
// The CopyInputs() will properly duplicate inputs where necessary.
// Copy states of Input Objects that correspond to the current type.
for(auto& Entry : PrevInputObjectsMap)
{
EHoudiniInputType InputType = Entry.Key;
TArray<UHoudiniInputObject*>* PrevInputObjects = Entry.Value;
TArray<UHoudiniInputObject*>* ToInputObjects = GetHoudiniInputObjectArray(InputType);
TArray<UHoudiniInputObject*>* FromInputObjects = InInput->GetHoudiniInputObjectArray(InputType);
if (ToInputObjects && FromInputObjects)
{
*ToInputObjects = *PrevInputObjects;
CopyInputs(*ToInputObjects, *FromInputObjects, bInCanDeleteHoudiniNodes);
}
}
}
void UHoudiniInput::SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes)
{
bCanDeleteHoudiniNodes = bInCanDeleteNodes;
for(UHoudiniInputObject* InputObject : GeometryInputObjects)
{
if (!InputObject)
continue;
InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
}
for(UHoudiniInputObject* InputObject : AssetInputObjects)
{
if (!InputObject)
continue;
InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
}
for(UHoudiniInputObject* InputObject : CurveInputObjects)
{
if (!InputObject)
continue;
InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
}
for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
{
if (!InputObject)
continue;
InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
}
for(UHoudiniInputObject* InputObject : WorldInputObjects)
{
if (!InputObject)
continue;
InputObject->SetCanDeleteHoudiniNodes(bInCanDeleteNodes);
}
}
void UHoudiniInput::InvalidateData()
{
// If valid, mark our input node for deletion
if (InputNodeId >= 0)
{
// .. but if we're an asset input, don't delete the node as InputNodeId
// is set to the input HDA's node ID!
if (Type != EHoudiniInputType::Asset)
{
if (bCanDeleteHoudiniNodes)
FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
}
InputNodeId = -1;
}
for(UHoudiniInputObject* InputObject : GeometryInputObjects)
{
if (!InputObject)
continue;
InputObject->InvalidateData();
}
for(UHoudiniInputObject* InputObject : AssetInputObjects)
{
if (!InputObject)
continue;
InputObject->InvalidateData();
}
for(UHoudiniInputObject* InputObject : CurveInputObjects)
{
if (!InputObject)
continue;
InputObject->InvalidateData();
}
for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
{
if (!InputObject)
continue;
InputObject->InvalidateData();
}
for(UHoudiniInputObject* InputObject : WorldInputObjects)
{
if (!InputObject)
continue;
if (InputObject->IsA<UHoudiniInputHoudiniAsset>())
{
// When the input object is a HoudiniAssetComponent,
// we need to be sure that this HDA node id is not in CreatedDataNodeIds
// We dont want to delete the input HDA node!
CreatedDataNodeIds.Remove(InputObject->InputNodeId);
}
InputObject->InvalidateData();
}
if (bCanDeleteHoudiniNodes)
{
auto& HoudiniEngineRuntime = FHoudiniEngineRuntime::Get();
for(int32 NodeId : CreatedDataNodeIds)
{
HoudiniEngineRuntime.MarkNodeIdAsPendingDelete(NodeId, true);
}
}
CreatedDataNodeIds.Empty();
}
void UHoudiniInput::CopyInputs(TArray<UHoudiniInputObject*>& ToInputObjects, TArray<UHoudiniInputObject*>& FromInputObjects, bool bInCanDeleteHoudiniNodes)
{
TSet<UHoudiniInputObject*> StaleObjects(ToInputObjects);
const int32 NumInputs = FromInputObjects.Num();
UObject* TargetOuter = GetOuter();
ToInputObjects.SetNum(NumInputs);
for (int i = 0; i < NumInputs; i++)
{
UHoudiniInputObject* FromObject = FromInputObjects[i];
UHoudiniInputObject* ToObject = ToInputObjects[i];
if (!FromObject)
{
ToInputObjects[i] = nullptr;
continue;
}
if (ToObject)
{
bool IsValid = true;
// Is ToInput and FromInput the same or do we have to create a input object?
IsValid = IsValid && ToObject->Matches(*FromObject);
IsValid = IsValid && ToObject->GetOuter() == TargetOuter;
if (!IsValid)
{
ToObject = nullptr;
}
}
if (ToObject)
{
// We have an existing (matching) object. Copy the
// state from the incoming input.
StaleObjects.Remove(ToObject);
ToObject->CopyStateFrom(FromObject, true);
}
else
{
// We need to create a new input here.
ToObject = FromObject->DuplicateAndCopyState(TargetOuter);
ToInputObjects[i] = ToObject;
}
ToObject->SetCanDeleteHoudiniNodes(bInCanDeleteHoudiniNodes);
}
for (UHoudiniInputObject* StaleInputObject : StaleObjects)
{
if (!StaleInputObject)
continue;
if (StaleInputObject->GetOuter() == this)
{
StaleInputObject->SetCanDeleteHoudiniNodes(bInCanDeleteHoudiniNodes);
}
}
}
UHoudiniInputHoudiniSplineComponent*
UHoudiniInput::CreateHoudiniSplineInput(UHoudiniInputHoudiniSplineComponent * FromHoudiniSplineInputComponent, const bool & bAttachToparent, const bool & bAppendToInputArray, bool& bOutBlueprintStructureModified)
{
UHoudiniInputHoudiniSplineComponent* HoudiniSplineInput = nullptr;
UHoudiniSplineComponent* HoudiniSplineComponent = nullptr;
UObject* OuterObj = GetOuter();
USceneComponent* OuterComp = Cast<USceneComponent>(GetOuter());
bool bOuterIsTemplate = (OuterObj && OuterObj->IsTemplate());
if (!FromHoudiniSplineInputComponent)
{
// NOTE: If we're inside the Blueprint editor, the outer here is going to the be HAC component template.
check(OuterObj)
// Create a default Houdini spline input if a null pointer is passed in.
FName HoudiniSplineName = MakeUniqueObjectName(OuterComp, UHoudiniSplineComponent::StaticClass(), TEXT("Houdini Spline"));
// Create a Houdini Input Object.
UHoudiniInputObject * NewInputObject = UHoudiniInputHoudiniSplineComponent::Create(
nullptr, OuterObj, HoudiniSplineName.ToString());
if (!NewInputObject || NewInputObject->IsPendingKill())
return nullptr;
HoudiniSplineInput = Cast<UHoudiniInputHoudiniSplineComponent>(NewInputObject);
if (!HoudiniSplineInput)
return nullptr;
HoudiniSplineComponent = NewObject<UHoudiniSplineComponent>(
HoudiniSplineInput, UHoudiniSplineComponent::StaticClass());
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
return nullptr;
HoudiniSplineInput->Update(HoudiniSplineComponent);
HoudiniSplineComponent->SetHoudiniSplineName(HoudiniSplineName.ToString());
HoudiniSplineComponent->SetFlags(RF_Transactional);
// Set the default position of curve to avoid overlapping.
HoudiniSplineComponent->SetOffset(DefaultCurveOffset);
DefaultCurveOffset += 100.f;
if (!bOuterIsTemplate)
{
HoudiniSplineComponent->RegisterComponent();
// Attach the new Houdini spline component to it's owner.
if (bAttachToparent)
HoudiniSplineComponent->AttachToComponent(OuterComp, FAttachmentTransformRules::KeepRelativeTransform);
}
//push the new input object to the array for new type.
if (bAppendToInputArray && Type == EHoudiniInputType::Curve)
GetHoudiniInputObjectArray(Type)->Add(NewInputObject);
#if WITH_EDITOR
if (bOuterIsTemplate)
{
UHoudiniAssetBlueprintComponent* HAB = Cast<UHoudiniAssetBlueprintComponent>(OuterObj);
if (HAB)
{
UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(HAB->GetOuter());
UBlueprint* Blueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
if (Blueprint)
{
TArray<UActorComponent*> Components;
Components.Add(HoudiniSplineComponent);
USCS_Node* HABNode = HAB->FindSCSNodeForTemplateComponentInClassHierarchy(HAB);
// NOTE: FAddComponentsToBlueprintParams was introduced in 4.26 so for the sake of
// backwards compatibility, manually determine which SCSNode was added instead of
// relying on Params.OutNodes.
//FKismetEditorUtilities::FAddComponentsToBlueprintParams Params;
//Params.OptionalNewRootNode = HABNode;
const TSet<USCS_Node*> PreviousSCSNodes(Blueprint->SimpleConstructionScript->GetAllNodes());
FKismetEditorUtilities::AddComponentsToBlueprint(Blueprint, Components, FKismetEditorUtilities::EAddComponentToBPHarvestMode::None, HABNode, false);
USCS_Node* NewNode = nullptr;
const TSet<USCS_Node*> CurrentSCSNodes(Blueprint->SimpleConstructionScript->GetAllNodes());
const TSet<USCS_Node*> AddedNodes = CurrentSCSNodes.Difference(PreviousSCSNodes);
if (AddedNodes.Num() > 0)
{
// Record Input / SCS node mapping
USCS_Node* SCSNode = AddedNodes.Array()[0];
HAB->AddInputObjectMapping(NewInputObject->GetInputGuid(), SCSNode->VariableGuid);
SCSNode->ComponentTemplate->SetFlags(RF_Public | RF_ArchetypeObject | RF_DefaultSubObject);
}
Blueprint->Modify();
bOutBlueprintStructureModified = true;
}
}
}
#endif
}
else
{
// Otherwise, get the Houdini spline, and Houdini spline input from the argument.
HoudiniSplineInput = FromHoudiniSplineInputComponent;
HoudiniSplineComponent = FromHoudiniSplineInputComponent->GetCurveComponent();
if (!HoudiniSplineComponent || HoudiniSplineComponent->IsPendingKill())
return nullptr;
// Attach the new Houdini spline component to it's owner.
HoudiniSplineComponent->AttachToComponent(OuterComp, FAttachmentTransformRules::KeepRelativeTransform);
}
// Mark the created UHoudiniSplineComponent as an input, and set its InputObject.
HoudiniSplineComponent->SetIsInputCurve(true);
// HoudiniSplineComponent->SetInputObject(HoudiniSplineInput);
// Set Houdini Spline Component bHasChanged and bNeedsToTrigerUpdate to true.
HoudiniSplineComponent->MarkChanged(true);
return HoudiniSplineInput;
}
void
UHoudiniInput::RemoveSplineFromInputObject(
UHoudiniInputHoudiniSplineComponent* InHoudiniSplineInputObject,
bool& bOutBlueprintStructureModified) const
{
if (!InHoudiniSplineInputObject)
return;
UObject* OuterObj = GetOuter();
const bool bOuterIsTemplate = OuterObj && OuterObj->IsTemplate();
if (bOuterIsTemplate)
{
#if WITH_EDITOR
// Find the SCS node that corresponds to this input and remove it.
UHoudiniAssetBlueprintComponent* HAB = Cast<UHoudiniAssetBlueprintComponent>(OuterObj);
if (HAB)
{
const UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(HAB->GetOuter());
UBlueprint* Blueprint = Cast<UBlueprint>(BPGC->ClassGeneratedBy);
if (Blueprint)
{
USimpleConstructionScript* SCS = Blueprint->SimpleConstructionScript;
check(SCS);
FGuid SCSGuid;
if (HAB->GetInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid, SCSGuid))
{
// TODO: Move this SCS variable removal code to a reusable utility function. We're
// going to need to reuse this in a few other places too.
USCS_Node* SCSNode = SCS->FindSCSNodeByGuid(SCSGuid);
if (SCSNode)
{
SCS->RemoveNodeAndPromoteChildren(SCSNode);
SCSNode->SetOnNameChanged(FSCSNodeNameChanged());
bOutBlueprintStructureModified = true;
HAB->RemoveInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid);
if (SCSNode->ComponentTemplate != nullptr)
{
const FName TemplateName = SCSNode->ComponentTemplate->GetFName();
const FString RemovedName = SCSNode->GetVariableName().ToString() + TEXT("_REMOVED_") + FGuid::NewGuid().ToString();
SCSNode->ComponentTemplate->Modify();
SCSNode->ComponentTemplate->Rename(*RemovedName, /*NewOuter =*/nullptr, REN_DontCreateRedirectors);
TArray<UObject*> ArchetypeInstances;
auto DestroyArchetypeInstances = [&ArchetypeInstances, &RemovedName](UActorComponent* ComponentTemplate)
{
ComponentTemplate->GetArchetypeInstances(ArchetypeInstances);
for (UObject* ArchetypeInstance : ArchetypeInstances)
{
if (!ArchetypeInstance->HasAllFlags(RF_ArchetypeObject | RF_InheritableComponentTemplate))
{
CastChecked<UActorComponent>(ArchetypeInstance)->DestroyComponent();
ArchetypeInstance->Rename(*RemovedName, nullptr, REN_DontCreateRedirectors);
}
}
};
DestroyArchetypeInstances(SCSNode->ComponentTemplate);
if (Blueprint)
{
// Children need to have their inherited component template instance of the component renamed out of the way as well
TArray<UClass*> ChildrenOfClass;
GetDerivedClasses(Blueprint->GeneratedClass, ChildrenOfClass);
for (UClass* ChildClass : ChildrenOfClass)
{
UBlueprintGeneratedClass* BPChildClass = CastChecked<UBlueprintGeneratedClass>(ChildClass);
if (UActorComponent* Component = (UActorComponent*)FindObjectWithOuter(BPChildClass, UActorComponent::StaticClass(), TemplateName))
{
Component->Modify();
Component->Rename(*RemovedName, /*NewOuter =*/nullptr, REN_DontCreateRedirectors);
DestroyArchetypeInstances(Component);
}
}
}
}
}
} // if (HAB->GetInputObjectSCSVariableGuid(InHoudiniSplineInputObject->Guid, SCSGuid))
} // if (Blueprint)
}
#endif
} // if (bIsOuterTemplate)
else
{
UHoudiniSplineComponent* HoudiniSplineComponent = InHoudiniSplineInputObject->GetCurveComponent();
if (HoudiniSplineComponent)
{
// detach the input curves from the asset component
//FDetachmentTransformRules DetachTransRules(EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, EDetachmentRule::KeepRelative, false);
//HoudiniSplineComponent->DetachFromComponent(DetachTransRules);
// Destroy the Houdini Spline Component
//InputObjectsPtr->RemoveAt(AtIndex);
HoudiniSplineComponent->DestroyComponent();
}
}
InHoudiniSplineInputObject->Update(nullptr);
}
TArray<UHoudiniInputObject*>*
UHoudiniInput::GetHoudiniInputObjectArray(const EHoudiniInputType& InType)
{
switch (InType)
{
case EHoudiniInputType::Geometry:
return &GeometryInputObjects;
case EHoudiniInputType::Curve:
return &CurveInputObjects;
case EHoudiniInputType::Asset:
return &AssetInputObjects;
case EHoudiniInputType::Landscape:
return &LandscapeInputObjects;
case EHoudiniInputType::World:
return &WorldInputObjects;
case EHoudiniInputType::Skeletal:
return &SkeletalInputObjects;
default:
case EHoudiniInputType::Invalid:
return nullptr;
}
return nullptr;
}
TArray<AActor*>*
UHoudiniInput::GetBoundSelectorObjectArray()
{
return &WorldInputBoundSelectorObjects;
}
const TArray<AActor*>*
UHoudiniInput::GetBoundSelectorObjectArray() const
{
return &WorldInputBoundSelectorObjects;
}
const TArray<UHoudiniInputObject*>*
UHoudiniInput::GetHoudiniInputObjectArray(const EHoudiniInputType& InType) const
{
switch (InType)
{
case EHoudiniInputType::Geometry:
return &GeometryInputObjects;
case EHoudiniInputType::Curve:
return &CurveInputObjects;
case EHoudiniInputType::Asset:
return &AssetInputObjects;
case EHoudiniInputType::Landscape:
return &LandscapeInputObjects;
case EHoudiniInputType::World:
return &WorldInputObjects;
case EHoudiniInputType::Skeletal:
return &SkeletalInputObjects;
default:
case EHoudiniInputType::Invalid:
return nullptr;
}
return nullptr;
}
UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const int32& AtIndex)
{
return GetHoudiniInputObjectAt(Type, AtIndex);
}
const UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const int32& AtIndex) const
{
const TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(Type);
if (!InputObjectsArray || !InputObjectsArray->IsValidIndex(AtIndex))
return nullptr;
return (*InputObjectsArray)[AtIndex];
}
UHoudiniInputObject*
UHoudiniInput::GetHoudiniInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
TArray<UHoudiniInputObject*>* InputObjectsArray = GetHoudiniInputObjectArray(InType);
if (!InputObjectsArray || !InputObjectsArray->IsValidIndex(AtIndex))
return nullptr;
return (*InputObjectsArray)[AtIndex];
}
UObject*
UHoudiniInput::GetInputObjectAt(const int32& AtIndex)
{
return GetInputObjectAt(Type, AtIndex);
}
AActor*
UHoudiniInput::GetBoundSelectorObjectAt(const int32& AtIndex)
{
if (!WorldInputBoundSelectorObjects.IsValidIndex(AtIndex))
return nullptr;
return WorldInputBoundSelectorObjects[AtIndex];
}
UObject*
UHoudiniInput::GetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
UHoudiniInputObject* HoudiniInputObject = GetHoudiniInputObjectAt(InType, AtIndex);
if (!HoudiniInputObject || HoudiniInputObject->IsPendingKill())
return nullptr;
return HoudiniInputObject->GetObject();
}
void
UHoudiniInput::InsertInputObjectAt(const int32& AtIndex)
{
InsertInputObjectAt(Type, AtIndex);
}
void
UHoudiniInput::InsertInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return;
InputObjectsPtr->InsertDefaulted(AtIndex, 1);
MarkChanged(true);
}
void
UHoudiniInput::DeleteInputObjectAt(const int32& AtIndex)
{
DeleteInputObjectAt(Type, AtIndex);
}
void
UHoudiniInput::DeleteInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return;
if (!InputObjectsPtr->IsValidIndex(AtIndex))
return;
bool bBlueprintStructureModified = false;
if (Type == EHoudiniInputType::Asset)
{
// ... TODO operations for removing asset input type
}
else if (Type == EHoudiniInputType::Curve)
{
UHoudiniInputHoudiniSplineComponent* HoudiniSplineInputObject = Cast<UHoudiniInputHoudiniSplineComponent>((*InputObjectsPtr)[AtIndex]);
if (HoudiniSplineInputObject)
{
RemoveSplineFromInputObject(HoudiniSplineInputObject, bBlueprintStructureModified);
}
}
else if (Type == EHoudiniInputType::Geometry)
{
// ... TODO operations for removing geometry input type
}
else if (Type == EHoudiniInputType::Landscape)
{
// ... TODO operations for removing landscape input type
}
else if (Type == EHoudiniInputType::Skeletal)
{
// ... TODO operations for removing skeletal input type
}
else if (Type == EHoudiniInputType::World)
{
// ... TODO operations for removing world input type
}
else
{
// ... invalid input type
}
MarkChanged(true);
UHoudiniInputObject* InputObjectToDelete = (*InputObjectsPtr)[AtIndex];
if (InputObjectToDelete && !InputObjectToDelete->IsPendingKill())
{
// Mark the input object's nodes for deletion
InputObjectToDelete->InvalidateData();
// If the deleted object wasnt null, trigger a re upload of the input data
MarkDataUploadNeeded(true);
}
InputObjectsPtr->RemoveAt(AtIndex);
// Delete the merge node when all the input objects are deleted.
if (InputObjectsPtr->Num() == 0 && InputNodeId >= 0)
{
if (bCanDeleteHoudiniNodes)
FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId);
InputNodeId = -1;
}
#if WITH_EDITOR
if (bBlueprintStructureModified)
{
UActorComponent* Component = Cast<UActorComponent>(GetOuter());
FHoudiniEngineRuntimeUtils::MarkBlueprintAsStructurallyModified(Component);
}
#endif
}
void
UHoudiniInput::DuplicateInputObjectAt(const int32& AtIndex)
{
DuplicateInputObjectAt(Type, AtIndex);
}
void
UHoudiniInput::DuplicateInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return;
if (!InputObjectsPtr->IsValidIndex(AtIndex))
return;
// If the duplicated object is not null, trigger a re upload of the input data
bool bTriggerUpload = (*InputObjectsPtr)[AtIndex] != nullptr;
// TODO: Duplicate the UHoudiniInputObject!!
UHoudiniInputObject* DuplicateInput = (*InputObjectsPtr)[AtIndex];
InputObjectsPtr->Insert(DuplicateInput, AtIndex);
MarkChanged(true);
if (bTriggerUpload)
MarkDataUploadNeeded(true);
}
int32
UHoudiniInput::GetNumberOfInputObjects()
{
return GetNumberOfInputObjects(Type);
}
int32
UHoudiniInput::GetNumberOfInputObjects(const EHoudiniInputType& InType)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return 0;
return InputObjectsPtr->Num();
}
int32
UHoudiniInput::GetNumberOfInputMeshes()
{
return GetNumberOfInputMeshes(Type);
}
int32
UHoudiniInput::GetNumberOfInputMeshes(const EHoudiniInputType& InType)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return 0;
// TODO?
// If geometry input, and we only have one null object, return 0
int32 Num = InputObjectsPtr->Num();
// TODO: Fix BP properly!
// Special case for SM in BP:
// we need to add extra input objects store in BlueprintStaticMeshes
// Same thing for Actor InputObjects!
for (auto InputObj : *InputObjectsPtr)
{
if (!InputObj || InputObj->IsPendingKill())
continue;
UHoudiniInputStaticMesh* InputSM = Cast<UHoudiniInputStaticMesh>(InputObj);
if (InputSM && !InputSM->IsPendingKill())
{
if (InputSM->BlueprintStaticMeshes.Num() > 0)
{
Num += (InputSM->BlueprintStaticMeshes.Num() - 1);
}
}
UHoudiniInputActor* InputActor = Cast<UHoudiniInputActor>(InputObj);
if (InputActor && !InputActor->IsPendingKill())
{
if (InputActor->GetActorComponents().Num() > 0)
{
Num += (InputActor->GetActorComponents().Num() - 1);
}
}
}
return Num;
}
int32
UHoudiniInput::GetNumberOfBoundSelectorObjects() const
{
return WorldInputBoundSelectorObjects.Num();
}
void
UHoudiniInput::SetInputObjectAt(const int32& AtIndex, UObject* InObject)
{
return SetInputObjectAt(Type, AtIndex, InObject);
}
void
UHoudiniInput::SetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex, UObject* InObject)
{
// Start by making sure we have the proper number of input objects
int32 NumIntObject = GetNumberOfInputObjects(InType);
if (NumIntObject <= AtIndex)
{
// We need to resize the array
SetInputObjectsNumber(InType, AtIndex + 1);
}
UObject* CurrentInputObject = GetInputObjectAt(InType, AtIndex);
if (CurrentInputObject == InObject)
{
// Nothing to do
return;
}
UHoudiniInputObject* CurrentInputObjectWrapper = GetHoudiniInputObjectAt(InType, AtIndex);
if (!InObject)
{
// We want to set the input object to null
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!ensure(InputObjectsPtr != nullptr && InputObjectsPtr->IsValidIndex(AtIndex)))
return;
if (CurrentInputObjectWrapper)
{
// TODO: Check this case
// Do not destroy the input object manually! this messes up GC
//CurrentInputObjectWrapper->ConditionalBeginDestroy();
MarkDataUploadNeeded(true);
}
(*InputObjectsPtr)[AtIndex] = nullptr;
return;
}
// Get the type of the previous and new input objects
EHoudiniInputObjectType NewObjectType = InObject ? UHoudiniInputObject::GetInputObjectTypeFromObject(InObject) : EHoudiniInputObjectType::Invalid;
EHoudiniInputObjectType CurrentObjectType = CurrentInputObjectWrapper ? CurrentInputObjectWrapper->Type : EHoudiniInputObjectType::Invalid;
// See if we can reuse the existing InputObject
if (CurrentObjectType == NewObjectType && NewObjectType != EHoudiniInputObjectType::Invalid)
{
// The InputObjectTypes match, we can just update the existing object
CurrentInputObjectWrapper->Update(InObject);
CurrentInputObjectWrapper->MarkChanged(true);
return;
}
// Destroy the existing input object
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!ensure(InputObjectsPtr))
return;
UHoudiniInputObject* NewInputObject = UHoudiniInputObject::CreateTypedInputObject(InObject, this, FString::FromInt(AtIndex + 1));
if (!ensure(NewInputObject))
return;
// Mark that input object as changed so we know we need to update it
NewInputObject->MarkChanged(true);
if (CurrentInputObjectWrapper && !CurrentInputObjectWrapper->IsPendingKill())
{
// TODO:
// For some input type, we may have to copy some of the previous object's property before deleting it
// Delete the previous object
CurrentInputObjectWrapper->MarkPendingKill();
(*InputObjectsPtr)[AtIndex] = nullptr;
}
// Update the input object array with the newly created input object
(*InputObjectsPtr)[AtIndex] = NewInputObject;
}
void
UHoudiniInput::SetInputObjectsNumber(const EHoudiniInputType& InType, const int32& InNewCount)
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(InType);
if (!InputObjectsPtr)
return;
if (InputObjectsPtr->Num() == InNewCount)
{
// Nothing to do
return;
}
if (InNewCount > InputObjectsPtr->Num())
{
// Simply add new default InputObjects
InputObjectsPtr->SetNum(InNewCount);
}
else
{
// TODO: Check this case!
// Do not destroy the input object themselves manually,
// destroy the input object's nodes and reduce the array's size
for (int32 InObjIdx = InputObjectsPtr->Num() - 1; InObjIdx >= InNewCount; InObjIdx--)
{
UHoudiniInputObject* CurrentInputObject = (*InputObjectsPtr)[InObjIdx];
if (!CurrentInputObject || CurrentInputObject->IsPendingKill())
continue;
if (bCanDeleteHoudiniNodes)
CurrentInputObject->InvalidateData();
/*/
//FHoudiniInputTranslator::DestroyInput(Inputs[InputIdx]);
CurrentObject->ConditionalBeginDestroy();
(*InputObjectsPtr)[InObjIdx] = nullptr;
*/
}
// Decrease the input object array size
InputObjectsPtr->SetNum(InNewCount);
}
// Also delete the input's merge node when all the input objects are deleted.
if (InNewCount == 0 && InputNodeId >= 0)
{
if (bCanDeleteHoudiniNodes)
FHoudiniEngineRuntime::Get().MarkNodeIdAsPendingDelete(InputNodeId, true);
InputNodeId = -1;
}
}
void
UHoudiniInput::SetBoundSelectorObjectsNumber(const int32& InNewCount)
{
if (WorldInputBoundSelectorObjects.Num() == InNewCount)
{
// Nothing to do
return;
}
if (InNewCount > WorldInputBoundSelectorObjects.Num())
{
// Simply add new default InputObjects
WorldInputBoundSelectorObjects.SetNum(InNewCount);
}
else
{
/*
// TODO: Not Needed?
// Do not destroy the input object themselves manually,
// destroy the input object's nodes and reduce the array's size
for (int32 InObjIdx = WorldInputBoundSelectorObjects.Num() - 1; InObjIdx >= InNewCount; InObjIdx--)
{
UHoudiniInputObject* CurrentInputObject = WorldInputBoundSelectorObjects[InObjIdx];
if (!CurrentInputObject)
continue;
CurrentInputObject->MarkInputNodesForDeletion();
}
*/
// Decrease the input object array size
WorldInputBoundSelectorObjects.SetNum(InNewCount);
}
}
void
UHoudiniInput::SetBoundSelectorObjectAt(const int32& AtIndex, AActor* InActor)
{
// Start by making sure we have the proper number of objects
int32 NumIntObject = GetNumberOfBoundSelectorObjects();
if (NumIntObject <= AtIndex)
{
// We need to resize the array
SetBoundSelectorObjectsNumber(AtIndex + 1);
}
AActor* CurrentActor = GetBoundSelectorObjectAt(AtIndex);
if (CurrentActor == InActor)
{
// Nothing to do
return;
}
// Update the array with the new object
WorldInputBoundSelectorObjects[AtIndex] = InActor;
}
// Helper function indicating what classes are supported by an input type
TArray<const UClass*>
UHoudiniInput::GetAllowedClasses(const EHoudiniInputType& InInputType)
{
TArray<const UClass*> AllowedClasses;
switch (InInputType)
{
case EHoudiniInputType::Geometry:
AllowedClasses.Add(UStaticMesh::StaticClass());
AllowedClasses.Add(USkeletalMesh::StaticClass());
AllowedClasses.Add(UBlueprint::StaticClass());
AllowedClasses.Add(UDataTable::StaticClass());
AllowedClasses.Add(UFoliageType_InstancedStaticMesh::StaticClass());
break;
case EHoudiniInputType::Curve:
AllowedClasses.Add(USplineComponent::StaticClass());
AllowedClasses.Add(UHoudiniSplineComponent::StaticClass());
break;
case EHoudiniInputType::Asset:
AllowedClasses.Add(UHoudiniAssetComponent::StaticClass());
break;
case EHoudiniInputType::Landscape:
AllowedClasses.Add(ALandscapeProxy::StaticClass());
break;
case EHoudiniInputType::World:
AllowedClasses.Add(AActor::StaticClass());
break;
case EHoudiniInputType::Skeletal:
AllowedClasses.Add(USkeletalMesh::StaticClass());
break;
default:
break;
}
return AllowedClasses;
}
// Helper function indicating if an object is supported by an input type
bool
UHoudiniInput::IsObjectAcceptable(const EHoudiniInputType& InInputType, const UObject* InObject)
{
TArray<const UClass*> AllowedClasses = GetAllowedClasses(InInputType);
for (auto CurClass : AllowedClasses)
{
if (InObject->IsA(CurClass))
return true;
}
return false;
}
bool
UHoudiniInput::IsDataUploadNeeded()
{
if (bDataUploadNeeded)
return true;
return HasChanged();
}
// Indicates if this input has changed and should be updated
bool
UHoudiniInput::HasChanged()
{
if (bHasChanged)
return true;
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
if (!ensure(InputObjectsPtr))
return false;
for (auto CurrentInputObject : (*InputObjectsPtr))
{
if (CurrentInputObject && CurrentInputObject->HasChanged())
return true;
}
return false;
}
bool
UHoudiniInput::IsTransformUploadNeeded()
{
TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
if (!ensure(InputObjectsPtr))
return false;
for (auto CurrentInputObject : (*InputObjectsPtr))
{
if (CurrentInputObject && CurrentInputObject->HasTransformChanged())
return true;
}
return false;
}
// Indicates if this input needs to trigger an update
bool
UHoudiniInput::NeedsToTriggerUpdate()
{
if (bNeedsToTriggerUpdate)
return true;
const TArray<UHoudiniInputObject*>* InputObjectsPtr = GetHoudiniInputObjectArray(Type);
if (!ensure(InputObjectsPtr))
return false;
for (auto CurrentInputObject : (*InputObjectsPtr))
{
if (CurrentInputObject && CurrentInputObject->NeedsToTriggerUpdate())
return true;
}
return false;
}
FString
UHoudiniInput::GetNodeBaseName() const
{
UHoudiniAssetComponent* HAC = Cast<UHoudiniAssetComponent>(GetOuter());
FString NodeBaseName = HAC ? HAC->GetDisplayName() : TEXT("HoudiniAsset");
// Unfortunately CreateInputNode always prefix with input_...
if (IsObjectPathParameter())
NodeBaseName += TEXT("_") + GetName();
else
NodeBaseName += TEXT("_input") + FString::FromInt(GetInputIndex());
return NodeBaseName;
}
void
UHoudiniInput::OnTransformUIExpand(const int32& AtIndex)
{
#if WITH_EDITORONLY_DATA
if (TransformUIExpanded.IsValidIndex(AtIndex))
{
TransformUIExpanded[AtIndex] = !TransformUIExpanded[AtIndex];
}
else
{
// We need to append values to the expanded array
for (int32 Index = TransformUIExpanded.Num(); Index <= AtIndex; Index++)
{
TransformUIExpanded.Add(Index == AtIndex ? true : false);
}
}
#endif
}
bool
UHoudiniInput::IsTransformUIExpanded(const int32& AtIndex)
{
#if WITH_EDITORONLY_DATA
return TransformUIExpanded.IsValidIndex(AtIndex) ? TransformUIExpanded[AtIndex] : false;
#else
return false;
#endif
};
FTransform*
UHoudiniInput::GetTransformOffset(const int32& AtIndex)
{
UHoudiniInputObject* InObject = GetHoudiniInputObjectAt(AtIndex);
if (InObject)
return &(InObject->Transform);
return nullptr;
}
const FTransform
UHoudiniInput::GetTransformOffset(const int32& AtIndex) const
{
const UHoudiniInputObject* InObject = GetHoudiniInputObjectAt(AtIndex);
if (InObject)
return InObject->Transform;
return FTransform::Identity;
}
TOptional<float>
UHoudiniInput::GetPositionOffsetX(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetLocation().X;
}
TOptional<float>
UHoudiniInput::GetPositionOffsetY(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetLocation().Y;
}
TOptional<float>
UHoudiniInput::GetPositionOffsetZ(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetLocation().Z;
}
TOptional<float>
UHoudiniInput::GetRotationOffsetRoll(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).Rotator().Roll;
}
TOptional<float>
UHoudiniInput::GetRotationOffsetPitch(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).Rotator().Pitch;
}
TOptional<float>
UHoudiniInput::GetRotationOffsetYaw(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).Rotator().Yaw;
}
TOptional<float>
UHoudiniInput::GetScaleOffsetX(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetScale3D().X;
}
TOptional<float>
UHoudiniInput::GetScaleOffsetY(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetScale3D().Y;
}
TOptional<float>
UHoudiniInput::GetScaleOffsetZ(int32 AtIndex) const
{
return GetTransformOffset(AtIndex).GetScale3D().Z;
}
bool
UHoudiniInput::SetTransformOffsetAt(const float& Value, const int32& AtIndex, const int32& PosRotScaleIndex, const int32& XYZIndex)
{
FTransform* Transform = GetTransformOffset(AtIndex);
if (!Transform)
return false;
if (PosRotScaleIndex == 0)
{
FVector Position = Transform->GetLocation();
if (Position[XYZIndex] == Value)
return false;
Position[XYZIndex] = Value;
Transform->SetLocation(Position);
}
else if (PosRotScaleIndex == 1)
{
FRotator Rotator = Transform->Rotator();
switch (XYZIndex)
{
case 0:
{
if (Rotator.Roll == Value)
return false;
Rotator.Roll = Value;
break;
}
case 1:
{
if (Rotator.Pitch == Value)
return false;
Rotator.Pitch = Value;
break;
}
case 2:
{
if (Rotator.Yaw == Value)
return false;
Rotator.Yaw = Value;
break;
}
}
Transform->SetRotation(Rotator.Quaternion());
}
else if (PosRotScaleIndex == 2)
{
FVector Scale = Transform->GetScale3D();
if (Scale[XYZIndex] == Value)
return false;
Scale[XYZIndex] = Value;
Transform->SetScale3D(Scale);
}
MarkChanged(true);
bStaticMeshChanged = true;
return true;
}
void
UHoudiniInput::SetAddRotAndScaleAttributes(const bool& InValue)
{
if (bAddRotAndScaleAttributesOnCurves == InValue)
return;
bAddRotAndScaleAttributesOnCurves = InValue;
// Mark all input obj as changed
MarkAllInputObjectsChanged(true);
}
#if WITH_EDITOR
FText
UHoudiniInput::GetCurrentSelectionText() const
{
FText CurrentSelectionText;
switch (Type)
{
case EHoudiniInputType::Landscape :
{
if (LandscapeInputObjects.Num() > 0)
{
UHoudiniInputObject* InputObject = LandscapeInputObjects[0];
UHoudiniInputLandscape* InputLandscape = Cast<UHoudiniInputLandscape>(InputObject);
if (!InputLandscape || InputLandscape->IsPendingKill())
return CurrentSelectionText;
ALandscapeProxy* LandscapeProxy = InputLandscape->GetLandscapeProxy();
if (!LandscapeProxy || LandscapeProxy->IsPendingKill())
return CurrentSelectionText;
CurrentSelectionText = FText::FromString(LandscapeProxy->GetActorLabel());
}
}
break;
case EHoudiniInputType::Asset :
{
if (AssetInputObjects.Num() > 0)
{
UHoudiniInputObject* InputObject = AssetInputObjects[0];
UHoudiniInputHoudiniAsset* HoudiniAssetInput = Cast<UHoudiniInputHoudiniAsset>(InputObject);
if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill())
return CurrentSelectionText;
UHoudiniAssetComponent* HAC = HoudiniAssetInput->GetHoudiniAssetComponent();
if (!HAC || HAC->IsPendingKill())
return CurrentSelectionText;
UHoudiniAsset* HoudiniAsset = HAC->GetHoudiniAsset();
if (!HoudiniAsset || HoudiniAsset->IsPendingKill())
return CurrentSelectionText;
CurrentSelectionText = FText::FromString(HoudiniAsset->GetName());
}
}
break;
default:
break;
}
return CurrentSelectionText;
}
#endif
bool
UHoudiniInput::HasLandscapeExportTypeChanged () const
{
if (Type != EHoudiniInputType::Landscape)
return false;
return bLandscapeHasExportTypeChanged;
}
void
UHoudiniInput::SetHasLandscapeExportTypeChanged(const bool InChanged)
{
if (Type != EHoudiniInputType::Landscape)
return;
bLandscapeHasExportTypeChanged = InChanged;
}
bool
UHoudiniInput::GetUpdateInputLandscape() const
{
if (Type != EHoudiniInputType::Landscape)
return false;
return bUpdateInputLandscape;
}
void
UHoudiniInput::SetUpdateInputLandscape(const bool bInUpdateInputLandcape)
{
if (Type != EHoudiniInputType::Landscape)
return;
bUpdateInputLandscape = bInUpdateInputLandcape;
}
bool
UHoudiniInput::UpdateWorldSelectionFromBoundSelectors()
{
// Dont do anything if we're not a World Input
if (Type != EHoudiniInputType::World)
return false;
// Build an array of the current selection's bounds
TArray<FBox> AllBBox;
for (auto CurrentActor : WorldInputBoundSelectorObjects)
{
if (!CurrentActor || CurrentActor->IsPendingKill())
continue;
AllBBox.Add(CurrentActor->GetComponentsBoundingBox(true, true));
}
//
// Select all actors in our bound selectors bounding boxes
//
// Get our parent component/actor
USceneComponent* ParentComponent = Cast<USceneComponent>(GetOuter());
AActor* ParentActor = ParentComponent ? ParentComponent->GetOwner() : nullptr;
//UWorld* editorWorld = GEditor->GetEditorWorldContext().World();
UWorld* MyWorld = GetWorld();
TArray<AActor*> NewSelectedActors;
for (TActorIterator<AActor> ActorItr(MyWorld); ActorItr; ++ActorItr)
{
AActor *CurrentActor = *ActorItr;
if (!CurrentActor || CurrentActor->IsPendingKill())
continue;
// Check that actor is currently not selected
if (WorldInputBoundSelectorObjects.Contains(CurrentActor))
continue;
// Ignore the SkySpheres?
FString ClassName = CurrentActor->GetClass() ? CurrentActor->GetClass()->GetName() : FString();
if (ClassName.Contains("BP_Sky_Sphere"))
continue;
// Don't allow selection of ourselves. Bad things happen if we do.
if (ParentActor && (CurrentActor == ParentActor))
continue;
// For BrushActors, both the actor and its brush must be valid
ABrush* BrushActor = Cast<ABrush>(CurrentActor);
if (BrushActor)
{
if (!BrushActor->Brush || BrushActor->Brush->IsPendingKill())
continue;
}
FBox ActorBounds = CurrentActor->GetComponentsBoundingBox(true);
for (auto InBounds : AllBBox)
{
// Check if both actor's bounds intersects
if (!ActorBounds.Intersect(InBounds))
continue;
NewSelectedActors.Add(CurrentActor);
break;
}
}
return UpdateWorldSelection(NewSelectedActors);
}
bool
UHoudiniInput::UpdateWorldSelection(const TArray<AActor*>& InNewSelection)
{
TArray<AActor*> NewSelectedActors = InNewSelection;
// Update our current selection with the new one
// Keep actors that are still selected, remove the one that are not selected anymore
bool bHasSelectionChanged = false;
for (int32 Idx = WorldInputObjects.Num() - 1; Idx >= 0; Idx--)
{
UHoudiniInputActor* InputActor = Cast<UHoudiniInputActor>(WorldInputObjects[Idx]);
AActor* CurActor = InputActor ? InputActor->GetActor() : nullptr;
if (CurActor && NewSelectedActors.Contains(CurActor))
{
// The actor is still selected, remove it from the new selection
NewSelectedActors.Remove(CurActor);
}
else
{
// That actor is no longer selected, remove itr from our current selection
DeleteInputObjectAt(EHoudiniInputType::World, Idx);
bHasSelectionChanged = true;
}
}
if (NewSelectedActors.Num() > 0)
bHasSelectionChanged = true;
// Then add the newly selected Actors
int32 InputObjectIdx = GetNumberOfInputObjects(EHoudiniInputType::World);
int32 NewInputObjectNumber = InputObjectIdx + NewSelectedActors.Num();
SetInputObjectsNumber(EHoudiniInputType::World, NewInputObjectNumber);
for (const auto& CurActor : NewSelectedActors)
{
// Update the input objects from the valid selected actors array
SetInputObjectAt(InputObjectIdx++, CurActor);
}
MarkChanged(bHasSelectionChanged);
return bHasSelectionChanged;
}
bool
UHoudiniInput::ContainsInputObject(const UObject* InObject, const EHoudiniInputType& InType) const
{
if (!InObject || InObject->IsPendingKill())
return false;
// Returns true if the object is one of our input object for the given type
const TArray<UHoudiniInputObject*>* ObjectArray = GetHoudiniInputObjectArray(InType);
if (!ObjectArray)
return false;
for (auto& CurrentInputObject : (*ObjectArray))
{
if (!CurrentInputObject || CurrentInputObject->IsPendingKill())
continue;
if (CurrentInputObject->GetObject() == InObject)
return true;
}
return false;
}
void UHoudiniInput::ForAllHoudiniInputObjects(TFunctionRef<void(UHoudiniInputObject*)> Fn) const
{
for(UHoudiniInputObject* InputObject : GeometryInputObjects)
{
Fn(InputObject);
}
for(UHoudiniInputObject* InputObject : AssetInputObjects)
{
Fn(InputObject);
}
for(UHoudiniInputObject* InputObject : CurveInputObjects)
{
Fn(InputObject);
}
for(UHoudiniInputObject* InputObject : LandscapeInputObjects)
{
Fn(InputObject);
}
for(UHoudiniInputObject* InputObject : WorldInputObjects)
{
Fn(InputObject);
}
for(UHoudiniInputObject* InputObject : SkeletalInputObjects)
{
Fn(InputObject);
}
}
TArray<const TArray<UHoudiniInputObject*>*> UHoudiniInput::GetAllObjectArrays() const
{
return { &GeometryInputObjects, &CurveInputObjects, &WorldInputObjects, &SkeletalInputObjects, &LandscapeInputObjects, &AssetInputObjects };
}
TArray<TArray<UHoudiniInputObject*>*> UHoudiniInput::GetAllObjectArrays()
{
return { &GeometryInputObjects, &CurveInputObjects, &WorldInputObjects, &SkeletalInputObjects, &LandscapeInputObjects, &AssetInputObjects };
}
void UHoudiniInput::ForAllHoudiniInputObjectArrays(TFunctionRef<void(const TArray<UHoudiniInputObject*>&)> Fn) const
{
TArray<const TArray<UHoudiniInputObject*>*> ObjectArrays = GetAllObjectArrays();
for (const TArray<UHoudiniInputObject*>* ObjectArrayPtr : ObjectArrays)
{
if (!ObjectArrayPtr)
continue;
Fn(*ObjectArrayPtr);
}
}
void UHoudiniInput::ForAllHoudiniInputObjectArrays(TFunctionRef<void(TArray<UHoudiniInputObject*>&)> Fn)
{
TArray<TArray<UHoudiniInputObject*>*> ObjectArrays = GetAllObjectArrays();
for (TArray<UHoudiniInputObject*>* ObjectArrayPtr : ObjectArrays)
{
if (!ObjectArrayPtr)
continue;
Fn(*ObjectArrayPtr);
}
}
void UHoudiniInput::GetAllHoudiniInputObjects(TArray<UHoudiniInputObject*>& OutObjects) const
{
OutObjects.Empty();
auto AddInputObject = [&OutObjects](UHoudiniInputObject* InputObject)
{
if (InputObject)
OutObjects.Add(InputObject);
};
ForAllHoudiniInputObjects(AddInputObject);
}
void UHoudiniInput::ForAllHoudiniInputSceneComponents(TFunctionRef<void(UHoudiniInputSceneComponent*)> Fn) const
{
auto ProcessSceneComponent = [Fn](UHoudiniInputObject* InputObject)
{
if (!InputObject)
return;
UHoudiniInputSceneComponent* SceneComponentInput = Cast<UHoudiniInputSceneComponent>(InputObject);
if (!SceneComponentInput)
return;
Fn(SceneComponentInput);
};
ForAllHoudiniInputObjects(ProcessSceneComponent);
}
void UHoudiniInput::GetAllHoudiniInputSceneComponents(TArray<UHoudiniInputSceneComponent*>& OutObjects) const
{
OutObjects.Empty();
auto AddSceneComponent = [&OutObjects](UHoudiniInputObject* InputObject)
{
if (!InputObject)
return;
UHoudiniInputSceneComponent* SceneComponentInput = Cast<UHoudiniInputSceneComponent>(InputObject);
if (!SceneComponentInput)
return;
OutObjects.Add(SceneComponentInput);
};
ForAllHoudiniInputObjects(AddSceneComponent);
}
void UHoudiniInput::GetAllHoudiniInputSplineComponents(TArray<UHoudiniInputHoudiniSplineComponent*>& OutObjects) const
{
OutObjects.Empty();
auto AddSceneComponent = [&OutObjects](UHoudiniInputObject* InputObject)
{
if (!InputObject)
return;
UHoudiniInputHoudiniSplineComponent* SceneComponentInput = Cast<UHoudiniInputHoudiniSplineComponent>(InputObject);
if (!SceneComponentInput)
return;
OutObjects.Add(SceneComponentInput);
};
ForAllHoudiniInputObjects(AddSceneComponent);
}
void UHoudiniInput::RemoveHoudiniInputObject(UHoudiniInputObject* InInputObject)
{
if (!InInputObject)
return;
ForAllHoudiniInputObjectArrays([InInputObject](TArray<UHoudiniInputObject*>& ObjectArray) {
ObjectArray.Remove(InInputObject);
});
return;
}
Reference in New Issue View Git Blame Copy Permalink