Andron666
6701 lines
242 KiB
C++
6701 lines
242 KiB
C++
/*
|
|
* Copyright (c) <2017> Side Effects Software Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "HoudiniAssetComponent.h"
|
|
|
|
#include "HoudiniApi.h"
|
|
#include "HoudiniEngineRuntimePrivatePCH.h"
|
|
#include "HoudiniEngineUtils.h"
|
|
#include "HoudiniEngineBakeUtils.h"
|
|
#include "HoudiniEngineMaterialUtils.h"
|
|
#include "HoudiniEngine.h"
|
|
#include "HoudiniAsset.h"
|
|
#include "HoudiniAssetActor.h"
|
|
#include "HoudiniAssetComponentMaterials.h"
|
|
#include "HoudiniAssetInstanceInput.h"
|
|
#include "HoudiniAssetInput.h"
|
|
#include "HoudiniAssetParameter.h"
|
|
#include "HoudiniAssetParameterButton.h"
|
|
#include "HoudiniAssetParameterChoice.h"
|
|
#include "HoudiniAssetParameterColor.h"
|
|
#include "HoudiniAssetParameterFloat.h"
|
|
#include "HoudiniAssetParameterFolder.h"
|
|
#include "HoudiniAssetParameterFolderList.h"
|
|
#include "HoudiniAssetParameterInt.h"
|
|
#include "HoudiniAssetParameterLabel.h"
|
|
#include "HoudiniAssetParameterMultiparm.h"
|
|
#include "HoudiniAssetParameterSeparator.h"
|
|
#include "HoudiniAssetParameterString.h"
|
|
#include "HoudiniAssetParameterFile.h"
|
|
#include "HoudiniAssetParameterToggle.h"
|
|
#include "HoudiniAssetParameterRamp.h"
|
|
#include "HoudiniHandleComponent.h"
|
|
#include "HoudiniSplineComponent.h"
|
|
#include "HoudiniEngineTask.h"
|
|
#include "HoudiniEngineTaskInfo.h"
|
|
#include "HoudiniAssetComponentMaterials.h"
|
|
#include "HoudiniPluginSerializationVersion.h"
|
|
#include "HoudiniEngineString.h"
|
|
#include "HoudiniAssetInstanceInputField.h"
|
|
#include "HoudiniInstancedActorComponent.h"
|
|
#include "HoudiniMeshSplitInstancerComponent.h"
|
|
#include "HoudiniParamUtils.h"
|
|
#include "HoudiniLandscapeUtils.h"
|
|
#include "Components/InstancedStaticMeshComponent.h"
|
|
#include "Landscape.h"
|
|
#include "Logging/MessageLog.h"
|
|
#include "Misc/UObjectToken.h"
|
|
#include "LandscapeInfo.h"
|
|
#include "LandscapeLayerInfoObject.h"
|
|
#include "Materials/MaterialInstance.h"
|
|
#include "Engine/StaticMeshSocket.h"
|
|
#include "HoudiniCookHandler.h"
|
|
#include "UObject/MetaData.h"
|
|
#if WITH_EDITOR
|
|
#include "UnrealEdGlobals.h"
|
|
#include "Editor/UnrealEdEngine.h"
|
|
#include "Editor.h"
|
|
#include "EdMode.h"
|
|
#include "EditorModeManager.h"
|
|
#include "EditorModes.h"
|
|
#include "Editor/PropertyEditor/Public/IDetailsView.h"
|
|
#include "Editor/UnrealEd/Private/GeomFitUtils.h"
|
|
#include "Misc/MessageDialog.h"
|
|
#include "Widgets/Input/SButton.h"
|
|
#include "Widgets/Notifications/SNotificationList.h"
|
|
#include "Framework/Notifications/NotificationManager.h"
|
|
#include "Editor/UnrealEd/Public/BusyCursor.h"
|
|
#include "Editor/UnrealEd/Public/AssetThumbnail.h"
|
|
#include "Editor/PropertyEditor/Public/PropertyCustomizationHelpers.h"
|
|
#include "Editor/PropertyEditor/Private/PropertyNode.h"
|
|
#include "Editor/PropertyEditor/Private/SDetailsViewBase.h"
|
|
#include "StaticMeshResources.h"
|
|
#include "Framework/Application/SlateApplication.h"
|
|
#include "NavigationSystem.h"
|
|
#include "FileHelpers.h"
|
|
#endif
|
|
#include "Internationalization/Internationalization.h"
|
|
|
|
|
|
#define LOCTEXT_NAMESPACE HOUDINI_LOCTEXT_NAMESPACE
|
|
|
|
#if WITH_EDITOR
|
|
|
|
/** Slate widget used to pick an asset to instantiate from an HDA with multiple assets inside. **/
|
|
class SAssetSelectionWidget : public SCompoundWidget
|
|
{
|
|
public:
|
|
SLATE_BEGIN_ARGS( SAssetSelectionWidget )
|
|
: _WidgetWindow(), _AvailableAssetNames()
|
|
{}
|
|
|
|
SLATE_ARGUMENT(TSharedPtr<SWindow>, WidgetWindow )
|
|
SLATE_ARGUMENT( TArray< HAPI_StringHandle >, AvailableAssetNames )
|
|
SLATE_END_ARGS()
|
|
|
|
public:
|
|
|
|
SAssetSelectionWidget();
|
|
|
|
public:
|
|
|
|
/** Widget construct. **/
|
|
void Construct( const FArguments & InArgs );
|
|
|
|
/** Return true if cancel button has been pressed. **/
|
|
bool IsCancelled() const;
|
|
|
|
/** Return true if constructed widget is valid. **/
|
|
bool IsValidWidget() const;
|
|
|
|
/** Return selected asset name. **/
|
|
int32 GetSelectedAssetName() const;
|
|
|
|
protected:
|
|
|
|
/** Called when Ok button is pressed. **/
|
|
FReply OnButtonOk();
|
|
|
|
/** Called when Cancel button is pressed. **/
|
|
FReply OnButtonCancel();
|
|
|
|
/** Called when user picks an asset. **/
|
|
FReply OnButtonAssetPick( int32 AssetName );
|
|
|
|
protected:
|
|
|
|
/** Parent widget window. **/
|
|
TWeakPtr< SWindow > WidgetWindow;
|
|
|
|
/** List of available Houdini Engine asset names. **/
|
|
TArray< HAPI_StringHandle > AvailableAssetNames;
|
|
|
|
/** Selected asset name. **/
|
|
int32 SelectedAssetName;
|
|
|
|
/** Is set to true if constructed widget is valid. **/
|
|
bool bIsValidWidget;
|
|
|
|
/** Is set to true if selection process has been cancelled. **/
|
|
bool bIsCancelled;
|
|
};
|
|
|
|
SAssetSelectionWidget::SAssetSelectionWidget()
|
|
: SelectedAssetName( -1 )
|
|
, bIsValidWidget( false )
|
|
, bIsCancelled( false )
|
|
{}
|
|
|
|
bool
|
|
SAssetSelectionWidget::IsCancelled() const
|
|
{
|
|
return bIsCancelled;
|
|
}
|
|
|
|
bool
|
|
SAssetSelectionWidget::IsValidWidget() const
|
|
{
|
|
return bIsValidWidget;
|
|
}
|
|
|
|
int32
|
|
SAssetSelectionWidget::GetSelectedAssetName() const
|
|
{
|
|
return SelectedAssetName;
|
|
}
|
|
|
|
void
|
|
SAssetSelectionWidget::Construct( const FArguments & InArgs )
|
|
{
|
|
WidgetWindow = InArgs._WidgetWindow;
|
|
AvailableAssetNames = InArgs._AvailableAssetNames;
|
|
|
|
TSharedRef< SVerticalBox > VerticalBox = SNew( SVerticalBox );
|
|
|
|
this->ChildSlot
|
|
[
|
|
SNew( SBorder )
|
|
.BorderImage( FEditorStyle::GetBrush( TEXT( "Menu.Background" ) ) )
|
|
.Content()
|
|
[
|
|
SNew( SHorizontalBox )
|
|
+SHorizontalBox::Slot()
|
|
.HAlign( HAlign_Center )
|
|
.VAlign( VAlign_Center )
|
|
[
|
|
SAssignNew( VerticalBox, SVerticalBox )
|
|
]
|
|
]
|
|
];
|
|
|
|
for ( int32 AssetNameIdx = 0, AssetNameNum = AvailableAssetNames.Num(); AssetNameIdx < AssetNameNum; ++AssetNameIdx )
|
|
{
|
|
FString AssetNameString = TEXT( "" );
|
|
HAPI_StringHandle AssetName = AvailableAssetNames[ AssetNameIdx ];
|
|
|
|
FHoudiniEngineString HoudiniEngineString( AssetName );
|
|
if ( HoudiniEngineString.ToFString( AssetNameString ) )
|
|
{
|
|
bIsValidWidget = true;
|
|
FText AssetNameStringText = FText::FromString( AssetNameString );
|
|
|
|
VerticalBox->AddSlot()
|
|
.HAlign( HAlign_Center )
|
|
.AutoHeight()
|
|
[
|
|
SNew( SHorizontalBox )
|
|
+SHorizontalBox::Slot()
|
|
.HAlign( HAlign_Center )
|
|
.VAlign( VAlign_Center )
|
|
.Padding( 2.0f, 4.0f )
|
|
[
|
|
SNew( SButton )
|
|
.VAlign( VAlign_Center )
|
|
.HAlign( HAlign_Center )
|
|
.OnClicked( this, &SAssetSelectionWidget::OnButtonAssetPick, AssetName )
|
|
.Text( AssetNameStringText )
|
|
.ToolTipText( AssetNameStringText )
|
|
]
|
|
];
|
|
}
|
|
}
|
|
}
|
|
|
|
FReply
|
|
SAssetSelectionWidget::OnButtonAssetPick( int32 AssetName )
|
|
{
|
|
SelectedAssetName = AssetName;
|
|
|
|
if (TSharedPtr<SWindow> WindowPtr = WidgetWindow.Pin())
|
|
{
|
|
WindowPtr->HideWindow();
|
|
WindowPtr->RequestDestroyWindow();
|
|
}
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
FReply
|
|
SAssetSelectionWidget::OnButtonOk()
|
|
{
|
|
if (TSharedPtr<SWindow> WindowPtr = WidgetWindow.Pin())
|
|
{
|
|
WindowPtr->HideWindow();
|
|
WindowPtr->RequestDestroyWindow();
|
|
}
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
FReply
|
|
SAssetSelectionWidget::OnButtonCancel()
|
|
{
|
|
bIsCancelled = true;
|
|
|
|
if (TSharedPtr<SWindow> WindowPtr = WidgetWindow.Pin())
|
|
{
|
|
WindowPtr->HideWindow();
|
|
WindowPtr->RequestDestroyWindow();
|
|
}
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// Macro to update given property on all components.
|
|
#define HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( COMPONENT_CLASS, PROPERTY ) \
|
|
do \
|
|
{ \
|
|
TArray< UActorComponent * > ReregisterComponents; \
|
|
TArray< USceneComponent * > LocalAttachChildren;\
|
|
GetChildrenComponents(true, LocalAttachChildren); \
|
|
for ( TArray< USceneComponent * >::TConstIterator Iter( LocalAttachChildren ); Iter; ++Iter ) \
|
|
{ \
|
|
COMPONENT_CLASS * Component = Cast< COMPONENT_CLASS >( *Iter ); \
|
|
if ( Component ) \
|
|
{ \
|
|
Component->PROPERTY = PROPERTY; \
|
|
ReregisterComponents.Add( Component ); \
|
|
} \
|
|
} \
|
|
\
|
|
if ( ReregisterComponents.Num() > 0 ) \
|
|
{ \
|
|
FMultiComponentReregisterContext MultiComponentReregisterContext( ReregisterComponents ); \
|
|
} \
|
|
} \
|
|
while( 0 )
|
|
|
|
bool
|
|
UHoudiniAssetComponent::bDisplayEngineNotInitialized = true;
|
|
|
|
bool
|
|
UHoudiniAssetComponent::bDisplayEngineHapiVersionMismatch = true;
|
|
|
|
UHoudiniAssetComponent::UHoudiniAssetComponent( const FObjectInitializer & ObjectInitializer )
|
|
: Super( ObjectInitializer )
|
|
{
|
|
HoudiniAsset = nullptr;
|
|
bManualRecookRequested = false;
|
|
PreviousTransactionHoudiniAsset = nullptr;
|
|
HoudiniAssetComponentMaterials = nullptr;
|
|
#if WITH_EDITOR
|
|
CopiedHoudiniComponent = nullptr;
|
|
#endif
|
|
AssetId = -1;
|
|
GeneratedGeometryScaleFactor = HAPI_UNREAL_SCALE_FACTOR_POSITION;
|
|
TransformScaleFactor = HAPI_UNREAL_SCALE_FACTOR_TRANSLATION;
|
|
ImportAxis = HRSAI_Unreal;
|
|
HapiNotificationStarted = 0.0;
|
|
AssetCookCount = 0;
|
|
HoudiniAssetComponentTransientFlagsPacked = 0u;
|
|
|
|
/** Component flags. **/
|
|
HoudiniAssetComponentFlagsPacked = 0u;
|
|
bEnableCooking = true;
|
|
bUploadTransformsToHoudiniEngine = true;
|
|
bUseHoudiniMaterials = true;
|
|
bCookingTriggersDownstreamCooks = true;
|
|
|
|
UObject * Object = ObjectInitializer.GetObj();
|
|
UObject * ObjectOuter = Object->GetOuter();
|
|
|
|
if ( ObjectOuter->IsA( AHoudiniAssetActor::StaticClass() ) )
|
|
bIsNativeComponent = true;
|
|
|
|
// Set scaling information.
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
if ( HoudiniRuntimeSettings )
|
|
{
|
|
GeneratedGeometryScaleFactor = HoudiniRuntimeSettings->GeneratedGeometryScaleFactor;
|
|
TransformScaleFactor = HoudiniRuntimeSettings->TransformScaleFactor;
|
|
ImportAxis = HoudiniRuntimeSettings->ImportAxis;
|
|
}
|
|
|
|
// Set component properties.
|
|
Mobility = EComponentMobility::Static;
|
|
PrimaryComponentTick.bCanEverTick = true;
|
|
bTickInEditor = true;
|
|
SetGenerateOverlapEvents(false);
|
|
|
|
// Similar to UMeshComponent.
|
|
CastShadow = true;
|
|
bUseAsOccluder = true;
|
|
bCanEverAffectNavigation = true;
|
|
|
|
// This component requires render update.
|
|
bNeverNeedsRenderUpdate = false;
|
|
|
|
// Initialize static mesh generation parameters.
|
|
bGeneratedDoubleSidedGeometry = false;
|
|
GeneratedPhysMaterial = nullptr;
|
|
DefaultBodyInstance.SetCollisionProfileName("BlockAll");
|
|
GeneratedCollisionTraceFlag = CTF_UseDefault;
|
|
GeneratedLpvBiasMultiplier = 1.0f;
|
|
GeneratedLightMapResolution = 32;
|
|
GeneratedLightMapCoordinateIndex = 1;
|
|
bGeneratedUseMaximumStreamingTexelRatio = false;
|
|
GeneratedStreamingDistanceMultiplier = 1.0f;
|
|
GeneratedDistanceFieldResolutionScale = 0.0f;
|
|
|
|
bNeedToUpdateNavigationSystem = false;
|
|
|
|
// Make an invalid GUID, since we do not have any cooking requests.
|
|
HapiGUID.Invalidate();
|
|
|
|
// Create unique component GUID.
|
|
ComponentGUID = FGuid::NewGuid();
|
|
|
|
bEditorPropertiesNeedFullUpdate = true;
|
|
|
|
bFullyLoaded = false;
|
|
|
|
Bounds = FBox( ForceInitToZero );
|
|
|
|
DefaultPresetBuffer.Empty();
|
|
PresetBuffer.Empty();
|
|
Parameters.Empty();
|
|
ParameterByName.Empty();
|
|
BakeNameOverrides.Empty();
|
|
DownstreamAssetConnections.Empty();
|
|
}
|
|
|
|
UHoudiniAssetComponent::~UHoudiniAssetComponent()
|
|
{}
|
|
|
|
void
|
|
UHoudiniAssetComponent::AddReferencedObjects( UObject * InThis, FReferenceCollector & Collector )
|
|
{
|
|
UHoudiniAssetComponent * HoudiniAssetComponent = Cast< UHoudiniAssetComponent >( InThis );
|
|
|
|
if ( HoudiniAssetComponent && !HoudiniAssetComponent->IsPendingKill() )
|
|
{
|
|
// Add references for all parameters.
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator
|
|
IterParams( HoudiniAssetComponent->Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
|
|
Collector.AddReferencedObject( HoudiniAssetParameter, InThis );
|
|
}
|
|
|
|
// Add references to all inputs.
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator
|
|
IterInputs( HoudiniAssetComponent->Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( HoudiniAssetInput && !HoudiniAssetInput->IsPendingKill() )
|
|
Collector.AddReferencedObject( HoudiniAssetInput, InThis );
|
|
}
|
|
|
|
// Add references to all instance inputs.
|
|
for ( auto& InstanceInput : HoudiniAssetComponent->InstanceInputs)
|
|
{
|
|
if ( !InstanceInput || InstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
Collector.AddReferencedObject( InstanceInput, InThis );
|
|
}
|
|
|
|
// Add references to all handles.
|
|
for ( TMap< FString, UHoudiniHandleComponent * >::TIterator
|
|
IterHandles( HoudiniAssetComponent->HandleComponents ); IterHandles; ++IterHandles )
|
|
{
|
|
UHoudiniHandleComponent * HandleComponent = IterHandles.Value();
|
|
if ( HandleComponent && !HandleComponent->IsPendingKill() )
|
|
Collector.AddReferencedObject( HandleComponent, InThis );
|
|
}
|
|
|
|
// Add references to all static meshes and corresponding geo parts.
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator
|
|
Iter( HoudiniAssetComponent->StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( StaticMesh && StaticMesh->IsValidLowLevel() && !StaticMesh->IsPendingKill() )
|
|
Collector.AddReferencedObject( StaticMesh, InThis );
|
|
}
|
|
|
|
// Add references to all static meshes and their static mesh components.
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TIterator
|
|
Iter( HoudiniAssetComponent->StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Key();
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
|
|
if (!StaticMesh || !StaticMeshComponent->IsValidLowLevel() || StaticMesh->IsPendingKill())
|
|
continue;
|
|
|
|
Collector.AddReferencedObject( StaticMesh, InThis );
|
|
|
|
if (!StaticMeshComponent || !StaticMeshComponent->IsValidLowLevel() || StaticMeshComponent->IsPendingKill())
|
|
continue;
|
|
|
|
Collector.AddReferencedObject( StaticMeshComponent, InThis );
|
|
}
|
|
|
|
// Add references to all temporary cooked mesh packages
|
|
for (TMap< FHoudiniGeoPartObject, TWeakObjectPtr<class UPackage> > ::TIterator
|
|
Iter(HoudiniAssetComponent->CookedTemporaryStaticMeshPackages); Iter; ++Iter)
|
|
{
|
|
UPackage * MeshPackage = Iter.Value().Get();
|
|
if (MeshPackage && !MeshPackage->IsPendingKill())
|
|
Collector.AddReferencedObject(MeshPackage, InThis);
|
|
}
|
|
|
|
// Add references to all spline components.
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TIterator
|
|
Iter( HoudiniAssetComponent->SplineComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniSplineComponent * HoudiniSplineComponent = Iter.Value();
|
|
if ( !HoudiniSplineComponent || !HoudiniSplineComponent->IsValidLowLevel() || HoudiniSplineComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
Collector.AddReferencedObject( HoudiniSplineComponent, InThis );
|
|
}
|
|
|
|
// Add references to all Landscape
|
|
for ( TMap< FHoudiniGeoPartObject, TWeakObjectPtr <ALandscapeProxy> >::TIterator
|
|
Iter( HoudiniAssetComponent->LandscapeComponents ); Iter; ++Iter)
|
|
{
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value().Get();
|
|
if ( !HoudiniLandscape || HoudiniLandscape->IsPendingKill() || !HoudiniLandscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
Collector.AddReferencedObject( HoudiniLandscape, InThis );
|
|
}
|
|
|
|
// Add references to all generated Landscape layer objects
|
|
for ( TMap< TWeakObjectPtr<class UPackage>, FHoudiniGeoPartObject > ::TIterator
|
|
Iter( HoudiniAssetComponent->CookedTemporaryLandscapeLayers ); Iter; ++Iter )
|
|
{
|
|
UPackage * LayerPackage = Iter.Key().Get();
|
|
if ( LayerPackage && !LayerPackage->IsPendingKill() )
|
|
Collector.AddReferencedObject( LayerPackage, InThis );
|
|
}
|
|
|
|
// Retrieve asset associated with this component and add reference to it.
|
|
// Also do not add reference if it is being referenced by preview component.
|
|
UHoudiniAsset * HoudiniAsset = HoudiniAssetComponent->GetHoudiniAsset();
|
|
if ( HoudiniAsset && !HoudiniAsset->IsPendingKill() && !HoudiniAssetComponent->bIsPreviewComponent )
|
|
{
|
|
// Manually add a reference to Houdini asset from this component.
|
|
Collector.AddReferencedObject( HoudiniAsset, InThis );
|
|
}
|
|
|
|
// Add reference to material replacements.
|
|
UHoudiniAssetComponentMaterials* HoudiniAssetComponentMaterials = HoudiniAssetComponent->HoudiniAssetComponentMaterials;
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
Collector.AddReferencedObject( HoudiniAssetComponent->HoudiniAssetComponentMaterials, InThis );
|
|
|
|
// Add references to all temporary cooked material packages
|
|
for (TMap< FString, TWeakObjectPtr<class UPackage> > ::TIterator
|
|
Iter(HoudiniAssetComponent->CookedTemporaryPackages); Iter; ++Iter)
|
|
{
|
|
UPackage * MaterialPackage = Iter.Value().Get();
|
|
if (MaterialPackage && !MaterialPackage->IsPendingKill())
|
|
Collector.AddReferencedObject(MaterialPackage, InThis);
|
|
}
|
|
|
|
}
|
|
|
|
// Call base implementation.
|
|
Super::AddReferencedObjects( InThis, Collector );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetNative( bool InbIsNativeComponent )
|
|
{
|
|
bIsNativeComponent = InbIsNativeComponent;
|
|
}
|
|
|
|
HAPI_NodeId
|
|
UHoudiniAssetComponent::GetAssetId() const
|
|
{
|
|
return AssetId;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetAssetId( HAPI_NodeId InAssetId )
|
|
{
|
|
AssetId = InAssetId;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::HasValidAssetId() const
|
|
{
|
|
return FHoudiniEngineUtils::IsHoudiniNodeValid( AssetId );
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::IsComponentValid() const
|
|
{
|
|
if( !IsValidLowLevel() )
|
|
return false;
|
|
|
|
if ( IsTemplate() )
|
|
return false;
|
|
|
|
if ( IsPendingKillOrUnreachable() )
|
|
return false;
|
|
|
|
if ( !GetOuter() ) //|| !GetOuter()->GetLevel() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
UHoudiniAsset *
|
|
UHoudiniAssetComponent::GetHoudiniAsset() const
|
|
{
|
|
return HoudiniAsset;
|
|
}
|
|
|
|
|
|
AHoudiniAssetActor*
|
|
UHoudiniAssetComponent::GetHoudiniAssetActorOwner() const
|
|
{
|
|
return Cast< AHoudiniAssetActor >( GetOwner() );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetHoudiniAsset( UHoudiniAsset * InHoudiniAsset )
|
|
{
|
|
// If it is the same asset, do nothing.
|
|
if ( InHoudiniAsset == HoudiniAsset )
|
|
return;
|
|
|
|
UHoudiniAsset * Asset = nullptr;
|
|
AHoudiniAssetActor * HoudiniAssetActor = Cast< AHoudiniAssetActor >( GetOwner() );
|
|
|
|
HoudiniAsset = InHoudiniAsset;
|
|
|
|
// Reset material tracking.
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
HoudiniAssetComponentMaterials->ResetMaterialInfo();
|
|
|
|
if ( !bIsNativeComponent )
|
|
return;
|
|
|
|
#if WITH_EDITOR
|
|
|
|
// Houdini Asset has been changed, we need to reset corresponding HDA and relevant resources.
|
|
ResetHoudiniResources();
|
|
|
|
#endif
|
|
|
|
// Clear all created parameters.
|
|
ClearParameters();
|
|
|
|
// Clear all inputs.
|
|
ClearInputs();
|
|
|
|
// Clear all instance inputs.
|
|
ClearInstanceInputs();
|
|
|
|
// Release all curve related resources.
|
|
ClearCurves();
|
|
|
|
// Clear all handles.
|
|
ClearHandles();
|
|
|
|
// Clear all landscapes.
|
|
ClearLandscapes();
|
|
|
|
// Set Houdini logo to be default geometry.
|
|
ReleaseObjectGeoPartResources( StaticMeshes );
|
|
StaticMeshes.Empty();
|
|
StaticMeshComponents.Empty();
|
|
CreateStaticMeshHoudiniLogoResource( StaticMeshes );
|
|
|
|
bIsPreviewComponent = false;
|
|
if ( !InHoudiniAsset )
|
|
{
|
|
#if WITH_EDITOR
|
|
UpdateEditorProperties( false );
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if ( HoudiniAssetActor )
|
|
bIsPreviewComponent = HoudiniAssetActor->IsUsedForPreview();
|
|
|
|
if( !bIsNativeComponent )
|
|
bLoadedComponent = false;
|
|
|
|
// Get instance of Houdini Engine.
|
|
FHoudiniEngine & HoudiniEngine = FHoudiniEngine::Get();
|
|
|
|
#if WITH_EDITOR
|
|
|
|
if ( !bIsPreviewComponent )
|
|
{
|
|
// If the fist session on the engine was never initialized, do it now
|
|
if (!FHoudiniEngine::Get().GetFirstSessionCreated())
|
|
{
|
|
HOUDINI_LOG_MESSAGE(TEXT("First initialization of the Houdini Engine session"));
|
|
FHoudiniEngine::Get().RestartSession();
|
|
}
|
|
|
|
if ( HoudiniEngine.IsInitialized() )
|
|
{
|
|
if ( !bLoadedComponent )
|
|
{
|
|
// If component is not a loaded component, instantiate and start ticking.
|
|
StartTaskAssetInstantiation( false, true );
|
|
}
|
|
else if ( bTransactionAssetChange )
|
|
{
|
|
// If assigned asset is transacted asset, instantiate and start ticking. Also treat as loaded component.
|
|
StartTaskAssetInstantiation( true, true );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( UHoudiniAssetComponent::bDisplayEngineHapiVersionMismatch && HoudiniEngine.CheckHapiVersionMismatch() )
|
|
{
|
|
// We have mismatch in defined and running versions.
|
|
int32 RunningEngineMajor = 0;
|
|
int32 RunningEngineMinor = 0;
|
|
int32 RunningEngineApi = 0;
|
|
|
|
const HAPI_Session * Session = FHoudiniEngine::Get().GetSession();
|
|
|
|
// Retrieve version numbers for running Houdini Engine.
|
|
FHoudiniApi::GetEnvInt( HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MAJOR, &RunningEngineMajor );
|
|
FHoudiniApi::GetEnvInt( HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MINOR, &RunningEngineMinor );
|
|
FHoudiniApi::GetEnvInt( HAPI_ENVINT_VERSION_HOUDINI_ENGINE_API, &RunningEngineApi );
|
|
|
|
// Get platform specific name of libHAPI.
|
|
FString LibHAPIName = FHoudiniEngineUtils::HoudiniGetLibHAPIName();
|
|
|
|
// Some sanity checks.
|
|
int32 BuiltEngineMajor = FMath::Max( 0, HAPI_VERSION_HOUDINI_ENGINE_MAJOR );
|
|
int32 BuiltEngineMinor = FMath::Max( 0, HAPI_VERSION_HOUDINI_ENGINE_MINOR );
|
|
int32 BuiltEngineApi = FMath::Max( 0, HAPI_VERSION_HOUDINI_ENGINE_API );
|
|
|
|
FString WarningMessage = FString::Printf(
|
|
TEXT( "Defined version: %d.%d.api:%d vs Running version: %d.%d.api:%d mismatch. " )
|
|
TEXT( "%s was loaded, but has wrong version. " )
|
|
TEXT( "No cooking / instantiation will take place." ),
|
|
BuiltEngineMajor,
|
|
BuiltEngineMinor,
|
|
BuiltEngineApi,
|
|
RunningEngineMajor,
|
|
RunningEngineMinor,
|
|
RunningEngineApi,
|
|
*LibHAPIName );
|
|
|
|
FString WarningTitle = TEXT( "Houdini Engine Plugin Warning" );
|
|
FText WarningTitleText = FText::FromString( WarningTitle );
|
|
FMessageDialog::Debugf( FText::FromString( WarningMessage ), &WarningTitleText );
|
|
|
|
UHoudiniAssetComponent::bDisplayEngineHapiVersionMismatch = false;
|
|
}
|
|
else if ( UHoudiniAssetComponent::bDisplayEngineNotInitialized )
|
|
{
|
|
// Get platform specific name of libHAPI.
|
|
FString LibHAPIName = FHoudiniEngineUtils::HoudiniGetLibHAPIName();
|
|
|
|
// If this is first time component is instantiated and we do not have Houdini Engine initialized.
|
|
FString WarningTitle = TEXT( "Houdini Engine Plugin Warning" );
|
|
FText WarningTitleText = FText::FromString( WarningTitle );
|
|
FString WarningMessage = FString::Printf(
|
|
TEXT( "Houdini Installation was not detected." )
|
|
TEXT( "Failed to locate or load %s. " )
|
|
TEXT( "No cooking / instantiation will take place." ),
|
|
*LibHAPIName );
|
|
|
|
FMessageDialog::Debugf( FText::FromString( WarningMessage ), &WarningTitleText );
|
|
|
|
UHoudiniAssetComponent::bDisplayEngineNotInitialized = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::AddDownstreamAsset( UHoudiniAssetComponent * InDownstreamAssetComponent, int32 InInputIndex )
|
|
{
|
|
if ( InDownstreamAssetComponent && !InDownstreamAssetComponent->IsPendingKill() )
|
|
{
|
|
if ( DownstreamAssetConnections.Contains( InDownstreamAssetComponent ) )
|
|
{
|
|
TSet< int32 > & InputIndicesSet = DownstreamAssetConnections[ InDownstreamAssetComponent ];
|
|
InputIndicesSet.Add( InInputIndex );
|
|
}
|
|
else
|
|
{
|
|
TSet< int32 > InputIndicesSet;
|
|
InputIndicesSet.Add( InInputIndex );
|
|
DownstreamAssetConnections.Add( InDownstreamAssetComponent, InputIndicesSet );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::RemoveDownstreamAsset( UHoudiniAssetComponent * InDownstreamAssetComponent, int32 InInputIndex )
|
|
{
|
|
if ( !InDownstreamAssetComponent || InDownstreamAssetComponent->IsPendingKill() )
|
|
return;
|
|
|
|
if ( DownstreamAssetConnections.Contains( InDownstreamAssetComponent ) )
|
|
{
|
|
TSet< int32 > & InputIndicesSet = DownstreamAssetConnections[ InDownstreamAssetComponent ];
|
|
if ( InputIndicesSet.Contains( InInputIndex ) )
|
|
InputIndicesSet.Remove( InInputIndex );
|
|
|
|
// Remove the downstream asset if we're not link to at least one of its input
|
|
if (InputIndicesSet.Num() <= 0)
|
|
DownstreamAssetConnections.Remove(InDownstreamAssetComponent);
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateObjectGeoPartResources(
|
|
TMap< FHoudiniGeoPartObject, UStaticMesh * > & StaticMeshMap )
|
|
{
|
|
// Reset Houdini logo flag.
|
|
bContainsHoudiniLogoGeometry = false;
|
|
|
|
// We need to store instancers as they need to be processed after all other meshes.
|
|
TArray< FHoudiniGeoPartObject > FoundInstancers;
|
|
TArray< FHoudiniGeoPartObject > FoundCurves;
|
|
TArray< FHoudiniGeoPartObject > FoundVolumes;
|
|
TMap< FHoudiniGeoPartObject, UStaticMesh* > StaleParts;
|
|
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( StaticMeshMap ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
|
|
if ( HoudiniGeoPartObject.IsInstancer() )
|
|
{
|
|
FoundInstancers.Add( HoudiniGeoPartObject );
|
|
}
|
|
else if ( HoudiniGeoPartObject.IsPackedPrimitiveInstancer() )
|
|
{
|
|
// Packed Primitives should be processed before other instancer in case they are instanced by the same
|
|
FoundInstancers.Insert( HoudiniGeoPartObject, 0 );
|
|
}
|
|
else if ( HoudiniGeoPartObject.IsCurve() )
|
|
{
|
|
// This geo part is a curve and has no mesh assigned.
|
|
check( !StaticMesh );
|
|
FoundCurves.Add( HoudiniGeoPartObject );
|
|
}
|
|
else if ( HoudiniGeoPartObject.IsVolume() )
|
|
{
|
|
FoundVolumes.Add( HoudiniGeoPartObject );
|
|
}
|
|
else
|
|
{
|
|
// This geo part is visible and not an instancer and must have static mesh assigned.
|
|
if ( HoudiniGeoPartObject.IsVisible() && ( !StaticMesh || StaticMesh->IsPendingKill() ) )
|
|
{
|
|
HOUDINI_LOG_WARNING( TEXT( "No static mesh generated for visible part %d,%d,%d" ), HoudiniGeoPartObject.AssetId, HoudiniGeoPartObject.ObjectId, HoudiniGeoPartObject.PartId );
|
|
continue;
|
|
}
|
|
|
|
UStaticMeshComponent * StaticMeshComponent = nullptr;
|
|
UStaticMeshComponent * FoundStaticMeshComponent = LocateStaticMeshComponent( StaticMesh );
|
|
|
|
if ( FoundStaticMeshComponent && !FoundStaticMeshComponent->IsPendingKill() )
|
|
{
|
|
StaticMeshComponent = FoundStaticMeshComponent;
|
|
if ( !HoudiniGeoPartObject.IsVisible() && !HoudiniGeoPartObject.IsCollidable())
|
|
{
|
|
// We have a mesh and component for a part which is invisible.
|
|
// Visibility may have changed since last cook
|
|
StaleParts.Add( HoudiniGeoPartObject, StaticMesh );
|
|
continue;
|
|
}
|
|
}
|
|
else if ( HoudiniGeoPartObject.IsVisible() || HoudiniGeoPartObject.IsCollidable())
|
|
{
|
|
// Create necessary component.
|
|
StaticMeshComponent = NewObject< UStaticMeshComponent >(
|
|
GetOwner() ? GetOwner() : GetOuter(), UStaticMeshComponent::StaticClass(),
|
|
NAME_None, RF_Transactional );
|
|
|
|
if ( StaticMeshComponent && !StaticMeshComponent->IsPendingKill() )
|
|
{
|
|
StaticMeshComponent->SetStaticMesh(StaticMesh);
|
|
StaticMeshComponent->SetVisibility(HoudiniGeoPartObject.IsVisible());
|
|
StaticMeshComponent->SetMobility(Mobility);
|
|
|
|
// Property propagation: set the new SMC's properties to the HAC's current settings
|
|
CopyComponentPropertiesTo(StaticMeshComponent);
|
|
|
|
// Register the component AFTER copying the properties!
|
|
StaticMeshComponent->RegisterComponent();
|
|
|
|
// Attach created static mesh component to our Houdini component.
|
|
StaticMeshComponent->AttachToComponent(this, FAttachmentTransformRules::KeepRelativeTransform);
|
|
|
|
// Add to the map of components.
|
|
StaticMeshComponents.Add(StaticMesh, StaticMeshComponent);
|
|
}
|
|
}
|
|
|
|
// No need to change visible/collision/uproperties if we're not fully loaded,
|
|
// as this likely means that we're in the process of being deserialized...
|
|
if (bFullyLoaded && StaticMeshComponent && !StaticMeshComponent->IsPendingKill())
|
|
{
|
|
// If this is a collision geo, we need to make it invisible.
|
|
if (HoudiniGeoPartObject.IsCollidable())
|
|
{
|
|
StaticMeshComponent->SetVisibility( false );
|
|
StaticMeshComponent->SetHiddenInGame( true );
|
|
StaticMeshComponent->SetCollisionProfileName( FName( TEXT( "InvisibleWall" ) ) );
|
|
StaticMeshComponent->SetCastShadow(false);
|
|
}
|
|
else
|
|
{
|
|
// Visibility may have changed so we still need to update it
|
|
StaticMeshComponent->SetVisibility( HoudiniGeoPartObject.IsVisible() );
|
|
StaticMeshComponent->SetHiddenInGame( !HoudiniGeoPartObject.IsVisible() );
|
|
}
|
|
|
|
// And we will need to update the navmesh later
|
|
if( HoudiniGeoPartObject.IsCollidable() || HoudiniGeoPartObject.IsRenderCollidable() )
|
|
bNeedToUpdateNavigationSystem = true;
|
|
|
|
// Transform the component by transformation provided by HAPI.
|
|
StaticMeshComponent->SetRelativeTransform( HoudiniGeoPartObject.TransformMatrix );
|
|
|
|
// If the static mesh had sockets, we can assign the desired actor to them now
|
|
int32 NumberOfSockets = StaticMesh == nullptr ? 0 : StaticMesh->Sockets.Num();
|
|
for( int32 nSocket = 0; nSocket < NumberOfSockets; nSocket++ )
|
|
{
|
|
UStaticMeshSocket* MeshSocket = StaticMesh->Sockets[ nSocket ];
|
|
if ( MeshSocket && !MeshSocket->IsPendingKill() && ( MeshSocket->Tag.IsEmpty() ) )
|
|
continue;
|
|
|
|
FHoudiniEngineUtils::AddActorsToMeshSocket( StaticMesh->Sockets[ nSocket ], StaticMeshComponent );
|
|
}
|
|
|
|
// Try to update uproperty atributes
|
|
FHoudiniEngineUtils::UpdateUPropertyAttributesOnObject( StaticMeshComponent, HoudiniGeoPartObject );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( StaleParts.Num() )
|
|
{
|
|
for ( auto Iter : StaleParts )
|
|
{
|
|
StaticMeshMap.Remove( Iter.Key );
|
|
}
|
|
ReleaseObjectGeoPartResources( StaleParts, true );
|
|
}
|
|
|
|
// Skip self assignment.
|
|
if ( &StaticMeshes != &StaticMeshMap )
|
|
StaticMeshes = StaticMeshMap;
|
|
|
|
#if WITH_EDITOR
|
|
if ( FHoudiniEngineUtils::IsHoudiniNodeValid( AssetId ) )
|
|
{
|
|
// Create necessary instance inputs.
|
|
CreateInstanceInputs( FoundInstancers );
|
|
|
|
// Create necessary curves.
|
|
CreateCurves( FoundCurves );
|
|
|
|
// Create necessary landscapes
|
|
CreateAllLandscapes( FoundVolumes );
|
|
}
|
|
#endif
|
|
|
|
CleanUpAttachedStaticMeshComponents();
|
|
|
|
// Now that all the Meshes/Landscapes are created, see if we need to create material instances from attributes
|
|
CreateOrUpdateMaterialInstances();
|
|
|
|
// Mobility will be set to static if we generated a Landscape,
|
|
// Or to movable if any of our children is movable
|
|
UpdateMobility();
|
|
}
|
|
|
|
|
|
void
|
|
UHoudiniAssetComponent::ReleaseObjectGeoPartResources( bool bDeletePackages )
|
|
{
|
|
ReleaseObjectGeoPartResources( StaticMeshes, bDeletePackages );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ReleaseObjectGeoPartResources(
|
|
TMap< FHoudiniGeoPartObject, UStaticMesh * > & StaticMeshMap,
|
|
bool bDeletePackages,
|
|
TMap< FHoudiniGeoPartObject, UStaticMesh * > * pKeepIfContainedIn )
|
|
{
|
|
// Record generated static meshes which we need to delete.
|
|
TArray< UStaticMesh * > StaticMeshesToDelete;
|
|
|
|
// Get Houdini logo.
|
|
UStaticMesh * HoudiniLogoMesh = FHoudiniEngine::Get().GetHoudiniLogoStaticMesh().Get();
|
|
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( StaticMeshMap ); Iter; ++Iter )
|
|
{
|
|
// If we find the new mesh in the existing list, don't destroy the existing static mesh slot
|
|
if ( pKeepIfContainedIn )
|
|
{
|
|
const FHoudiniGeoPartObject& GeoPart = Iter.Key();
|
|
if (LocateStaticMeshByNames(GeoPart, *pKeepIfContainedIn))
|
|
{
|
|
// The old static mesh was found in the new list, no need to destroy it
|
|
continue;
|
|
}
|
|
}
|
|
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
// Removes the static mesh component from the map, detaches and destroys it.
|
|
RemoveStaticMeshComponent( StaticMesh );
|
|
|
|
if ( bDeletePackages && ( StaticMesh != HoudiniLogoMesh ) )
|
|
{
|
|
// Make sure this static mesh is not referenced.
|
|
UObject * ObjectMesh = (UObject *) StaticMesh;
|
|
FReferencerInformationList Referencers;
|
|
|
|
// Check if object is referenced and get its referencers, if it is.
|
|
bool bReferenced = IsReferenced(
|
|
ObjectMesh, GARBAGE_COLLECTION_KEEPFLAGS,
|
|
EInternalObjectFlags::GarbageCollectionKeepFlags, true, &Referencers );
|
|
|
|
if ( !bReferenced || IsObjectReferencedLocally( StaticMesh, Referencers ) )
|
|
{
|
|
// Only delete generated mesh if it has not been saved manually.
|
|
UPackage * Package = Cast< UPackage >( StaticMesh->GetOuter() );
|
|
if ( !Package || !Package->bHasBeenFullyLoaded )
|
|
StaticMeshesToDelete.Add(StaticMesh);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CleanUpAttachedStaticMeshComponents();
|
|
|
|
// Remove unused meshes.
|
|
StaticMeshMap.Empty();
|
|
|
|
#if WITH_EDITOR // Delete no longer used generated static meshes.
|
|
int32 MeshNum = StaticMeshesToDelete.Num();
|
|
|
|
if ( bDeletePackages && MeshNum > 0 )
|
|
{
|
|
for ( int32 MeshIdx = 0; MeshIdx < MeshNum; ++MeshIdx )
|
|
{
|
|
UStaticMesh * StaticMesh = StaticMeshesToDelete[ MeshIdx ];
|
|
|
|
// Free any RHI resources.
|
|
StaticMesh->PreEditChange( nullptr );
|
|
StaticMesh->MarkPendingKill();
|
|
|
|
ObjectTools::DeleteSingleObject( StaticMesh, false );
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CleanUpAttachedStaticMeshComponents()
|
|
{
|
|
// Record generated static meshes which we need to delete.
|
|
TArray< UStaticMesh * > StaticMeshesToDelete;
|
|
|
|
// Collect all the static mesh component for this asset
|
|
TMap<const UStaticMeshComponent *, FHoudiniGeoPartObject> AllSMC = CollectAllStaticMeshComponents();
|
|
|
|
// We'll check all the children static mesh components for junk
|
|
const auto & LocalAttachChildren = GetAttachChildren();
|
|
for (TArray< USceneComponent * >::TConstIterator Iter( LocalAttachChildren ); Iter; ++Iter)
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Cast< UStaticMeshComponent >(*Iter);
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
bool bNeedToCleanMeshComponent = false;
|
|
UStaticMesh * StaticMesh = StaticMeshComponent->GetStaticMesh();
|
|
|
|
if (AllSMC.Find(StaticMeshComponent) == nullptr)
|
|
bNeedToCleanMeshComponent = true;
|
|
|
|
// Do not clean up component attached to a socket
|
|
if ( StaticMeshComponent->GetAttachSocketName() != NAME_None )
|
|
bNeedToCleanMeshComponent = false;
|
|
|
|
if ( bNeedToCleanMeshComponent )
|
|
{
|
|
// This StaticMeshComponent is attached to the asset but not in the map, and not an instance.
|
|
// It may be a leftover from previous cook/undo/redo and needs to be properly destroyed
|
|
StaticMeshComponent->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
|
|
StaticMeshComponent->UnregisterComponent();
|
|
StaticMeshComponent->DestroyComponent();
|
|
|
|
StaticMeshesToDelete.Add( StaticMesh );
|
|
|
|
//HOUDINI_LOG_WARNING( TEXT("CLEANUP: Deleted extra Static Mesh Component for %s"), *(StaticMesh->GetName()) );
|
|
}
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
// We'll try to delete the undesirable static meshes too
|
|
for (int32 MeshIdx = 0; MeshIdx < StaticMeshesToDelete.Num(); ++MeshIdx)
|
|
{
|
|
UStaticMesh * StaticMesh = StaticMeshesToDelete[MeshIdx];
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
UObject * ObjectMesh = (UObject *)StaticMesh;
|
|
if ( ObjectMesh->IsUnreachable() )
|
|
continue;
|
|
|
|
// Check if object is referenced and get its referencers, if it is.
|
|
FReferencerInformationList Referencers;
|
|
bool bReferenced = IsReferenced(
|
|
ObjectMesh, GARBAGE_COLLECTION_KEEPFLAGS,
|
|
EInternalObjectFlags::GarbageCollectionKeepFlags, true, &Referencers);
|
|
|
|
if ( !bReferenced || IsObjectReferencedLocally( StaticMesh, Referencers ) )
|
|
{
|
|
// Only delete generated mesh if it has not been saved manually.
|
|
UPackage * Package = Cast< UPackage >( StaticMesh->GetOuter() );
|
|
if ( !Package || !Package->bHasBeenFullyLoaded )
|
|
{
|
|
StaticMesh->PreEditChange( nullptr );
|
|
ObjectTools::DeleteSingleObject( StaticMesh, false );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::IsObjectReferencedLocally(
|
|
UStaticMesh * StaticMesh,
|
|
FReferencerInformationList & Referencers ) const
|
|
{
|
|
if ( Referencers.InternalReferences.Num() == 0 && Referencers.ExternalReferences.Num() == 1 )
|
|
{
|
|
const FReferencerInformation & ExternalReferencer = Referencers.ExternalReferences[ 0 ];
|
|
if ( ExternalReferencer.Referencer == this )
|
|
{
|
|
// Only referencer is this component.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CollectSubstanceParameters( TMap< FString, UHoudiniAssetParameter * > & SubstanceParameters ) const
|
|
{
|
|
SubstanceParameters.Empty();
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TConstIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( HoudiniAssetParameter->IsSubstanceParameter() )
|
|
SubstanceParameters.Add( HoudiniAssetParameter->GetParameterName(), HoudiniAssetParameter );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CollectAllParametersOfType(
|
|
UClass * ParameterClass,
|
|
TMap< FString, UHoudiniAssetParameter * > & ClassParameters ) const
|
|
{
|
|
ClassParameters.Empty();
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TConstIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill())
|
|
continue;
|
|
|
|
if ( HoudiniAssetParameter->IsA( ParameterClass ) )
|
|
ClassParameters.Add( HoudiniAssetParameter->GetParameterName(), HoudiniAssetParameter );
|
|
}
|
|
}
|
|
|
|
UHoudiniAssetParameter *
|
|
UHoudiniAssetComponent::FindParameter( const FString & ParameterName ) const
|
|
{
|
|
UHoudiniAssetParameter * const * FoundHoudiniAssetParameter = ParameterByName.Find( ParameterName );
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = nullptr;
|
|
|
|
if ( FoundHoudiniAssetParameter )
|
|
HoudiniAssetParameter = *FoundHoudiniAssetParameter;
|
|
|
|
if ( !HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill() )
|
|
return nullptr;
|
|
|
|
return HoudiniAssetParameter;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::GetInputs( TArray< UHoudiniAssetInput* >& AllInputs, bool IncludeObjectPathParameter )
|
|
{
|
|
AllInputs.Empty();
|
|
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( !HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
AllInputs.Add( HoudiniAssetInput );
|
|
}
|
|
|
|
if ( !IncludeObjectPathParameter )
|
|
return;
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TConstIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetInput* ObjectPathInput = Cast< UHoudiniAssetInput >( IterParams.Value() );
|
|
if ( !ObjectPathInput || ObjectPathInput->IsPendingKill() )
|
|
continue;
|
|
|
|
AllInputs.Add ( ObjectPathInput );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::GetAllUsedStaticMeshes( TArray< UStaticMesh * > & UsedStaticMeshes )
|
|
{
|
|
UsedStaticMeshes.Empty();
|
|
|
|
// Add all static meshes.
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( StaticMesh && !StaticMesh->IsPendingKill() )
|
|
UsedStaticMeshes.Add( StaticMesh );
|
|
}
|
|
}
|
|
|
|
TMap<const UStaticMeshComponent *, FHoudiniGeoPartObject>
|
|
UHoudiniAssetComponent::CollectAllStaticMeshComponents() const
|
|
{
|
|
TMap<const UStaticMeshComponent *, FHoudiniGeoPartObject> OutSMComponentToPart;
|
|
|
|
// Add all the instance meshes, including the variations
|
|
for ( const UHoudiniAssetInstanceInput* InstanceInput : InstanceInputs )
|
|
{
|
|
if ( !InstanceInput || InstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
for ( const UHoudiniAssetInstanceInputField* InputField : InstanceInput->GetInstanceInputFields() )
|
|
{
|
|
if ( !InputField || InputField->IsPendingKill() )
|
|
continue;
|
|
|
|
for ( int32 VarIndex = 0; VarIndex < InputField->InstanceVariationCount(); ++VarIndex )
|
|
{
|
|
UObject* Comp = InputField->GetInstancedComponent( VarIndex );
|
|
if ( Comp && InputField->GetInstanceVariation( VarIndex ) && Comp->IsA<UInstancedStaticMeshComponent>() )
|
|
{
|
|
OutSMComponentToPart.Add( Cast<UInstancedStaticMeshComponent>( Comp ), InputField->GetHoudiniGeoPartObject() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// add all the plain UStaticMeshComponent
|
|
for ( const auto& MeshPart : GetStaticMeshes() )
|
|
{
|
|
if ( UStaticMeshComponent * SMC = LocateStaticMeshComponent( MeshPart.Value ) )
|
|
{
|
|
OutSMComponentToPart.Add( SMC, MeshPart.Key );
|
|
}
|
|
}
|
|
|
|
return OutSMComponentToPart;
|
|
}
|
|
|
|
TMap<const UHoudiniInstancedActorComponent *, FHoudiniGeoPartObject>
|
|
UHoudiniAssetComponent::CollectAllInstancedActorComponents() const
|
|
{
|
|
TMap<const UHoudiniInstancedActorComponent *, FHoudiniGeoPartObject> OutSMComponentToPart;
|
|
for ( const UHoudiniAssetInstanceInput* InstanceInput : InstanceInputs )
|
|
{
|
|
if ( !InstanceInput || InstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
for ( const UHoudiniAssetInstanceInputField* InputField : InstanceInput->GetInstanceInputFields() )
|
|
{
|
|
if ( !InputField || InputField->IsPendingKill() )
|
|
continue;
|
|
|
|
for ( int32 VarIndex = 0; VarIndex < InputField->InstanceVariationCount(); ++VarIndex )
|
|
{
|
|
UObject* Comp = InputField->GetInstancedComponent( VarIndex );
|
|
if (!Comp || Comp->IsPendingKill())
|
|
continue;
|
|
|
|
if ( InputField->GetInstanceVariation( VarIndex ) && Comp->IsA<UHoudiniInstancedActorComponent>() )
|
|
{
|
|
OutSMComponentToPart.Add( Cast<UHoudiniInstancedActorComponent>( Comp ), InputField->GetHoudiniGeoPartObject() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return OutSMComponentToPart;
|
|
}
|
|
|
|
TMap<const UHoudiniMeshSplitInstancerComponent *, FHoudiniGeoPartObject>
|
|
UHoudiniAssetComponent::CollectAllMeshSplitInstancerComponents() const
|
|
{
|
|
TMap<const UHoudiniMeshSplitInstancerComponent *, FHoudiniGeoPartObject> OutSMComponentToPart;
|
|
for( const UHoudiniAssetInstanceInput* InstanceInput : InstanceInputs )
|
|
{
|
|
if (!InstanceInput || InstanceInput->IsPendingKill())
|
|
continue;
|
|
|
|
for( const UHoudiniAssetInstanceInputField* InputField : InstanceInput->GetInstanceInputFields() )
|
|
{
|
|
if ( !InputField || InputField->IsPendingKill() )
|
|
continue;
|
|
|
|
for( int32 VarIndex = 0; VarIndex < InputField->InstanceVariationCount(); ++VarIndex )
|
|
{
|
|
UObject* Comp = InputField->GetInstancedComponent(VarIndex);
|
|
if (!Comp || Comp->IsPendingKill())
|
|
continue;
|
|
|
|
if( InputField->GetInstanceVariation(VarIndex) && Comp->IsA<UHoudiniMeshSplitInstancerComponent>() )
|
|
{
|
|
OutSMComponentToPart.Add(Cast<UHoudiniMeshSplitInstancerComponent>(Comp), InputField->GetHoudiniGeoPartObject());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return OutSMComponentToPart;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::CheckGlobalSettingScaleFactors() const
|
|
{
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
if ( HoudiniRuntimeSettings )
|
|
{
|
|
return ( GeneratedGeometryScaleFactor == HoudiniRuntimeSettings->GeneratedGeometryScaleFactor &&
|
|
TransformScaleFactor == HoudiniRuntimeSettings->TransformScaleFactor );
|
|
}
|
|
|
|
return ( GeneratedGeometryScaleFactor == HAPI_UNREAL_SCALE_FACTOR_POSITION &&
|
|
TransformScaleFactor == HAPI_UNREAL_SCALE_FACTOR_TRANSLATION );
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
|
|
bool
|
|
UHoudiniAssetComponent::IsInstantiatingOrCooking() const
|
|
{
|
|
return HapiGUID.IsValid();
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::HasBeenInstantiatedButNotCooked() const
|
|
{
|
|
return ( FHoudiniEngineUtils::IsHoudiniNodeValid( AssetId ) && ( 0 == AssetCookCount ) );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::AssignUniqueActorLabel()
|
|
{
|
|
if ( GEditor && FHoudiniEngineUtils::IsValidNodeId( AssetId ) )
|
|
{
|
|
AHoudiniAssetActor * HoudiniAssetActor = GetHoudiniAssetActorOwner();
|
|
if ( HoudiniAssetActor )
|
|
{
|
|
FString UniqueName;
|
|
if ( FHoudiniEngineUtils::GetHoudiniAssetName( AssetId, UniqueName ) )
|
|
FActorLabelUtilities::SetActorLabelUnique( HoudiniAssetActor, UniqueName );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartHoudiniUIUpdateTicking()
|
|
{
|
|
// If we have no timer delegate spawned for ui update, spawn one.
|
|
if ( !TimerDelegateUIUpdate.IsBound() && GEditor )
|
|
{
|
|
TimerDelegateUIUpdate = FTimerDelegate::CreateUObject( this, &UHoudiniAssetComponent::TickHoudiniUIUpdate );
|
|
|
|
// We need to register delegate with the timer system.
|
|
static const float TickTimerDelay = 0.25f;
|
|
GEditor->GetTimerManager()->SetTimer( TimerHandleUIUpdate, TimerDelegateUIUpdate, TickTimerDelay, true );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StopHoudiniUIUpdateTicking()
|
|
{
|
|
if ( TimerDelegateUIUpdate.IsBound() && GEditor )
|
|
{
|
|
GEditor->GetTimerManager()->ClearTimer( TimerHandleUIUpdate );
|
|
TimerDelegateUIUpdate.Unbind();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::TickHoudiniUIUpdate()
|
|
{
|
|
UpdateEditorProperties( true );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartHoudiniTicking()
|
|
{
|
|
// If we have no timer delegate spawned for this component, spawn one.
|
|
if ( !TimerDelegateCooking.IsBound() && GEditor )
|
|
{
|
|
TimerDelegateCooking = FTimerDelegate::CreateUObject( this, &UHoudiniAssetComponent::TickHoudiniComponent );
|
|
|
|
// We need to register delegate with the timer system.
|
|
static const float TickTimerDelay = 0.25f;
|
|
GEditor->GetTimerManager()->SetTimer( TimerHandleCooking, TimerDelegateCooking, TickTimerDelay, true );
|
|
|
|
// Grab current time for delayed notification.
|
|
HapiNotificationStarted = FPlatformTime::Seconds();
|
|
}
|
|
|
|
// If the fist session of houdini engine hasnt been initialized yet, do it now
|
|
if (!FHoudiniEngine::Get().GetFirstSessionCreated())
|
|
{
|
|
HOUDINI_LOG_MESSAGE(TEXT("First initialization of the Houdini Engine session"));
|
|
FHoudiniEngine::Get().RestartSession();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StopHoudiniTicking()
|
|
{
|
|
if ( TimerDelegateCooking.IsBound() && GEditor )
|
|
{
|
|
GEditor->GetTimerManager()->ClearTimer( TimerHandleCooking );
|
|
TimerDelegateCooking.Unbind();
|
|
|
|
// Reset time for delayed notification.
|
|
HapiNotificationStarted = 0.0;
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostCook( bool bCookError )
|
|
{
|
|
// Show busy cursor.
|
|
FScopedBusyCursor ScopedBusyCursor;
|
|
|
|
// Create parameters and inputs.
|
|
CreateParameters();
|
|
CreateInputs();
|
|
CreateHandles();
|
|
|
|
if ( bCookError )
|
|
{
|
|
// We need to reset the manual recook flag here to avoid endless cooking
|
|
bManualRecookRequested = false;
|
|
return;
|
|
}
|
|
|
|
FTransform ComponentTransform;
|
|
TMap< FHoudiniGeoPartObject, UStaticMesh * > NewStaticMeshes;
|
|
|
|
FHoudiniCookParams HoudiniCookParams( this );
|
|
HoudiniCookParams.StaticMeshBakeMode = FHoudiniCookParams::GetDefaultStaticMeshesCookMode();
|
|
HoudiniCookParams.MaterialAndTextureBakeMode = FHoudiniCookParams::GetDefaultMaterialAndTextureCookMode();
|
|
|
|
if ( FHoudiniEngineUtils::CreateStaticMeshesFromHoudiniAsset(
|
|
GetAssetId(),
|
|
HoudiniCookParams,
|
|
!CheckGlobalSettingScaleFactors(),
|
|
bManualRecookRequested,
|
|
StaticMeshes,
|
|
NewStaticMeshes,
|
|
ComponentTransform ) )
|
|
{
|
|
// Remove all duplicates. After this operation, old map will have meshes which we need to deallocate.
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator
|
|
Iter( NewStaticMeshes ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
|
|
// Removes the mesh from previous map of meshes
|
|
UStaticMesh * FoundOldStaticMesh = LocateStaticMesh( HoudiniGeoPartObject );
|
|
if (!FoundOldStaticMesh)
|
|
FoundOldStaticMesh = LocateStaticMeshByNames(HoudiniGeoPartObject, StaticMeshes);
|
|
|
|
if ( ( FoundOldStaticMesh ) && ( FoundOldStaticMesh == StaticMesh ) )
|
|
{
|
|
// Mesh has not changed, we need to remove it from the old map to avoid deallocation.
|
|
StaticMeshes.Remove( HoudiniGeoPartObject );
|
|
}
|
|
|
|
// See if we need to update the HoudiniAssetComponent uproperties
|
|
FHoudiniEngineUtils::UpdateUPropertyAttributesOnObject( this, HoudiniGeoPartObject );
|
|
}
|
|
|
|
// Make sure rendering is done
|
|
FlushRenderingCommands();
|
|
|
|
// Update the bake folder as it might have been updated by an override
|
|
BakeFolder = HoudiniCookParams.BakeFolder;
|
|
|
|
if ( NewStaticMeshes.Num() == 0 && bContainsHoudiniLogoGeometry )
|
|
{
|
|
// We're not creating anything new and are already using the houdini logo
|
|
// No need to destroy then recreate the Houdini Logo
|
|
if ( StaticMeshes.Num() != 1)
|
|
CreateStaticMeshHoudiniLogoResource( StaticMeshes );
|
|
}
|
|
else
|
|
{
|
|
// Free meshes and components that are no longer used.
|
|
// compare with first array, keep if contained in NewMeshes
|
|
ReleaseObjectGeoPartResources(StaticMeshes, true, &NewStaticMeshes);
|
|
|
|
// Set meshes and create new components for those meshes that do not have them.
|
|
if (NewStaticMeshes.Num() > 0)
|
|
CreateObjectGeoPartResources(NewStaticMeshes);
|
|
else
|
|
CreateStaticMeshHoudiniLogoResource(NewStaticMeshes);
|
|
}
|
|
}
|
|
|
|
// Invoke cooks of downstream assets.
|
|
if ( bCookingTriggersDownstreamCooks && DownstreamAssetConnections.Num() > 0)
|
|
{
|
|
// First, make sure our downstream assets are valid
|
|
// (check that the component is valid and we are properly set as one of its asset input)
|
|
ValidateDownstreamAssets();
|
|
|
|
for ( TMap<UHoudiniAssetComponent *, TSet< int32 > >::TIterator IterAssets( DownstreamAssetConnections );
|
|
IterAssets;
|
|
++IterAssets )
|
|
{
|
|
UHoudiniAssetComponent * DownstreamAsset = IterAssets.Key();
|
|
if ( !DownstreamAsset || DownstreamAsset->IsPendingKill() )
|
|
continue;
|
|
|
|
DownstreamAsset->bManualRecookRequested = bManualRecookRequested;
|
|
DownstreamAsset->NotifyParameterChanged( nullptr );
|
|
}
|
|
}
|
|
|
|
// We can reset the manual recook flag now that the static meshes have been created
|
|
bManualRecookRequested = false;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ValidateDownstreamAssets()
|
|
{
|
|
TArray<UHoudiniAssetComponent*> InvalidDowmnstreamAssets;
|
|
for (TMap<UHoudiniAssetComponent *, TSet< int32 > >::TIterator IterAssets(DownstreamAssetConnections); IterAssets; ++IterAssets)
|
|
{
|
|
UHoudiniAssetComponent * DownstreamAsset = IterAssets.Key();
|
|
if (!DownstreamAsset || DownstreamAsset->IsPendingKill())
|
|
{
|
|
InvalidDowmnstreamAssets.Add(DownstreamAsset);
|
|
continue;
|
|
}
|
|
|
|
// Check that the downstream asset is valid (that we are indeed set as asset input)
|
|
bool bInvalidDownstreamAsset = false;
|
|
TSet<int32> InputIndexes = IterAssets.Value();
|
|
if (InputIndexes.Num() <= 0)
|
|
{
|
|
InvalidDowmnstreamAssets.Add(DownstreamAsset);
|
|
continue;
|
|
}
|
|
|
|
// Get the downstream assets inputs (including object path parameters!)
|
|
TArray<UHoudiniAssetInput*> DownstreamInputs;
|
|
DownstreamAsset->GetInputs(DownstreamInputs, true);
|
|
|
|
// Check that asset component's input
|
|
for (auto DownstreamInputIdx : InputIndexes)
|
|
{
|
|
if (!DownstreamInputs.IsValidIndex(DownstreamInputIdx))
|
|
{
|
|
RemoveDownstreamAsset(DownstreamAsset, DownstreamInputIdx);
|
|
continue;
|
|
}
|
|
|
|
UHoudiniAssetInput* DownInput = DownstreamInputs[DownstreamInputIdx];
|
|
if (!DownInput || DownInput->IsPendingKill())
|
|
{
|
|
RemoveDownstreamAsset(DownstreamAsset, DownstreamInputIdx);
|
|
continue;
|
|
}
|
|
|
|
if (DownInput->GetChoiceIndex() != EHoudiniAssetInputType::AssetInput
|
|
|| DownInput->GetConnectedInputAssetComponent() != this)
|
|
{
|
|
RemoveDownstreamAsset(DownstreamAsset, DownstreamInputIdx);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove the fully invalid HAC
|
|
for (auto InvalidHAC : InvalidDowmnstreamAssets)
|
|
{
|
|
DownstreamAssetConnections.Remove(InvalidHAC);
|
|
}
|
|
|
|
}
|
|
void
|
|
UHoudiniAssetComponent::TickHoudiniComponent()
|
|
{
|
|
// Only tick/cook when in Editor
|
|
// This prevents PIE cooks or runtime cooks due to inputs moving
|
|
if (!GetWorld() || (GetWorld()->WorldType != EWorldType::Editor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get settings.
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
|
|
FHoudiniEngineTaskInfo TaskInfo;
|
|
bool bStopTicking = false;
|
|
bool bFinishedLoadedInstantiation = false;
|
|
|
|
static float NotificationFadeOutDuration = 2.0f;
|
|
static float NotificationExpireDuration = 2.0f;
|
|
static double NotificationUpdateFrequency = 2.0f;
|
|
|
|
// Check whether we want to display Slate cooking and instantiation notifications.
|
|
bool bDisplaySlateCookingNotifications = false;
|
|
if ( HoudiniRuntimeSettings )
|
|
bDisplaySlateCookingNotifications = HoudiniRuntimeSettings->bDisplaySlateCookingNotifications;
|
|
|
|
if ( HapiGUID.IsValid() )
|
|
{
|
|
// If we have a valid task GUID.
|
|
if ( FHoudiniEngine::Get().RetrieveTaskInfo( HapiGUID, TaskInfo ) )
|
|
{
|
|
if ( EHoudiniEngineTaskState::None != TaskInfo.TaskState )
|
|
{
|
|
if ( !NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
FNotificationInfo Info( TaskInfo.StatusText );
|
|
|
|
Info.bFireAndForget = false;
|
|
Info.FadeOutDuration = NotificationFadeOutDuration;
|
|
Info.ExpireDuration = NotificationExpireDuration;
|
|
|
|
TSharedPtr< FSlateDynamicImageBrush > HoudiniBrush = FHoudiniEngine::Get().GetHoudiniLogoBrush();
|
|
if ( HoudiniBrush.IsValid() )
|
|
Info.Image = HoudiniBrush.Get();
|
|
|
|
if ( ( FPlatformTime::Seconds() - HapiNotificationStarted) >= NotificationUpdateFrequency )
|
|
{
|
|
if ( !IsPIEActive() )
|
|
NotificationPtr = FSlateNotificationManager::Get().AddNotification( Info );
|
|
}
|
|
}
|
|
}
|
|
|
|
FString DisplayName;
|
|
if (GetOwner())
|
|
DisplayName = (GetOwner()->GetName());
|
|
else
|
|
DisplayName = GetName();
|
|
|
|
switch( TaskInfo.TaskState )
|
|
{
|
|
case EHoudiniEngineTaskState::FinishedInstantiation:
|
|
{
|
|
HOUDINI_LOG_MESSAGE( TEXT(" %s FinishedInstantiation." ), *DisplayName );
|
|
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( TaskInfo.AssetId ) )
|
|
{
|
|
// Set new asset id.
|
|
SetAssetId( TaskInfo.AssetId );
|
|
|
|
AHoudiniAssetActor * HoudiniAssetActor = GetHoudiniAssetActorOwner();
|
|
if( HoudiniAssetActor && HoudiniAssetActor->GetName().StartsWith( AHoudiniAssetActor::StaticClass()->GetName() ) )
|
|
{
|
|
// Assign unique actor label based on asset name if it seems to have not been renamed already
|
|
AssignUniqueActorLabel();
|
|
}
|
|
|
|
// Create default preset buffer.
|
|
CreateDefaultPreset();
|
|
|
|
// If necessary, set asset transform.
|
|
if ( bUploadTransformsToHoudiniEngine )
|
|
{
|
|
// Retrieve the current component-to-world transform for this component.
|
|
if ( !FHoudiniEngineUtils::HapiSetAssetTransform( AssetId, GetComponentTransform() ) )
|
|
HOUDINI_LOG_MESSAGE( TEXT( "Failed Uploading Initial Transformation back to HAPI." ) );
|
|
}
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
{
|
|
NotificationItem->SetText( TaskInfo.StatusText );
|
|
NotificationItem->ExpireAndFadeout();
|
|
|
|
NotificationPtr.Reset();
|
|
}
|
|
}
|
|
|
|
FHoudiniEngine::Get().RemoveTaskInfo( HapiGUID );
|
|
HapiGUID.Invalidate();
|
|
|
|
// We just finished instantiation, we need to reset cook counter.
|
|
AssetCookCount = 0;
|
|
|
|
if ( TaskInfo.bLoadedComponent )
|
|
bFinishedLoadedInstantiation = true;
|
|
|
|
FHoudiniEngine::Get().SetHapiState( HAPI_RESULT_SUCCESS );
|
|
}
|
|
else
|
|
{
|
|
bStopTicking = true;
|
|
HOUDINI_LOG_MESSAGE( TEXT( " %s Received invalid asset id." ), *DisplayName );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case EHoudiniEngineTaskState::FinishedCooking:
|
|
{
|
|
HOUDINI_LOG_MESSAGE( TEXT( " %s FinishedCooking." ), *DisplayName );
|
|
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( TaskInfo.AssetId ) )
|
|
{
|
|
// Set new asset id.
|
|
SetAssetId( TaskInfo.AssetId );
|
|
|
|
// Call post cook event.
|
|
PostCook();
|
|
|
|
// Need to update rendering information.
|
|
UpdateRenderingInformation();
|
|
|
|
#if WITH_EDITOR
|
|
// Force editor to redraw viewports.
|
|
if ( GEditor )
|
|
GEditor->RedrawAllViewports();
|
|
|
|
// Update properties panel after instantiation.
|
|
UpdateEditorProperties( true );
|
|
|
|
// We may have toolshelf input presets to apply (may cause a recook)
|
|
if ( HoudiniToolInputPreset.Num() > 0 )
|
|
ApplyHoudiniToolInputPreset();
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
HOUDINI_LOG_MESSAGE( TEXT( " %s Received invalid asset id." ), *DisplayName );
|
|
}
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
{
|
|
NotificationItem->SetText( TaskInfo.StatusText );
|
|
NotificationItem->ExpireAndFadeout();
|
|
|
|
NotificationPtr.Reset();
|
|
}
|
|
}
|
|
|
|
FHoudiniEngine::Get().RemoveTaskInfo( HapiGUID );
|
|
HapiGUID.Invalidate();
|
|
|
|
bStopTicking = true;
|
|
AssetCookCount++;
|
|
|
|
break;
|
|
}
|
|
|
|
case EHoudiniEngineTaskState::FinishedCookingWithErrors:
|
|
{
|
|
HOUDINI_LOG_MESSAGE( TEXT( " %s FinishedCookingWithErrors." ), *DisplayName );
|
|
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( TaskInfo.AssetId ) )
|
|
{
|
|
// Call post cook event with error parameter. This will create parameters, inputs and handles.
|
|
PostCook( true );
|
|
|
|
// Create default preset buffer.
|
|
CreateDefaultPreset();
|
|
#if WITH_EDITOR
|
|
// Apply the Input presets for Houdini tools if we have any...
|
|
ApplyHoudiniToolInputPreset();
|
|
|
|
// Update properties panel.
|
|
UpdateEditorProperties( true );
|
|
#endif
|
|
// If necessary, set asset transform.
|
|
if ( bUploadTransformsToHoudiniEngine )
|
|
{
|
|
// Retrieve the current component-to-world transform for this component.
|
|
if ( !FHoudiniEngineUtils::HapiSetAssetTransform(AssetId, GetComponentTransform() ) )
|
|
HOUDINI_LOG_MESSAGE( TEXT( "Failed Uploading Initial Transformation back to HAPI." ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Make sure to reset the manual cook flag here to avoid endless cooking/error spam
|
|
bManualRecookRequested = false;
|
|
}
|
|
|
|
// Try to detect possible crash/failures of HARS
|
|
if ( TaskInfo.Result == HAPI_RESULT_NOT_INITIALIZED
|
|
|| TaskInfo.Result == HAPI_RESULT_INVALID_SESSION )
|
|
{
|
|
HOUDINI_LOG_ERROR( TEXT("Failed to cook due to an invalid session.\n\
|
|
This could be due to a crash in the Houdini Engine session / HARS.\n\
|
|
Try restarting it via \"File > Restart Houdini Engine session\"\n\
|
|
then rebuild your assets." ) );
|
|
}
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
{
|
|
NotificationItem->SetText( TaskInfo.StatusText );
|
|
NotificationItem->ExpireAndFadeout();
|
|
|
|
NotificationPtr.Reset();
|
|
}
|
|
}
|
|
|
|
FHoudiniEngine::Get().RemoveTaskInfo( HapiGUID );
|
|
HapiGUID.Invalidate();
|
|
|
|
bStopTicking = true;
|
|
AssetCookCount++;
|
|
|
|
break;
|
|
}
|
|
|
|
case EHoudiniEngineTaskState::Aborted:
|
|
case EHoudiniEngineTaskState::FinishedInstantiationWithErrors:
|
|
{
|
|
HOUDINI_LOG_ERROR( TEXT( " %s FinishedInstantiationWithErrors." ), *DisplayName );
|
|
|
|
bool bLicensingIssue = false;
|
|
switch( TaskInfo.Result )
|
|
{
|
|
case HAPI_RESULT_NO_LICENSE_FOUND:
|
|
{
|
|
FHoudiniEngine::Get().SetHapiState( HAPI_RESULT_NO_LICENSE_FOUND );
|
|
|
|
bLicensingIssue = true;
|
|
break;
|
|
}
|
|
|
|
case HAPI_RESULT_DISALLOWED_NC_LICENSE_FOUND:
|
|
case HAPI_RESULT_DISALLOWED_NC_ASSET_WITH_C_LICENSE:
|
|
case HAPI_RESULT_DISALLOWED_NC_ASSET_WITH_LC_LICENSE:
|
|
case HAPI_RESULT_DISALLOWED_LC_ASSET_WITH_C_LICENSE:
|
|
{
|
|
bLicensingIssue = true;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bLicensingIssue )
|
|
{
|
|
const FString & StatusMessage = TaskInfo.StatusText.ToString() ;
|
|
HOUDINI_LOG_MESSAGE( TEXT( "%s" ), *StatusMessage );
|
|
|
|
FString WarningTitle = TEXT( "Houdini Engine Plugin Warning" );
|
|
FText WarningTitleText = FText::FromString( WarningTitle );
|
|
FString WarningMessage = FString::Printf( TEXT( "Houdini License issue - %s." ), *StatusMessage );
|
|
|
|
FMessageDialog::Debugf( FText::FromString( WarningMessage ), &WarningTitleText );
|
|
}
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
{
|
|
NotificationItem->SetText( TaskInfo.StatusText );
|
|
NotificationItem->ExpireAndFadeout();
|
|
|
|
NotificationPtr.Reset();
|
|
}
|
|
}
|
|
|
|
if ( TaskInfo.bLoadedComponent )
|
|
bFinishedLoadedInstantiation = true;
|
|
|
|
FHoudiniEngine::Get().RemoveTaskInfo( HapiGUID );
|
|
HapiGUID.Invalidate();
|
|
|
|
bStopTicking = true;
|
|
AssetCookCount = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
case EHoudiniEngineTaskState::Processing:
|
|
{
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
NotificationItem->SetText( TaskInfo.StatusText );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case EHoudiniEngineTaskState::None:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Task information does not exist, we can stop ticking.
|
|
HapiGUID.Invalidate();
|
|
bStopTicking = true;
|
|
}
|
|
}
|
|
|
|
if (bFinishedLoadedInstantiation)
|
|
bAssetIsBeingInstantiated = false;
|
|
|
|
if ( !IsInstantiatingOrCooking() )
|
|
{
|
|
if (( HasBeenInstantiatedButNotCooked() || bParametersChanged || bComponentNeedsCook || bManualRecookRequested )
|
|
&& (FHoudiniEngine::Get().GetEnableCookingGlobal() || bManualRecookRequested) )
|
|
{
|
|
// Grab current time for delayed notification.
|
|
HapiNotificationStarted = FPlatformTime::Seconds();
|
|
|
|
// We just submitted a task, we want to continue ticking.
|
|
bStopTicking = false;
|
|
|
|
if ( bWaitingForUpstreamAssetsToInstantiate )
|
|
{
|
|
// We are waiting for upstream assets to instantiate. Update the flag
|
|
UpdateWaitingForUpstreamAssetsToInstantiate();
|
|
|
|
// Try instantiating this asset again.
|
|
if ( !bWaitingForUpstreamAssetsToInstantiate )
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
}
|
|
else if ( bLoadedComponentRequiresInstantiation )
|
|
{
|
|
// This component has been loaded and requires instantiation.
|
|
bLoadedComponentRequiresInstantiation = false;
|
|
StartTaskAssetInstantiation( true );
|
|
}
|
|
else if ( bFinishedLoadedInstantiation )
|
|
{
|
|
// If we are doing first cook after instantiation.
|
|
RefreshEditableNodesAfterLoad();
|
|
|
|
// Update parameter node id for all loaded parameters.
|
|
UpdateLoadedParameters();
|
|
|
|
// Additionally, we need to update and create assets for all input parameters that have geos assigned.
|
|
UpdateLoadedInputs( bManualRecookRequested );
|
|
|
|
// We also need to upload loaded curve points.
|
|
UploadLoadedCurves();
|
|
|
|
// If we finished loading instantiation, we can restore preset data.
|
|
if ( PresetBuffer.Num() > 0 )
|
|
{
|
|
FHoudiniEngineUtils::SetAssetPreset( AssetId, PresetBuffer );
|
|
PresetBuffer.Empty();
|
|
}
|
|
|
|
// Upload changed parameters back to HAPI.
|
|
UploadChangedParameters();
|
|
|
|
// Reset tranform changed flag.
|
|
bComponentNeedsCook = false;
|
|
|
|
// Create asset cooking task object and submit it for processing.
|
|
StartTaskAssetCooking();
|
|
}
|
|
else
|
|
{
|
|
if ( IsCookingEnabled() || bManualRecookRequested )
|
|
{
|
|
// Upload changed parameters back to HAPI.
|
|
UploadChangedParameters();
|
|
|
|
// Create asset cooking task object and submit it for processing.
|
|
StartTaskAssetCooking();
|
|
|
|
// Reset ComponentNeedsCook flag.
|
|
bComponentNeedsCook = false;
|
|
}
|
|
else
|
|
{
|
|
// Cooking is disabled, but we still need to upload the parameters
|
|
// and update the editor properties
|
|
UploadChangedParameters();
|
|
|
|
// Update properties panel.
|
|
UpdateEditorProperties(true);
|
|
|
|
// Remember that we have uncooked changes
|
|
bComponentNeedsCook = true;
|
|
|
|
// Stop ticking
|
|
bStopTicking = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Nothing has changed, we can terminate ticking.
|
|
bStopTicking = true;
|
|
}
|
|
}
|
|
|
|
if ( bNeedToUpdateNavigationSystem )
|
|
{
|
|
#ifdef WITH_EDITOR
|
|
// notify navigation system
|
|
AHoudiniAssetActor* HoudiniActor = GetHoudiniAssetActorOwner();
|
|
if ( HoudiniActor && !HoudiniActor->IsPendingKill() )
|
|
FNavigationSystem::UpdateActorAndComponentData(*HoudiniActor);
|
|
#endif
|
|
bNeedToUpdateNavigationSystem = false;
|
|
}
|
|
|
|
if ( bStopTicking )
|
|
StopHoudiniTicking();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UpdateEditorProperties( bool bConditionalUpdate )
|
|
{
|
|
AHoudiniAssetActor * HoudiniAssetActor = GetHoudiniAssetActorOwner();
|
|
if ( !HoudiniAssetActor )
|
|
return;
|
|
|
|
FPropertyEditorModule & PropertyModule =
|
|
FModuleManager::Get().GetModuleChecked< FPropertyEditorModule >( "PropertyEditor" );
|
|
|
|
// We want to iterate on all the details panel
|
|
static const FName DetailsTabIdentifiers[] = { "LevelEditorSelectionDetails", "LevelEditorSelectionDetails2", "LevelEditorSelectionDetails3", "LevelEditorSelectionDetails4" };
|
|
for (const FName& DetailsPanelName : DetailsTabIdentifiers )
|
|
{
|
|
// Locate the details panel.
|
|
//FName DetailsPanelName = "LevelEditorSelectionDetails";
|
|
TSharedPtr< IDetailsView > DetailsView = PropertyModule.FindDetailView( DetailsPanelName );
|
|
|
|
if ( !DetailsView.IsValid() )
|
|
{
|
|
// We have no details panel, nothing to update.
|
|
continue;
|
|
}
|
|
|
|
if ( DetailsView->IsLocked() )
|
|
{
|
|
// If details panel is locked, locate selected actors and check if this component belongs to one of them.
|
|
const TArray< TWeakObjectPtr< AActor > > & SelectedDetailActors = DetailsView->GetSelectedActors();
|
|
bool bFoundActor = false;
|
|
|
|
for (int32 ActorIdx = 0, ActorNum = SelectedDetailActors.Num(); ActorIdx < ActorNum; ++ActorIdx)
|
|
{
|
|
TWeakObjectPtr< AActor > SelectedActor = SelectedDetailActors[ActorIdx];
|
|
if ( SelectedActor.IsValid() && SelectedActor.Get() == HoudiniAssetActor )
|
|
{
|
|
bFoundActor = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Details panel is locked, but our actor is not selected.
|
|
if ( !bFoundActor )
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// If our actor is not selected (and details panel is not locked) don't do any updates.
|
|
if ( !HoudiniAssetActor->IsSelected() )
|
|
continue;
|
|
}
|
|
|
|
if ( GEditor && HoudiniAssetActor && bIsNativeComponent )
|
|
{
|
|
if ( bConditionalUpdate && FSlateApplication::Get().HasAnyMouseCaptor() )
|
|
{
|
|
// We want to avoid UI update if this is a conditional update and widget has captured the mouse.
|
|
StartHoudiniUIUpdateTicking();
|
|
continue;
|
|
}
|
|
|
|
TArray< UObject * > SelectedActors;
|
|
SelectedActors.Add( HoudiniAssetActor );
|
|
|
|
// bEditorPropertiesNeedFullUpdate is false only when small changes (parameters value) have been made
|
|
// We do not reselect the actor to avoid loosing the current selected parameter
|
|
|
|
// Reset selected actor to itself, force refresh and override the lock.
|
|
DetailsView->SetObjects( SelectedActors, bEditorPropertiesNeedFullUpdate, true );
|
|
|
|
if ( !bEditorPropertiesNeedFullUpdate )
|
|
bEditorPropertiesNeedFullUpdate = true;
|
|
|
|
if ( GUnrealEd )
|
|
{
|
|
GUnrealEd->UpdateFloatingPropertyWindows();
|
|
}
|
|
}
|
|
|
|
StopHoudiniUIUpdateTicking();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetInstantiation( bool bLocalLoadedComponent, bool bStartTicking )
|
|
{
|
|
// We do not want to be instantiated twice
|
|
bAssetIsBeingInstantiated = true;
|
|
|
|
// We first need to make sure all our asset inputs have been instantiated and reconnected.
|
|
UpdateWaitingForUpstreamAssetsToInstantiate( true );
|
|
|
|
if ( !bWaitingForUpstreamAssetsToInstantiate )
|
|
{
|
|
// Check if asset has multiple Houdini assets inside.
|
|
HAPI_AssetLibraryId AssetLibraryId = -1;
|
|
TArray< HAPI_StringHandle > AssetNames;
|
|
|
|
if ( FHoudiniEngineUtils::GetAssetNames( HoudiniAsset, AssetLibraryId, AssetNames ) )
|
|
{
|
|
HAPI_StringHandle PickedAssetName = AssetNames[ 0 ];
|
|
bool bShowMultiAssetDialog = false;
|
|
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
if ( HoudiniRuntimeSettings )
|
|
bShowMultiAssetDialog = HoudiniRuntimeSettings->bShowMultiAssetDialog;
|
|
|
|
if ( bShowMultiAssetDialog && AssetNames.Num() > 1 )
|
|
{
|
|
// If we have more than one asset, we need to present user with choice dialog.
|
|
|
|
TSharedPtr< SWindow > ParentWindow;
|
|
|
|
// Check if the main frame is loaded. When using the old main frame it may not be.
|
|
if ( FModuleManager::Get().IsModuleLoaded( "MainFrame" ) )
|
|
{
|
|
IMainFrameModule & MainFrame = FModuleManager::LoadModuleChecked< IMainFrameModule >( "MainFrame" );
|
|
ParentWindow = MainFrame.GetParentWindow();
|
|
}
|
|
|
|
if ( ParentWindow.IsValid() )
|
|
{
|
|
TSharedPtr< SAssetSelectionWidget > AssetSelectionWidget;
|
|
|
|
TSharedRef< SWindow > Window = SNew( SWindow )
|
|
.Title( LOCTEXT( "WindowTitle", "Select an asset to instantiate" ) )
|
|
.ClientSize( FVector2D( 640, 480 ) )
|
|
.SupportsMinimize( false )
|
|
.SupportsMaximize( false )
|
|
.HasCloseButton( false );
|
|
|
|
Window->SetContent( SAssignNew( AssetSelectionWidget, SAssetSelectionWidget )
|
|
.WidgetWindow( Window )
|
|
.AvailableAssetNames( AssetNames ) );
|
|
|
|
if ( AssetSelectionWidget->IsValidWidget() )
|
|
{
|
|
FSlateApplication::Get().AddModalWindow( Window, ParentWindow, false );
|
|
|
|
int32 DialogPickedAssetName = AssetSelectionWidget->GetSelectedAssetName();
|
|
if ( DialogPickedAssetName != -1 )
|
|
PickedAssetName = DialogPickedAssetName;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create new GUID to identify this request.
|
|
HapiGUID = FGuid::NewGuid();
|
|
|
|
FHoudiniEngineTask Task( EHoudiniEngineTaskType::AssetInstantiation, HapiGUID );
|
|
Task.Asset = HoudiniAsset;
|
|
Task.ActorName = GetOuter()->GetName();
|
|
Task.bLoadedComponent = bLocalLoadedComponent;
|
|
Task.AssetLibraryId = AssetLibraryId;
|
|
Task.AssetHapiName = PickedAssetName;
|
|
FHoudiniEngine::Get().AddTask( Task );
|
|
}
|
|
else
|
|
{
|
|
HOUDINI_LOG_MESSAGE( TEXT( "Cancelling asset instantiation - unable to retrieve asset names." ) );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Start ticking - this will poll the cooking system for completion.
|
|
if ( bStartTicking )
|
|
StartHoudiniTicking();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetCookingManual()
|
|
{
|
|
if ( !IsInstantiatingOrCooking() )
|
|
{
|
|
bManualRecookRequested = true;
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( GetAssetId() ) )
|
|
{
|
|
StartHoudiniTicking();
|
|
}
|
|
else
|
|
{
|
|
if ( bLoadedComponent )
|
|
{
|
|
// This is a loaded component which requires instantiation.
|
|
StartTaskAssetInstantiation( true, true );
|
|
bParametersChanged = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetResetManual()
|
|
{
|
|
if ( !IsInstantiatingOrCooking() )
|
|
{
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( GetAssetId() ) )
|
|
{
|
|
if ( FHoudiniEngineUtils::SetAssetPreset( GetAssetId(), DefaultPresetBuffer ) )
|
|
{
|
|
UnmarkChangedParameters();
|
|
StartTaskAssetCookingManual();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( bLoadedComponent )
|
|
{
|
|
// This is a loaded component which requires instantiation.
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
bParametersChanged = true;
|
|
|
|
// Replace serialized preset buffer with default preset buffer.
|
|
PresetBuffer = DefaultPresetBuffer;
|
|
StartHoudiniTicking();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetRebuildManual()
|
|
{
|
|
if ( !IsInstantiatingOrCooking() )
|
|
{
|
|
if ( FHoudiniEngineUtils::IsHoudiniNodeValid( AssetId ) )
|
|
{
|
|
if ( !FHoudiniEngineUtils::GetAssetPreset( AssetId, PresetBuffer ) )
|
|
{
|
|
HOUDINI_LOG_WARNING(TEXT("Failed to get the asset's preset, rebuilt asset may have lost its parameters."));
|
|
}
|
|
|
|
// We need to delete the asset and request a new one.
|
|
StartTaskAssetDeletion();
|
|
}
|
|
|
|
HapiGUID = FGuid::NewGuid();
|
|
|
|
// If this is a loaded component, then we just need to instantiate.
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
bParametersChanged = true;
|
|
bManualRecookRequested = true;
|
|
|
|
StartHoudiniTicking();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetDeletion()
|
|
{
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( AssetId ) && bIsNativeComponent )
|
|
{
|
|
// Get the Asset's NodeInfo
|
|
HAPI_NodeInfo AssetNodeInfo;
|
|
FHoudiniApi::NodeInfo_Init(&AssetNodeInfo);
|
|
FHoudiniApi::GetNodeInfo(
|
|
FHoudiniEngine::Get().GetSession(), AssetId, &AssetNodeInfo );
|
|
|
|
HAPI_NodeId OBJNodeToDelete = AssetId;
|
|
if ( AssetNodeInfo.type == HAPI_NODETYPE_SOP )
|
|
{
|
|
// For SOP Asset, we want to delete their parent's OBJ node
|
|
HAPI_NodeId ParentId = FHoudiniEngineUtils::HapiGetParentNodeId( AssetId );
|
|
OBJNodeToDelete = ParentId != -1 ? ParentId : AssetId;
|
|
}
|
|
|
|
// Generate GUID for our new task.
|
|
FGuid HapiDeletionGUID = FGuid::NewGuid();
|
|
|
|
// Create asset deletion task object and submit it for processing.
|
|
FHoudiniEngineTask Task( EHoudiniEngineTaskType::AssetDeletion, HapiDeletionGUID );
|
|
Task.AssetId = OBJNodeToDelete;
|
|
FHoudiniEngine::Get().AddTask( Task );
|
|
|
|
// Reset asset id
|
|
AssetId = -1;
|
|
|
|
// We do not need to tick as we are not interested in result.
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::StartTaskAssetCooking( bool bStartTicking )
|
|
{
|
|
if ( !IsInstantiatingOrCooking() )
|
|
{
|
|
if (!FHoudiniEngineUtils::IsValidNodeId(AssetId))
|
|
return;
|
|
|
|
// Generate GUID for our new task.
|
|
HapiGUID = FGuid::NewGuid();
|
|
|
|
FHoudiniEngineTask Task( EHoudiniEngineTaskType::AssetCooking, HapiGUID );
|
|
Task.ActorName = GetOuter()->GetName();
|
|
Task.AssetId = GetAssetId();
|
|
FHoudiniEngine::Get().AddTask( Task );
|
|
|
|
if ( bStartTicking )
|
|
StartHoudiniTicking();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ResetHoudiniResources()
|
|
{
|
|
if ( HapiGUID.IsValid() )
|
|
{
|
|
// If we have a valid task GUID.
|
|
FHoudiniEngineTaskInfo TaskInfo;
|
|
|
|
if ( FHoudiniEngine::Get().RetrieveTaskInfo( HapiGUID, TaskInfo ) )
|
|
{
|
|
FHoudiniEngine::Get().RemoveTaskInfo( HapiGUID );
|
|
HapiGUID.Invalidate();
|
|
StopHoudiniTicking();
|
|
|
|
// Get settings.
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
|
|
// Check whether we want to display Slate cooking and instantiation notifications.
|
|
bool bDisplaySlateCookingNotifications = false;
|
|
if ( HoudiniRuntimeSettings )
|
|
bDisplaySlateCookingNotifications = HoudiniRuntimeSettings->bDisplaySlateCookingNotifications;
|
|
|
|
if ( NotificationPtr.IsValid() && bDisplaySlateCookingNotifications )
|
|
{
|
|
TSharedPtr< SNotificationItem > NotificationItem = NotificationPtr.Pin();
|
|
if ( NotificationItem.IsValid() )
|
|
{
|
|
NotificationItem->ExpireAndFadeout();
|
|
NotificationPtr.Reset();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start asset deletion.
|
|
StartTaskAssetDeletion();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SubscribeEditorDelegates()
|
|
{
|
|
// Add delegate for viewport drag and drop events.
|
|
DelegateHandleApplyObjectToActor =
|
|
FEditorDelegates::OnApplyObjectToActor.AddUObject( this, &UHoudiniAssetComponent::OnApplyObjectToActor );
|
|
|
|
if ( GEditor )
|
|
{
|
|
// Add delegate for asset post import.
|
|
if (UImportSubsystem* ImportSys = GEditor->GetEditorSubsystem<UImportSubsystem>())
|
|
{
|
|
ImportSys->OnAssetPostImport.AddUObject(this, &UHoudiniAssetComponent::OnAssetPostImport);
|
|
}
|
|
|
|
// Add delegate for actor moved.
|
|
GEditor->OnActorMoved().AddUObject( this, &UHoudiniAssetComponent::OnActorMoved );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UnsubscribeEditorDelegates()
|
|
{
|
|
// Remove delegate for viewport drag and drop events.
|
|
FEditorDelegates::OnApplyObjectToActor.Remove( DelegateHandleApplyObjectToActor );
|
|
|
|
if ( GEditor )
|
|
{
|
|
// Remove delegate for asset post import.
|
|
if (UImportSubsystem* ImportSys = GEditor->GetEditorSubsystem<UImportSubsystem>())
|
|
{
|
|
ImportSys->OnAssetPostImport.Remove(DelegateHandleAssetPostImport);
|
|
}
|
|
|
|
// Remove delegate for actor moved.
|
|
GEditor->OnActorMoved().RemoveAll( this );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostEditChangeProperty( FPropertyChangedEvent & PropertyChangedEvent )
|
|
{
|
|
Super::PostEditChangeProperty( PropertyChangedEvent );
|
|
|
|
if (!bIsNativeComponent)
|
|
return;
|
|
|
|
FProperty * Property = PropertyChangedEvent.MemberProperty;
|
|
if ( !Property )
|
|
return;
|
|
|
|
if ( Property->GetName() == TEXT( "Mobility" ) )
|
|
{
|
|
// Changed GetAttachChildren to 'GetAllDescendants' due to HoudiniMeshSplitInstanceComponent
|
|
// not propagating property changes to their own child StaticMeshComponents.
|
|
TArray< USceneComponent * > LocalAttachChildren;
|
|
GetChildrenComponents(true, LocalAttachChildren);
|
|
|
|
// Mobility was changed, we need to update it for all attached components as well.
|
|
for ( TArray< USceneComponent * >::TConstIterator Iter( LocalAttachChildren ); Iter; ++Iter)
|
|
{
|
|
USceneComponent * SceneComponent = *Iter;
|
|
SceneComponent->SetMobility( Mobility );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bVisible" ) )
|
|
{
|
|
// Visibility has changed, propagate it to children.
|
|
SetVisibility( IsVisible(), true );
|
|
return;
|
|
}
|
|
else if ( ( Property->GetName() == TEXT( "RelativeLocation" ) )
|
|
|| (Property->GetName() == TEXT( "RelativeRotation" ) )
|
|
|| (Property->GetName() == TEXT( "RelativeScale3D" ) ) )
|
|
{
|
|
// Location has changed
|
|
CheckedUploadTransform();
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bHiddenInGame" ) )
|
|
{
|
|
// Visibility has changed, propagate it to children.
|
|
SetHiddenInGame( bHiddenInGame, true );
|
|
return;
|
|
}
|
|
|
|
if ( Property->HasMetaData( TEXT( "Category" ) ) )
|
|
{
|
|
const FString & Category = Property->GetMetaData( TEXT( "Category" ) );
|
|
static const FString CategoryHoudiniGeneratedStaticMeshSettings = TEXT( "HoudiniGeneratedStaticMeshSettings" );
|
|
static const FString CategoryLighting = TEXT( "Lighting" );
|
|
static const FString CategoryRendering = TEXT( "Rendering" );
|
|
static const FString CategoryCollision = TEXT( "Collision" );
|
|
static const FString CategoryPhysics = TEXT("Physics");
|
|
static const FString CategoryLOD = TEXT("LOD");
|
|
|
|
if ( CategoryHoudiniGeneratedStaticMeshSettings == Category )
|
|
{
|
|
// We are changing one of the mesh generation properties, we need to update all static meshes.
|
|
// As the StaticMeshComponents map contains only top-level static mesh components only, use the StaticMeshes map instead
|
|
for (TMap< FHoudiniGeoPartObject, UStaticMesh * > ::TIterator Iter(StaticMeshes); Iter; ++Iter)
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
SetStaticMeshGenerationParameters( StaticMesh );
|
|
FHoudiniScopedGlobalSilence ScopedGlobalSilence;
|
|
StaticMesh->Build( true );
|
|
RefreshCollisionChange( *StaticMesh );
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if ( CategoryLighting == Category )
|
|
{
|
|
if ( Property->GetName() == TEXT( "CastShadow" ) )
|
|
{
|
|
// Stop cast-shadow being applied to invisible colliders children
|
|
// This prevent colliders only meshes from casting shadows
|
|
TArray< UActorComponent * > ReregisterComponents;
|
|
{
|
|
TArray< USceneComponent * > LocalAttachChildren;
|
|
GetChildrenComponents(true, LocalAttachChildren);
|
|
for (TArray< USceneComponent * >::TConstIterator Iter(LocalAttachChildren); Iter; ++Iter)
|
|
{
|
|
UStaticMeshComponent * Component = Cast< UStaticMeshComponent >(*Iter);
|
|
if (!Component || Component->IsPendingKill())
|
|
continue;
|
|
|
|
const FHoudiniGeoPartObject * pGeoPart = StaticMeshes.FindKey(Component->GetStaticMesh());
|
|
if (pGeoPart && pGeoPart->IsCollidable())
|
|
{
|
|
// This is an invisible collision mesh:
|
|
// Do not interfere with lightmap builds - disable shadow casting
|
|
Component->SetCastShadow(false);
|
|
}
|
|
else
|
|
{
|
|
// Set normally
|
|
Component->SetCastShadow(CastShadow);
|
|
}
|
|
|
|
ReregisterComponents.Add(Component);
|
|
}
|
|
}
|
|
|
|
if (ReregisterComponents.Num() > 0)
|
|
{
|
|
FMultiComponentReregisterContext MultiComponentReregisterContext(ReregisterComponents);
|
|
}
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastDynamicShadow" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastDynamicShadow );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastStaticShadow" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastStaticShadow );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastVolumetricTranslucentShadow" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastVolumetricTranslucentShadow );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastInsetShadow" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastInsetShadow );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastHiddenShadow" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastHiddenShadow );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bCastShadowAsTwoSided" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCastShadowAsTwoSided );
|
|
}
|
|
/*else if ( Property->GetName() == TEXT( "bLightAsIfStatic" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bLightAsIfStatic );
|
|
}*/
|
|
else if ( Property->GetName() == TEXT( "bLightAttachmentsAsGroup" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bLightAttachmentsAsGroup );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "IndirectLightingCacheQuality" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, IndirectLightingCacheQuality );
|
|
}
|
|
}
|
|
else if ( CategoryRendering == Category )
|
|
{
|
|
if ( Property->GetName() == TEXT( "bVisibleInReflectionCaptures" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bVisibleInReflectionCaptures );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bRenderInMainPass" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bRenderInMainPass );
|
|
}
|
|
/*
|
|
else if ( Property->GetName() == TEXT( "bRenderInMono" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bRenderInMono );
|
|
}
|
|
*/
|
|
else if ( Property->GetName() == TEXT( "bOwnerNoSee" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bOwnerNoSee );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bOnlyOwnerSee" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bOnlyOwnerSee );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bTreatAsBackgroundForOcclusion" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bTreatAsBackgroundForOcclusion );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bUseAsOccluder" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bUseAsOccluder );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bRenderCustomDepth" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bRenderCustomDepth );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "CustomDepthStencilValue" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, CustomDepthStencilValue );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "CustomDepthStencilWriteMask" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, CustomDepthStencilWriteMask );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "TranslucencySortPriority" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, TranslucencySortPriority );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "LpvBiasMultiplier" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, LpvBiasMultiplier );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bReceivesDecals" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bReceivesDecals );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "BoundsScale" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, BoundsScale );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bUseAttachParentBound" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( USceneComponent, bUseAttachParentBound);
|
|
}
|
|
}
|
|
else if ( CategoryCollision == Category )
|
|
{
|
|
if ( Property->GetName() == TEXT( "bAlwaysCreatePhysicsState" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bAlwaysCreatePhysicsState );
|
|
}
|
|
/*else if ( Property->GetName() == TEXT( "bGenerateOverlapEvents" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bGenerateOverlapEvents );
|
|
}*/
|
|
else if ( Property->GetName() == TEXT( "bMultiBodyOverlap" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bMultiBodyOverlap );
|
|
}
|
|
/*
|
|
else if ( Property->GetName() == TEXT( "bCheckAsyncSceneOnMove" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bCheckAsyncSceneOnMove );
|
|
}
|
|
*/
|
|
else if ( Property->GetName() == TEXT( "bTraceComplexOnMove" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bTraceComplexOnMove );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bReturnMaterialOnMove" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bReturnMaterialOnMove );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "BodyInstance" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, BodyInstance );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "CanCharacterStepUpOn" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, CanCharacterStepUpOn );
|
|
}
|
|
/*else if ( Property->GetName() == TEXT( "bCanEverAffectNavigation" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UActorComponent, bCanEverAffectNavigation );
|
|
}*/
|
|
}
|
|
else if ( CategoryPhysics == Category )
|
|
{
|
|
if ( Property->GetName() == TEXT( "bIgnoreRadialImpulse" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bIgnoreRadialImpulse );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bIgnoreRadialForce" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bIgnoreRadialForce );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bApplyImpulseOnDamage" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bApplyImpulseOnDamage );
|
|
}
|
|
/*
|
|
else if ( Property->GetName() == TEXT( "bShouldUpdatePhysicsVolume" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( USceneComponent, bShouldUpdatePhysicsVolume );
|
|
}
|
|
*/
|
|
}
|
|
else if ( CategoryLOD == Category )
|
|
{
|
|
if ( Property->GetName() == TEXT( "MinDrawDistance" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, MinDrawDistance );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "LDMaxDrawDistance" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, LDMaxDrawDistance );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "CachedMaxDrawDistance" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, CachedMaxDrawDistance );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "bAllowCullDistanceVolume" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( UPrimitiveComponent, bAllowCullDistanceVolume );
|
|
}
|
|
else if ( Property->GetName() == TEXT( "DetailMode" ) )
|
|
{
|
|
HOUDINI_UPDATE_ALL_CHILD_COMPONENTS( USceneComponent, DetailMode );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::RemoveAllAttachedComponents()
|
|
{
|
|
while ( true )
|
|
{
|
|
const int32 ChildCount = GetAttachChildren().Num();
|
|
if ( ChildCount <= 0 )
|
|
break;
|
|
|
|
USceneComponent * Component = GetAttachChildren()[ ChildCount - 1 ];
|
|
|
|
Component->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
|
|
Component->UnregisterComponent();
|
|
Component->DestroyComponent();
|
|
}
|
|
|
|
check( GetAttachChildren().Num() == 0 );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnComponentClipboardCopy( UHoudiniAssetComponent * HoudiniAssetComponent )
|
|
{
|
|
// Store copied component.
|
|
CopiedHoudiniComponent = HoudiniAssetComponent;
|
|
|
|
if ( bIsNativeComponent )
|
|
{
|
|
// This component has been loaded.
|
|
bLoadedComponent = true;
|
|
bFullyLoaded = false;
|
|
}
|
|
|
|
// Mark this component as imported.
|
|
bComponentCopyImported = true;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnAssetPostImport( UFactory * Factory, UObject * Object )
|
|
{
|
|
if (!bComponentCopyImported || !CopiedHoudiniComponent.IsValid() )
|
|
return;
|
|
|
|
// Show busy cursor.
|
|
FScopedBusyCursor ScopedBusyCursor;
|
|
|
|
// Copy the original scale - this gets lost sometimes in the copy/paste procedure
|
|
SetWorldScale3D( CopiedHoudiniComponent->GetComponentScale() );
|
|
|
|
// Copy mobility
|
|
SetMobility( CopiedHoudiniComponent->Mobility );
|
|
|
|
// Get original asset id.
|
|
HAPI_NodeId CopiedHoudiniComponentAssetId = CopiedHoudiniComponent->AssetId;
|
|
|
|
// Set Houdini asset.
|
|
HoudiniAsset = CopiedHoudiniComponent->HoudiniAsset;
|
|
|
|
// Copy preset buffer.
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( CopiedHoudiniComponentAssetId ) )
|
|
FHoudiniEngineUtils::GetAssetPreset( CopiedHoudiniComponentAssetId, PresetBuffer );
|
|
else
|
|
PresetBuffer = CopiedHoudiniComponent->PresetBuffer;
|
|
|
|
// Copy default preset buffer.
|
|
DefaultPresetBuffer = CopiedHoudiniComponent->DefaultPresetBuffer;
|
|
|
|
// Clean up all generated and auto-attached components.
|
|
RemoveAllAttachedComponents();
|
|
|
|
// Release static mesh related resources.
|
|
ReleaseObjectGeoPartResources( StaticMeshes );
|
|
StaticMeshes.Empty();
|
|
StaticMeshComponents.Empty();
|
|
|
|
TMap<UObject*, UObject*> ReplacementMap;
|
|
|
|
// We need to reconstruct geometry from copied actor.
|
|
for( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( CopiedHoudiniComponent->StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
// Prevents the default Houdini logo mesh from being duplicated and saved into sub-levels
|
|
const UStaticMesh * HoudiniLogoMesh = FHoudiniEngine::Get().GetHoudiniLogoStaticMesh().Get();
|
|
if (StaticMesh == HoudiniLogoMesh)
|
|
{
|
|
HOUDINI_LOG_WARNING(TEXT("Ignoring HoudiniAsset duplication of default logo static mesh."));
|
|
continue;
|
|
}
|
|
|
|
// Duplicate static mesh and all related generated Houdini materials and textures.
|
|
UStaticMesh * DuplicatedStaticMesh =
|
|
FHoudiniEngineBakeUtils::DuplicateStaticMeshAndCreatePackage( StaticMesh, this, HoudiniGeoPartObject, FHoudiniCookParams::GetDefaultStaticMeshesCookMode() );
|
|
|
|
if( DuplicatedStaticMesh && !DuplicatedStaticMesh->IsPendingKill() )
|
|
{
|
|
// Store this duplicated mesh.
|
|
StaticMeshes.Add( FHoudiniGeoPartObject( HoudiniGeoPartObject, true ), DuplicatedStaticMesh );
|
|
ReplacementMap.Add( StaticMesh, DuplicatedStaticMesh );
|
|
}
|
|
}
|
|
|
|
// Copy material information.
|
|
HoudiniAssetComponentMaterials = CopiedHoudiniComponent->HoudiniAssetComponentMaterials->Duplicate( this, ReplacementMap );
|
|
|
|
// Copy parameters.
|
|
{
|
|
ClearParameters();
|
|
CopiedHoudiniComponent->DuplicateParameters( this );
|
|
}
|
|
|
|
// Copy inputs.
|
|
{
|
|
ClearInputs();
|
|
CopiedHoudiniComponent->DuplicateInputs( this );
|
|
}
|
|
|
|
// Copy instance inputs.
|
|
{
|
|
ClearInstanceInputs();
|
|
CopiedHoudiniComponent->DuplicateInstanceInputs( this, ReplacementMap );
|
|
}
|
|
|
|
// We need to reconstruct splines.
|
|
for( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TIterator
|
|
Iter( CopiedHoudiniComponent->SplineComponents ); Iter; ++Iter )
|
|
{
|
|
FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
UHoudiniSplineComponent * HoudiniSplineComponent = Iter.Value();
|
|
if ( !HoudiniSplineComponent || !HoudiniSplineComponent->IsValidLowLevel() )
|
|
continue;
|
|
|
|
// Duplicate spline component.
|
|
UHoudiniSplineComponent * DuplicatedSplineComponent =
|
|
DuplicateObject< UHoudiniSplineComponent >( HoudiniSplineComponent, this );
|
|
|
|
if ( DuplicatedSplineComponent )
|
|
{
|
|
DuplicatedSplineComponent->SetFlags( RF_Transactional | RF_Public );
|
|
SplineComponents.Add( HoudiniGeoPartObject, DuplicatedSplineComponent );
|
|
}
|
|
}
|
|
|
|
/*
|
|
// We need to duplicate landscapes.
|
|
for ( TMap< FHoudiniGeoPartObject, ALandscapeProxy * >::TIterator
|
|
Iter(CopiedHoudiniComponent->LandscapeComponents); Iter; ++Iter)
|
|
{
|
|
FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value();
|
|
|
|
// Duplicate landscape component.
|
|
ALandscapeProxy * DuplicatedLandscape =
|
|
DuplicateObject< ALandscapeProxy >( HoudiniLandscape, this );
|
|
|
|
if ( DuplicatedLandscape )
|
|
{
|
|
DuplicatedLandscape->SetFlags(RF_Transactional | RF_Public);
|
|
LandscapeComponents.Add(HoudiniGeoPartObject, DuplicatedLandscape);
|
|
}
|
|
}
|
|
*/
|
|
|
|
// We cannot duplicate landscape for now...
|
|
// we will have to recook the asset to recreate them
|
|
bool bNeedsRecook = false;
|
|
if ( CopiedHoudiniComponent->LandscapeComponents.Num() > 0 )
|
|
bNeedsRecook = true;
|
|
|
|
// Perform any necessary post loading.
|
|
PostLoad();
|
|
|
|
DuplicateHandles( CopiedHoudiniComponent.Get() );
|
|
|
|
// Mark this component as no longer copy imported and reset copied component.
|
|
bComponentCopyImported = false;
|
|
CopiedHoudiniComponent = nullptr;
|
|
|
|
if ( bNeedsRecook )
|
|
StartTaskAssetCookingManual();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnApplyObjectToActor( UObject* ObjectToApply, AActor * ActorToApplyTo )
|
|
{
|
|
if ( GetHoudiniAssetActorOwner() != ActorToApplyTo )
|
|
return;
|
|
|
|
// We want to handle material replacements.
|
|
UMaterialInterface * Material = Cast< UMaterialInterface >( ObjectToApply );
|
|
if (!Material)
|
|
return;
|
|
|
|
bool bMaterialReplaced = false;
|
|
|
|
TMap< UStaticMesh*, int32 > MaterialReplacementsMap;
|
|
|
|
// We need to detect which components have material overriden, and replace it on their corresponding
|
|
// generated static meshes.
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Key();
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
|
|
if ( !StaticMeshComponent || !StaticMesh || StaticMeshComponent->IsPendingKill() || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
const TArray< class UMaterialInterface * > & OverrideMaterials = StaticMeshComponent->OverrideMaterials;
|
|
for ( int32 MaterialIdx = 0; MaterialIdx < OverrideMaterials.Num(); ++MaterialIdx )
|
|
{
|
|
UMaterialInterface * OverridenMaterial = OverrideMaterials[ MaterialIdx ];
|
|
if ( OverridenMaterial && OverridenMaterial == Material )
|
|
{
|
|
if ( MaterialIdx < StaticMesh->StaticMaterials.Num() )
|
|
MaterialReplacementsMap.Add( StaticMesh, MaterialIdx );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if ( InstanceInput && !InstanceInput->IsPendingKill() )
|
|
InstanceInput->GetMaterialReplacementMeshes( Material, MaterialReplacementsMap );
|
|
}
|
|
|
|
if (MaterialReplacementsMap.Num() <= 0)
|
|
return;
|
|
|
|
FScopedTransaction Transaction(
|
|
TEXT( HOUDINI_MODULE_RUNTIME ),
|
|
LOCTEXT( "HoudiniMaterialReplacement", "Houdini Material Replacement" ), this );
|
|
|
|
for ( TMap< UStaticMesh *, int32 >::TIterator Iter( MaterialReplacementsMap ); Iter; ++Iter )
|
|
{
|
|
UStaticMesh * StaticMesh = Iter.Key();
|
|
int32 MaterialIdx = Iter.Value();
|
|
|
|
// Get old material.
|
|
UMaterialInterface * OldMaterial = StaticMesh->StaticMaterials[ MaterialIdx ].MaterialInterface;
|
|
|
|
// Locate geo part object.
|
|
FHoudiniGeoPartObject HoudiniGeoPartObject = LocateGeoPartObject( StaticMesh );
|
|
if ( !HoudiniGeoPartObject.IsValid() )
|
|
continue;
|
|
|
|
if ( ReplaceMaterial( HoudiniGeoPartObject, Material, OldMaterial, MaterialIdx ) )
|
|
{
|
|
StaticMesh->Modify();
|
|
StaticMesh->StaticMaterials[ MaterialIdx ].MaterialInterface = Material;
|
|
|
|
StaticMesh->PreEditChange( nullptr );
|
|
StaticMesh->PostEditChange();
|
|
StaticMesh->MarkPackageDirty();
|
|
|
|
UStaticMeshComponent * StaticMeshComponent = LocateStaticMeshComponent( StaticMesh );
|
|
if ( StaticMeshComponent )
|
|
{
|
|
StaticMeshComponent->Modify();
|
|
StaticMeshComponent->SetMaterial( MaterialIdx, Material );
|
|
|
|
bMaterialReplaced = true;
|
|
}
|
|
|
|
TArray< UInstancedStaticMeshComponent * > InstancedStaticMeshComponents;
|
|
if ( LocateInstancedStaticMeshComponents( StaticMesh, InstancedStaticMeshComponents ) )
|
|
{
|
|
for ( int32 Idx = 0; Idx < InstancedStaticMeshComponents.Num(); ++Idx )
|
|
{
|
|
UInstancedStaticMeshComponent * InstancedStaticMeshComponent = InstancedStaticMeshComponents[ Idx ];
|
|
|
|
if ( InstancedStaticMeshComponent )
|
|
{
|
|
InstancedStaticMeshComponent->Modify();
|
|
InstancedStaticMeshComponent->SetMaterial( MaterialIdx, Material );
|
|
|
|
bMaterialReplaced = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bMaterialReplaced )
|
|
UpdateEditorProperties( false );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnActorMoved( AActor* Actor )
|
|
{
|
|
if ( GetOwner() == Actor )
|
|
{
|
|
CheckedUploadTransform();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateDefaultPreset()
|
|
{
|
|
if ( !bLoadedComponent && !FHoudiniEngineUtils::GetAssetPreset( GetAssetId(), DefaultPresetBuffer ) )
|
|
DefaultPresetBuffer.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnUpdateTransform( EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport )
|
|
{
|
|
Super::OnUpdateTransform( UpdateTransformFlags, Teleport );
|
|
|
|
CheckedUploadTransform();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CheckedUploadTransform()
|
|
{
|
|
// Only if the asset is done loading, else this might cause a cook
|
|
// upon loading a map if the asset has TransformChangeTRiggersCook enabled
|
|
if ( !bFullyLoaded )
|
|
return;
|
|
|
|
// If we have to upload transforms.
|
|
if ( bUploadTransformsToHoudiniEngine && AssetCookCount > 0 )
|
|
{
|
|
// Retrieve the current component-to-world transform for this component.
|
|
if ( !FHoudiniEngineUtils::HapiSetAssetTransform( AssetId, GetComponentTransform() ) )
|
|
HOUDINI_LOG_MESSAGE( TEXT( "Failed Uploading Transformation change back to HAPI." ) );
|
|
}
|
|
|
|
// If transforms trigger cooks, we need to schedule a cook.
|
|
if ( bTransformChangeTriggersCooks )
|
|
{
|
|
// If we have landscape inputs in auto select components mode, we need to mark them
|
|
// as changed so to recommit the landscape properly with updated transforms
|
|
bool NeedLandscapeUpdate = false;
|
|
for (int32 InputIdx = 0; InputIdx < Inputs.Num(); ++InputIdx)
|
|
{
|
|
// Retrieve input at this index.
|
|
UHoudiniAssetInput * AssetInput = Inputs[InputIdx];
|
|
if (!AssetInput || AssetInput->IsPendingKill())
|
|
continue;
|
|
|
|
if (!AssetInput->IsLandscapeUpdateNeededOnTransformChange())
|
|
continue;
|
|
|
|
NeedLandscapeUpdate = true;
|
|
AssetInput->MarkChanged();
|
|
}
|
|
|
|
if (bLoadedComponent && !FHoudiniEngineUtils::IsValidNodeId(AssetId) && !bAssetIsBeingInstantiated)
|
|
StartTaskAssetCookingManual();
|
|
|
|
bComponentNeedsCook = true;
|
|
StartHoudiniTicking();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetBakingBaseNameOverride( const FHoudiniGeoPartObject& GeoPartObject, const FString& BaseName )
|
|
{
|
|
if( const FString* FoundOverride = BakeNameOverrides.Find( GeoPartObject ) )
|
|
{
|
|
// forget the last baked package since we changed the name
|
|
if( *FoundOverride != BaseName )
|
|
{
|
|
BakedStaticMeshPackagesForParts.Remove( GeoPartObject );
|
|
}
|
|
}
|
|
BakeNameOverrides.Add( GeoPartObject, BaseName );
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::RemoveBakingBaseNameOverride( const FHoudiniGeoPartObject& GeoPartObject )
|
|
{
|
|
return BakeNameOverrides.Remove( GeoPartObject ) > 0;
|
|
}
|
|
|
|
#endif // WITH_EDITOR
|
|
|
|
FText
|
|
UHoudiniAssetComponent::GetBakeFolder() const
|
|
{
|
|
// Empty indicates default - which is Content root
|
|
if( BakeFolder.IsEmpty() )
|
|
{
|
|
return LOCTEXT( "Game", "/Game" );
|
|
}
|
|
return BakeFolder;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetBakeFolder( const FString& Folder )
|
|
{
|
|
FText NewBakeFolder = FText::FromString( Folder );
|
|
if( !NewBakeFolder.EqualTo( BakeFolder ) )
|
|
{
|
|
BakeFolder = NewBakeFolder;
|
|
BakedStaticMeshPackagesForParts.Empty();
|
|
BakedMaterialPackagesForIds.Empty();
|
|
}
|
|
}
|
|
|
|
FText
|
|
UHoudiniAssetComponent::GetTempCookFolder() const
|
|
{
|
|
// Empty indicates default
|
|
if( TempCookFolder.IsEmpty() )
|
|
{
|
|
// Get runtime settings.
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
check( HoudiniRuntimeSettings );
|
|
|
|
return HoudiniRuntimeSettings->TemporaryCookFolder;
|
|
}
|
|
|
|
return TempCookFolder;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetTempCookFolder(const FString& Folder)
|
|
{
|
|
FText NewTempCookFolder = FText::FromString(Folder);
|
|
if (!NewTempCookFolder.EqualTo(TempCookFolder))
|
|
{
|
|
TempCookFolder = NewTempCookFolder;
|
|
}
|
|
}
|
|
|
|
FString UHoudiniAssetComponent::GetBakingBaseName( const FHoudiniGeoPartObject& GeoPartObject ) const
|
|
{
|
|
if( const FString* FoundOverride = BakeNameOverrides.Find( GeoPartObject ) )
|
|
{
|
|
return *FoundOverride;
|
|
}
|
|
if( GeoPartObject.HasCustomName() )
|
|
{
|
|
return GeoPartObject.PartName;
|
|
}
|
|
|
|
FString DisplayName;
|
|
if (GetOwner())
|
|
DisplayName = GetOwner()->GetName();
|
|
else
|
|
DisplayName = GetName();
|
|
|
|
return FString::Printf( TEXT( "%s_%d_%d_%d_%d" ),
|
|
*DisplayName,
|
|
GeoPartObject.ObjectId, GeoPartObject.GeoId,
|
|
GeoPartObject.PartId, GeoPartObject.SplitId );
|
|
}
|
|
|
|
FBoxSphereBounds
|
|
UHoudiniAssetComponent::CalcBounds( const FTransform & LocalToWorld ) const
|
|
{
|
|
FBoxSphereBounds LocalBounds;
|
|
FBox BoundingBox = GetAssetBounds();
|
|
if ( BoundingBox.GetExtent() == FVector::ZeroVector )
|
|
BoundingBox.ExpandBy( 1.0f );
|
|
|
|
LocalBounds = FBoxSphereBounds( BoundingBox );
|
|
// fix for offset bounds - maintain local bounds origin
|
|
LocalBounds.TransformBy(LocalToWorld);
|
|
|
|
const auto & LocalAttachedChildren = GetAttachChildren();
|
|
for (int32 Idx = 0; Idx < LocalAttachedChildren.Num(); ++Idx)
|
|
{
|
|
if ( !LocalAttachedChildren[ Idx ] )
|
|
continue;
|
|
|
|
FBoxSphereBounds ChildBounds = LocalAttachedChildren[ Idx ]->CalcBounds( LocalToWorld );
|
|
if ( !ChildBounds.ContainsNaN() )
|
|
LocalBounds = LocalBounds + ChildBounds;
|
|
}
|
|
|
|
return LocalBounds;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UpdateRenderingInformation()
|
|
{
|
|
// Need to send this to render thread at some point.
|
|
MarkRenderStateDirty();
|
|
|
|
// Update physics representation right away.
|
|
RecreatePhysicsState();
|
|
|
|
// Changed GetAttachChildren to 'GetAllDescendants' due to HoudiniMeshSplitInstanceComponent
|
|
// not propagating property changes to their own child StaticMeshComponents.
|
|
TArray< USceneComponent * > LocalAttachChildren;
|
|
GetChildrenComponents(true, LocalAttachChildren);
|
|
for ( TArray< USceneComponent * >::TConstIterator Iter( LocalAttachChildren ); Iter; ++Iter )
|
|
{
|
|
USceneComponent * SceneComponent = *Iter;
|
|
if( SceneComponent )
|
|
SceneComponent->RecreatePhysicsState();
|
|
}
|
|
|
|
// Since we have new asset, we need to update bounds.
|
|
UpdateBounds();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostLoadReattachComponents()
|
|
{
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( StaticMeshComponent && !StaticMeshComponent->IsPendingKill() )
|
|
StaticMeshComponent->AttachToComponent( this, FAttachmentTransformRules::KeepRelativeTransform );
|
|
}
|
|
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TIterator Iter( SplineComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniSplineComponent * HoudiniSplineComponent = Iter.Value();
|
|
if( HoudiniSplineComponent && HoudiniSplineComponent->IsValidLowLevel() )
|
|
HoudiniSplineComponent->AttachToComponent( this, FAttachmentTransformRules::KeepRelativeTransform );
|
|
}
|
|
|
|
for ( TMap< FString, UHoudiniHandleComponent * >::TIterator Iter( HandleComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniHandleComponent * HoudiniHandleComponent = Iter.Value();
|
|
if ( HoudiniHandleComponent && !HoudiniHandleComponent->IsPendingKill() )
|
|
HoudiniHandleComponent->AttachToComponent( this, FAttachmentTransformRules::KeepRelativeTransform );
|
|
}
|
|
|
|
for (TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TIterator Iter(LandscapeComponents); Iter; ++Iter)
|
|
{
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value().Get();
|
|
if ( HoudiniLandscape && HoudiniLandscape->IsValidLowLevel() )
|
|
HoudiniLandscape->AttachToComponent(this, FAttachmentTransformRules::KeepRelativeTransform);
|
|
}
|
|
}
|
|
|
|
|
|
#if WITH_EDITOR
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnComponentCreated()
|
|
{
|
|
// This event will only be fired for native Actor and native Component.
|
|
Super::OnComponentCreated();
|
|
|
|
if ( !GetOwner() || !GetOwner()->GetWorld() )
|
|
return;
|
|
|
|
if ( StaticMeshes.Num() == 0 )
|
|
{
|
|
// Create Houdini logo static mesh and component for it.
|
|
CreateStaticMeshHoudiniLogoResource( StaticMeshes );
|
|
}
|
|
|
|
// Create replacement material object.
|
|
if ( !HoudiniAssetComponentMaterials )
|
|
{
|
|
HoudiniAssetComponentMaterials =
|
|
NewObject< UHoudiniAssetComponentMaterials >(
|
|
this, UHoudiniAssetComponentMaterials::StaticClass(), NAME_None, RF_Public | RF_Transactional );
|
|
}
|
|
|
|
// Subscribe to delegates.
|
|
SubscribeEditorDelegates();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnComponentDestroyed( bool bDestroyingHierarchy )
|
|
{
|
|
// Release static mesh related resources.
|
|
ReleaseObjectGeoPartResources( StaticMeshes );
|
|
StaticMeshes.Empty();
|
|
StaticMeshComponents.Empty();
|
|
|
|
// Release all curve related resources.
|
|
ClearCurves();
|
|
|
|
// Destroy all parameters.
|
|
ClearParameters();
|
|
|
|
// Destroy all inputs.
|
|
ClearInputs();
|
|
|
|
// Destroy all instance inputs.
|
|
ClearInstanceInputs();
|
|
|
|
// Destroy all handles.
|
|
ClearHandles();
|
|
|
|
// Destroy all landscapes.
|
|
ClearLandscapes();
|
|
|
|
// Inform downstream assets that we are dieing.
|
|
ClearDownstreamAssets();
|
|
|
|
// Clear cook content temp file
|
|
ClearCookTempFile();
|
|
|
|
// Release all Houdini related resources.
|
|
ResetHoudiniResources();
|
|
|
|
// Unsubscribe from Editor events.
|
|
UnsubscribeEditorDelegates();
|
|
|
|
Super::OnComponentDestroyed( bDestroyingHierarchy );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::OnRegister()
|
|
{
|
|
Super::OnRegister();
|
|
|
|
// We need to recreate render states for loaded components.
|
|
if ( bLoadedComponent )
|
|
{
|
|
// Static meshes.
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( StaticMeshComponent && !StaticMeshComponent->IsPendingKill() )
|
|
{
|
|
// Recreate render state.
|
|
StaticMeshComponent->RecreateRenderState_Concurrent();
|
|
|
|
// Need to recreate physics state.
|
|
StaticMeshComponent->RecreatePhysicsState();
|
|
}
|
|
}
|
|
|
|
// Instanced static meshes.
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if (!InstanceInput || InstanceInput->IsPendingKill())
|
|
continue;
|
|
|
|
// Recreate render state.
|
|
InstanceInput->RecreateRenderStates();
|
|
|
|
// Recreate physics state.
|
|
InstanceInput->RecreatePhysicsStates();
|
|
}
|
|
}
|
|
|
|
// We can now consider the asset as fully loaded
|
|
bFullyLoaded = true;
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
UHoudiniAssetComponent::ContainsHoudiniLogoGeometry() const
|
|
{
|
|
return bContainsHoudiniLogoGeometry;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateStaticMeshHoudiniLogoResource( TMap< FHoudiniGeoPartObject, UStaticMesh * > & StaticMeshMap )
|
|
{
|
|
if ( !bIsNativeComponent )
|
|
return;
|
|
|
|
// Create Houdini logo static mesh and component for it.
|
|
FHoudiniGeoPartObject HoudiniGeoPartObject;
|
|
StaticMeshMap.Add( HoudiniGeoPartObject, FHoudiniEngine::Get().GetHoudiniLogoStaticMesh().Get() );
|
|
CreateObjectGeoPartResources( StaticMeshMap );
|
|
bContainsHoudiniLogoGeometry = true;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
void
|
|
UHoudiniAssetComponent::PostLoad()
|
|
{
|
|
Super::PostLoad();
|
|
|
|
// If we are being cooked, we don't want to do anything
|
|
if( GIsCookerLoadingPackage )
|
|
return;
|
|
|
|
// Only do PostLoad stuff if we are in the editor world
|
|
if( UWorld* World = GetWorld() )
|
|
{
|
|
if( World->WorldType != EWorldType::Editor && World->WorldType != EWorldType::Inactive )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we aren't in _any_ world - how unusual
|
|
return;
|
|
}
|
|
|
|
SanitizePostLoad();
|
|
|
|
// We loaded a component which has no asset associated with it.
|
|
if ( !HoudiniAsset && StaticMeshes.Num() <= 0)
|
|
{
|
|
// Set geometry to be Houdini logo geometry, since we have no other geometry.
|
|
CreateStaticMeshHoudiniLogoResource( StaticMeshes );
|
|
return;
|
|
}
|
|
|
|
// Show busy cursor.
|
|
FScopedBusyCursor ScopedBusyCursor;
|
|
|
|
if ( StaticMeshes.Num() > 0 )
|
|
{
|
|
CreateObjectGeoPartResources( StaticMeshes );
|
|
}
|
|
else
|
|
{
|
|
// If the only component our owner has is us, then we should show the logo mesh
|
|
TArray< USceneComponent* > AllSceneComponents;
|
|
if(GetOwner())
|
|
GetOwner()->GetComponents<USceneComponent>(AllSceneComponents);
|
|
|
|
if (AllSceneComponents.Num() == 1 )
|
|
{
|
|
CreateStaticMeshHoudiniLogoResource( StaticMeshes );
|
|
}
|
|
}
|
|
|
|
// Perform post load initialization on parameters.
|
|
PostLoadInitializeParameters();
|
|
|
|
// Perform post load initialization on instance inputs.
|
|
PostLoadInitializeInstanceInputs();
|
|
|
|
// Post attach components to parent asset component.
|
|
PostLoadReattachComponents();
|
|
|
|
// Update mobility.
|
|
// It'll be changed to static if we generated a landscape,
|
|
// and if not, to movable if any of our children is movable
|
|
UpdateMobility();
|
|
|
|
// Need to update rendering information.
|
|
UpdateRenderingInformation();
|
|
|
|
// Force editor to redraw viewports.
|
|
if ( GEditor )
|
|
GEditor->RedrawAllViewports();
|
|
|
|
// Update properties panel after instantiation.
|
|
UpdateEditorProperties( false );
|
|
}
|
|
#endif
|
|
|
|
void
|
|
UHoudiniAssetComponent::Serialize( FArchive & Ar )
|
|
{
|
|
Super::Serialize( Ar );
|
|
|
|
Ar.UsingCustomVersion( FHoudiniCustomSerializationVersion::GUID );
|
|
|
|
if ( !Ar.IsSaving() && !Ar.IsLoading() )
|
|
return;
|
|
|
|
// Serialize component flags.
|
|
Ar << HoudiniAssetComponentFlagsPacked;
|
|
|
|
// State of this component.
|
|
EHoudiniAssetComponentState::Enum ComponentState = EHoudiniAssetComponentState::Invalid;
|
|
|
|
if ( Ar.IsSaving() )
|
|
{
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( AssetId ) )
|
|
{
|
|
// Asset has been previously instantiated.
|
|
|
|
if ( HapiGUID.IsValid() )
|
|
{
|
|
// Asset is being re-cooked asynchronously.
|
|
ComponentState = EHoudiniAssetComponentState::BeingCooked;
|
|
}
|
|
else
|
|
{
|
|
// We have no pending asynchronous cook requests.
|
|
ComponentState = EHoudiniAssetComponentState::Instantiated;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( HoudiniAsset )
|
|
{
|
|
// Asset has not been instantiated and therefore must have asynchronous instantiation
|
|
// request in progress.
|
|
ComponentState = EHoudiniAssetComponentState::None;
|
|
}
|
|
else
|
|
{
|
|
// Component is in invalid state (for example is a default class object).
|
|
ComponentState = EHoudiniAssetComponentState::Invalid;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Serialize format version.
|
|
uint32 HoudiniAssetComponentVersion = Ar.CustomVer( FHoudiniCustomSerializationVersion::GUID );
|
|
Ar << HoudiniAssetComponentVersion;
|
|
|
|
// Serialize component state.
|
|
SerializeEnumeration< EHoudiniAssetComponentState::Enum >( Ar, ComponentState );
|
|
|
|
// Serialize scaling information and import axis.
|
|
Ar << GeneratedGeometryScaleFactor;
|
|
Ar << TransformScaleFactor;
|
|
SerializeEnumeration< EHoudiniRuntimeSettingsAxisImport >( Ar, ImportAxis );
|
|
|
|
// Serialize generated component GUID.
|
|
Ar << ComponentGUID;
|
|
|
|
// If component is in invalid state, we can skip the rest of serialization.
|
|
if ( ComponentState == EHoudiniAssetComponentState::Invalid )
|
|
return;
|
|
|
|
// If we have no asset, we can stop.
|
|
if ( !HoudiniAsset && Ar.IsSaving() )
|
|
return;
|
|
|
|
// Serialize Houdini asset.
|
|
UHoudiniAsset * HoudiniSerializedAsset = nullptr;
|
|
|
|
if ( Ar.IsSaving() )
|
|
HoudiniSerializedAsset = HoudiniAsset;
|
|
|
|
Ar << HoudiniSerializedAsset;
|
|
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
if ( Ar.IsTransacting() && HoudiniAsset != HoudiniSerializedAsset )
|
|
{
|
|
bTransactionAssetChange = true;
|
|
PreviousTransactionHoudiniAsset = HoudiniAsset;
|
|
}
|
|
|
|
HoudiniAsset = HoudiniSerializedAsset;
|
|
}
|
|
|
|
// If we are going into playmode, save asset id.
|
|
// NOTE: bIsPlayModeActive_Unused is known to have been mistakenly saved to disk as ON,
|
|
// the following fixes that case - should only happen once when first loading
|
|
if( Ar.IsLoading() && bIsPlayModeActive_Unused )
|
|
{
|
|
HAPI_NodeId TempId;
|
|
Ar << TempId;
|
|
bIsPlayModeActive_Unused = false;
|
|
}
|
|
|
|
// Serialization of default preset.
|
|
Ar << DefaultPresetBuffer;
|
|
|
|
// Serialization of preset.
|
|
{
|
|
bool bPresetSaved = false;
|
|
|
|
if ( Ar.IsSaving() )
|
|
{
|
|
bPresetSaved = true;
|
|
if ( FHoudiniEngineUtils::IsValidNodeId( AssetId ) )
|
|
{
|
|
FHoudiniEngineUtils::GetAssetPreset( AssetId, PresetBuffer );
|
|
}
|
|
}
|
|
|
|
Ar << bPresetSaved;
|
|
|
|
if ( bPresetSaved )
|
|
{
|
|
Ar << PresetBuffer;
|
|
}
|
|
}
|
|
|
|
// Serialize parameters.
|
|
SerializeParameters( Ar );
|
|
|
|
// Serialize parameters name map.
|
|
if ( HoudiniAssetComponentVersion >= VER_HOUDINI_ENGINE_COMPONENT_PARAMETER_NAME_MAP )
|
|
{
|
|
Ar << ParameterByName;
|
|
}
|
|
else
|
|
{
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
ParameterByName.Empty();
|
|
|
|
// Otherwise if we are loading an older serialization format, we can reconstruct parameters name map.
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
|
|
ParameterByName.Add( HoudiniAssetParameter->GetParameterName(), HoudiniAssetParameter );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Serialize inputs.
|
|
SerializeInputs( Ar );
|
|
|
|
// Serialize material replacements and material assignments.
|
|
Ar << HoudiniAssetComponentMaterials;
|
|
|
|
// Serialize geo parts and generated static meshes.
|
|
Ar << StaticMeshes;
|
|
Ar << StaticMeshComponents;
|
|
|
|
// Serialize instance inputs (we do this after geometry loading as we might need it).
|
|
SerializeInstanceInputs( Ar );
|
|
|
|
// Serialize curves.
|
|
Ar << SplineComponents;
|
|
|
|
// Serialize handles.
|
|
Ar << HandleComponents;
|
|
|
|
// Serialize downstream asset connections.
|
|
Ar << DownstreamAssetConnections;
|
|
|
|
// Serialize Landscape/GeoPart map
|
|
if ( HoudiniAssetComponentVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_LANDSCAPES )
|
|
{
|
|
Ar << LandscapeComponents;
|
|
}
|
|
|
|
if( HoudiniAssetComponentVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_BAKENAME_OVERRIDE )
|
|
{
|
|
Ar << BakeNameOverrides;
|
|
}
|
|
|
|
TArray<UPackage *> DirtyPackages;
|
|
if (HoudiniAssetComponentVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_COOK_TEMP_PACKAGES)
|
|
{
|
|
TMap<FString, FString> SavedPackages;
|
|
if ( Ar.IsSaving() )
|
|
{
|
|
for ( TMap<FString, TWeakObjectPtr< UPackage > > ::TIterator IterPackage(CookedTemporaryPackages); IterPackage; ++IterPackage )
|
|
{
|
|
if (!IterPackage.Value().IsValid())
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( !Package || UPackage::IsEmptyPackage( Package ) )
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
|
|
FString sValue = Package->GetFName().ToString();
|
|
|
|
FString sKey = IterPackage.Key();
|
|
SavedPackages.Add( sKey, sValue );
|
|
}
|
|
}
|
|
|
|
Ar << SavedPackages;
|
|
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
for ( TMap<FString, FString > ::TIterator IterPackage( SavedPackages ); IterPackage; ++IterPackage )
|
|
{
|
|
FString sKey = IterPackage.Key();
|
|
FString PackageFile = IterPackage.Value();
|
|
if (!FPackageName::DoesPackageExist(PackageFile))
|
|
continue;
|
|
|
|
UPackage * Package = nullptr;
|
|
if ( !PackageFile.IsEmpty() )
|
|
{
|
|
Package = FindPackage(nullptr, *PackageFile);
|
|
}
|
|
|
|
if ( !Package )
|
|
continue;
|
|
|
|
if ( Package->IsDirty() )
|
|
DirtyPackages.Add(Package);
|
|
|
|
CookedTemporaryPackages.Add( sKey, Package );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( HoudiniAssetComponentVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_COOK_TEMP_PACKAGES_MESH_AND_LAYERS )
|
|
{
|
|
// Temporary Mesh Packages
|
|
TMap<FHoudiniGeoPartObject, FString> MeshPackages;
|
|
if ( Ar.IsSaving() )
|
|
{
|
|
for ( TMap<FHoudiniGeoPartObject, TWeakObjectPtr< UPackage > > ::TIterator IterPackage(CookedTemporaryStaticMeshPackages); IterPackage; ++IterPackage )
|
|
{
|
|
if ( !IterPackage.Value().IsValid() )
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( !Package || UPackage::IsEmptyPackage( Package ) )
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
|
|
FString sValue = Package->GetFName().ToString();
|
|
|
|
FHoudiniGeoPartObject Key = IterPackage.Key();
|
|
MeshPackages.Add( Key, sValue );
|
|
}
|
|
}
|
|
|
|
Ar << MeshPackages;
|
|
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
for ( TMap<FHoudiniGeoPartObject, FString > ::TIterator IterPackage( MeshPackages ); IterPackage; ++IterPackage )
|
|
{
|
|
FHoudiniGeoPartObject Key = IterPackage.Key();
|
|
FString PackageFile = IterPackage.Value();
|
|
if (!FPackageName::DoesPackageExist(PackageFile))
|
|
continue;
|
|
|
|
UPackage * Package = nullptr;
|
|
if ( !PackageFile.IsEmpty() )
|
|
{
|
|
Package = FindPackage(nullptr, *PackageFile);
|
|
}
|
|
|
|
if ( !Package )
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
|
|
CookedTemporaryStaticMeshPackages.Add( Key, Package );
|
|
}
|
|
}
|
|
|
|
// Temporary Landscape Layers Packages
|
|
TMap<FString, FHoudiniGeoPartObject> LayerPackages;
|
|
if ( Ar.IsSaving() )
|
|
{
|
|
for ( TMap<TWeakObjectPtr< UPackage >, FHoudiniGeoPartObject > ::TIterator IterPackage( CookedTemporaryLandscapeLayers ); IterPackage; ++IterPackage )
|
|
{
|
|
if (!IterPackage.Key().IsValid())
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Key().Get();
|
|
if ( !Package || UPackage::IsEmptyPackage( Package ) )
|
|
continue;
|
|
|
|
if ( Package->IsDirty() )
|
|
DirtyPackages.Add(Package);
|
|
|
|
FString sKey = Package->GetFName().ToString();
|
|
|
|
FHoudiniGeoPartObject Value = IterPackage.Value();
|
|
LayerPackages.Add( sKey, Value );
|
|
}
|
|
}
|
|
|
|
Ar << LayerPackages;
|
|
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
for ( TMap<FString, FHoudiniGeoPartObject > ::TIterator IterPackage( LayerPackages ); IterPackage; ++IterPackage )
|
|
{
|
|
FHoudiniGeoPartObject Value = IterPackage.Value();
|
|
FString PackageFile = IterPackage.Key();
|
|
if ( !FPackageName::DoesPackageExist(PackageFile) )
|
|
continue;
|
|
|
|
UPackage * Package = nullptr;
|
|
if ( !PackageFile.IsEmpty() )
|
|
{
|
|
Package = FindPackage(nullptr, *PackageFile);
|
|
}
|
|
|
|
if ( !Package )
|
|
continue;
|
|
|
|
if ( Package->IsDirty() )
|
|
DirtyPackages.Add(Package);
|
|
|
|
CookedTemporaryLandscapeLayers.Add( Package, Value );
|
|
}
|
|
}
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
if (DirtyPackages.Num() > 0)
|
|
{
|
|
if (Ar.IsSaving() && !Ar.IsTransacting())
|
|
{
|
|
// Save the dirty packages that we're still using
|
|
const bool bCheckDirty = false;
|
|
const bool bPromptToSave = false;
|
|
FEditorFileUtils::PromptForCheckoutAndSave(DirtyPackages, bCheckDirty, bPromptToSave);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ( Ar.IsLoading() && bIsNativeComponent )
|
|
{
|
|
// This component has been loaded.
|
|
bLoadedComponent = true;
|
|
bFullyLoaded = false;
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetStaticMeshGenerationParameters( UStaticMesh * StaticMesh ) const
|
|
{
|
|
#if WITH_EDITOR
|
|
if( !StaticMesh )
|
|
return;
|
|
|
|
// Make sure static mesh has a new lighting guid.
|
|
StaticMesh->LightingGuid = FGuid::NewGuid();
|
|
StaticMesh->LODGroup = NAME_None;
|
|
|
|
// Set resolution of lightmap.
|
|
StaticMesh->LightMapResolution = GeneratedLightMapResolution;
|
|
|
|
// Set Bias multiplier for Light Propagation Volume lighting.
|
|
StaticMesh->LpvBiasMultiplier = GeneratedLpvBiasMultiplier;
|
|
|
|
// Set the global light map coordinate index if it looks valid
|
|
if ( StaticMesh->RenderData.IsValid() && StaticMesh->RenderData->LODResources.Num() > 0)
|
|
{
|
|
int32 NumUVs = StaticMesh->RenderData->LODResources[0].GetNumTexCoords();
|
|
if ( NumUVs > GeneratedLightMapCoordinateIndex )
|
|
{
|
|
StaticMesh->LightMapCoordinateIndex = GeneratedLightMapCoordinateIndex;
|
|
}
|
|
}
|
|
|
|
// Set method for LOD texture factor computation.
|
|
/* TODO_414
|
|
//StaticMesh->bUseMaximumStreamingTexelRatio = bGeneratedUseMaximumStreamingTexelRatio;
|
|
|
|
// Set distance where textures using UV 0 are streamed in/out. - GOES ON COMPONENT
|
|
// StaticMesh->StreamingDistanceMultiplier = GeneratedStreamingDistanceMultiplier;
|
|
*/
|
|
|
|
// Add user data.
|
|
for( int32 AssetUserDataIdx = 0; AssetUserDataIdx < GeneratedAssetUserData.Num(); ++AssetUserDataIdx )
|
|
StaticMesh->AddAssetUserData( GeneratedAssetUserData[ AssetUserDataIdx ] );
|
|
|
|
StaticMesh->CreateBodySetup();
|
|
UBodySetup * BodySetup = StaticMesh->BodySetup;
|
|
check( BodySetup );
|
|
|
|
// Set flag whether physics triangle mesh will use double sided faces when doing scene queries.
|
|
BodySetup->bDoubleSidedGeometry = bGeneratedDoubleSidedGeometry;
|
|
|
|
// Assign physical material for simple collision.
|
|
BodySetup->PhysMaterial = GeneratedPhysMaterial;
|
|
|
|
BodySetup->DefaultInstance.CopyBodyInstancePropertiesFrom(&DefaultBodyInstance);
|
|
|
|
// Assign collision trace behavior.
|
|
BodySetup->CollisionTraceFlag = GeneratedCollisionTraceFlag;
|
|
|
|
// Assign walkable slope behavior.
|
|
BodySetup->WalkableSlopeOverride = GeneratedWalkableSlopeOverride;
|
|
|
|
// We want to use all of geometry for collision detection purposes.
|
|
BodySetup->bMeshCollideAll = true;
|
|
|
|
#endif
|
|
}
|
|
|
|
const TArray< UHoudiniAssetInstanceInputField * >
|
|
UHoudiniAssetComponent::GetAllInstanceInputFields() const
|
|
{
|
|
TArray< UHoudiniAssetInstanceInputField * > AllInstanceInputFields;
|
|
|
|
// Duplicate instanced static mesh components.
|
|
for (auto& InstanceInput : InstanceInputs)
|
|
{
|
|
if (!InstanceInput || InstanceInput->IsPendingKill())
|
|
continue;
|
|
|
|
const TArray< UHoudiniAssetInstanceInputField * > CurrentInstanceInputFields = InstanceInput->GetInstanceInputFields();
|
|
for (auto currentInputField : CurrentInstanceInputFields)
|
|
AllInstanceInputFields.Add(currentInputField);
|
|
}
|
|
|
|
return AllInstanceInputFields;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
|
|
AActor *
|
|
UHoudiniAssetComponent::CloneComponentsAndCreateActor()
|
|
{
|
|
// Display busy cursor.
|
|
FScopedBusyCursor ScopedBusyCursor;
|
|
|
|
ULevel * Level = GetHoudiniAssetActorOwner() ? GetHoudiniAssetActorOwner()->GetLevel() : nullptr;
|
|
if ( !Level )
|
|
Level = GWorld->GetCurrentLevel();
|
|
|
|
AActor * Actor = NewObject< AActor >( Level, NAME_None );
|
|
Actor->AddToRoot();
|
|
|
|
USceneComponent * RootComponent =
|
|
NewObject< USceneComponent >( Actor, USceneComponent::GetDefaultSceneRootVariableName(), RF_Transactional );
|
|
|
|
RootComponent->SetMobility(EComponentMobility::Static);
|
|
RootComponent->bVisualizeComponent = true;
|
|
|
|
const FTransform & ComponentWorldTransform = GetComponentTransform();
|
|
RootComponent->SetWorldLocationAndRotation(
|
|
ComponentWorldTransform.GetLocation(),
|
|
ComponentWorldTransform.GetRotation() );
|
|
|
|
Actor->SetRootComponent( RootComponent );
|
|
Actor->AddInstanceComponent( RootComponent );
|
|
|
|
RootComponent->RegisterComponent();
|
|
|
|
// Duplicate static mesh components.
|
|
{
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
// Retrieve referenced static mesh component.
|
|
UStaticMeshComponent * StaticMeshComponent = LocateStaticMeshComponent( StaticMesh );
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
// Bake the referenced static mesh.
|
|
UStaticMesh * OutStaticMesh = FHoudiniEngineBakeUtils::DuplicateStaticMeshAndCreatePackage(
|
|
StaticMesh, this, HoudiniGeoPartObject, EBakeMode::CreateNewAssets );
|
|
|
|
if ( !OutStaticMesh || OutStaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
FAssetRegistryModule::AssetCreated( OutStaticMesh );
|
|
|
|
// Create static mesh component for baked mesh.
|
|
UStaticMeshComponent * DuplicatedComponent =
|
|
NewObject< UStaticMeshComponent >( Actor, UStaticMeshComponent::StaticClass(), NAME_None );//, RF_Transactional );
|
|
|
|
if ( !DuplicatedComponent || DuplicatedComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
Actor->AddInstanceComponent( DuplicatedComponent );
|
|
|
|
DuplicatedComponent->SetStaticMesh( OutStaticMesh );
|
|
DuplicatedComponent->SetVisibility( true );
|
|
DuplicatedComponent->SetRelativeTransform( HoudiniGeoPartObject.TransformMatrix );
|
|
|
|
// If this is a collision geo, we need to make it invisible.
|
|
if ( HoudiniGeoPartObject.IsCollidable() )
|
|
{
|
|
DuplicatedComponent->SetVisibility( false );
|
|
DuplicatedComponent->SetHiddenInGame( true );
|
|
DuplicatedComponent->SetCollisionProfileName( FName( TEXT( "InvisibleWall" ) ) );
|
|
}
|
|
|
|
// Reapply the uproperties modified by attributes on the duplicated component
|
|
FHoudiniEngineUtils::UpdateUPropertyAttributesOnObject( DuplicatedComponent, HoudiniGeoPartObject );
|
|
|
|
DuplicatedComponent->AttachToComponent( RootComponent, FAttachmentTransformRules::KeepRelativeTransform );
|
|
DuplicatedComponent->RegisterComponent();
|
|
}
|
|
}
|
|
|
|
// Duplicate instanced static mesh components.
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if ( InstanceInput && !InstanceInput->IsPendingKill() )
|
|
InstanceInput->CloneComponentsAndAttachToActor( Actor );
|
|
}
|
|
|
|
return Actor;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::IsCookingEnabled() const
|
|
{
|
|
return FHoudiniEngine::Get().GetEnableCookingGlobal() && bEnableCooking;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostEditUndo()
|
|
{
|
|
// We need to make sure that all mesh components in the maps are valid ones
|
|
CleanUpAttachedStaticMeshComponents();
|
|
|
|
// Check the cooked materials refer to something..
|
|
bool bCookedContentNeedRecook = false;
|
|
for ( TMap< FString, TWeakObjectPtr< UPackage > > ::TIterator IterPackage( CookedTemporaryPackages ); IterPackage; ++IterPackage )
|
|
{
|
|
if ( bCookedContentNeedRecook )
|
|
break;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( Package )
|
|
{
|
|
FString PackageName = Package->GetName();
|
|
if ( !PackageName.IsEmpty() && ( PackageName != TEXT( "None" ) ) )
|
|
continue;
|
|
}
|
|
|
|
bCookedContentNeedRecook = true;
|
|
}
|
|
|
|
// Check the cooked meshes refer to something..
|
|
for ( TMap< FHoudiniGeoPartObject, TWeakObjectPtr< UPackage > > ::TIterator IterPackage( CookedTemporaryStaticMeshPackages ); IterPackage; ++IterPackage )
|
|
{
|
|
if ( bCookedContentNeedRecook )
|
|
break;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( Package )
|
|
{
|
|
FString PackageName = Package->GetName();
|
|
if ( !PackageName.IsEmpty() && ( PackageName != TEXT("None") ) )
|
|
continue;
|
|
}
|
|
|
|
bCookedContentNeedRecook = true;
|
|
}
|
|
|
|
// Check the cooked landscape layers refer to something..
|
|
for ( TMap< TWeakObjectPtr< UPackage >, FHoudiniGeoPartObject >::TIterator IterPackage( CookedTemporaryLandscapeLayers ); IterPackage; ++IterPackage )
|
|
{
|
|
if ( bCookedContentNeedRecook )
|
|
break;
|
|
|
|
UPackage * Package = IterPackage.Key().Get();
|
|
if ( Package )
|
|
{
|
|
FString PackageName = Package->GetName();
|
|
if ( !PackageName.IsEmpty() && ( PackageName != TEXT("None") ) )
|
|
continue;
|
|
}
|
|
|
|
bCookedContentNeedRecook = true;
|
|
}
|
|
|
|
|
|
if ( bCookedContentNeedRecook )
|
|
StartTaskAssetCookingManual();
|
|
|
|
Super::PostEditUndo();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostEditImport()
|
|
{
|
|
Super::PostEditImport();
|
|
|
|
AHoudiniAssetActor * CopiedActor = FHoudiniEngineUtils::LocateClipboardActor( GetOwner(), TEXT( "" ) );
|
|
if ( CopiedActor )
|
|
OnComponentClipboardCopy( CopiedActor->HoudiniAssetComponent );
|
|
}
|
|
|
|
void UHoudiniAssetComponent::SanitizePostLoad()
|
|
{
|
|
AActor* Owner = GetOwner();
|
|
|
|
for(auto Iter : Parameters)
|
|
{
|
|
UHoudiniAssetParameter* Param = Iter.Value;
|
|
if( !Param || Param->IsPendingKill() )
|
|
{
|
|
// we have at least one bad parameter, clear them all
|
|
FMessageLog("LoadErrors").Error(LOCTEXT("NullParameterFound", "Houdini Engine: Null parameter found, clearing parameters"))
|
|
->AddToken(FUObjectToken::Create(Owner));
|
|
Parameters.Empty();
|
|
ParameterByName.Empty();
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(auto Input : Inputs)
|
|
{
|
|
if( !Input || Input->IsPendingKill() )
|
|
{
|
|
// we have at least one bad input, clear them all
|
|
FMessageLog("LoadErrors").Error(LOCTEXT("NullInputFound", "Houdini Engine: Null input found, clearing inputs"))
|
|
->AddToken(FUObjectToken::Create(Owner));
|
|
Inputs.Empty();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Patch any invalid material references
|
|
for( auto& SMCElem : StaticMeshComponents )
|
|
{
|
|
UStaticMesh* SM = SMCElem.Key;
|
|
UMeshComponent* SMC = SMCElem.Value;
|
|
if ( !SM || SM->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( !SMC || SMC->IsPendingKill() )
|
|
continue;
|
|
|
|
auto& StaticMeshMaterials = SM->StaticMaterials;
|
|
for( int32 MaterialIdx = 0; MaterialIdx < StaticMeshMaterials.Num(); ++MaterialIdx )
|
|
{
|
|
if( nullptr == StaticMeshMaterials[ MaterialIdx ].MaterialInterface )
|
|
{
|
|
auto DefaultMI = FHoudiniEngine::Get().GetHoudiniDefaultMaterial().Get();
|
|
StaticMeshMaterials[ MaterialIdx ].MaterialInterface = DefaultMI;
|
|
SMC->SetMaterial( MaterialIdx, DefaultMI );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
// Fetch the dirty package that need to be reloaded
|
|
TArray<UPackage *> DirtyPackages;
|
|
for (TMap<FString, TWeakObjectPtr< UPackage > > ::TIterator IterPackage(CookedTemporaryPackages); IterPackage; ++IterPackage)
|
|
{
|
|
if (!IterPackage.Value().IsValid())
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if (!Package || UPackage::IsEmptyPackage(Package))
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
}
|
|
|
|
for (TMap<FHoudiniGeoPartObject, TWeakObjectPtr< UPackage > > ::TIterator IterPackage(CookedTemporaryStaticMeshPackages); IterPackage; ++IterPackage)
|
|
{
|
|
if (!IterPackage.Value().IsValid())
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if (!Package || UPackage::IsEmptyPackage(Package))
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
}
|
|
|
|
for (TMap<TWeakObjectPtr< UPackage >, FHoudiniGeoPartObject > ::TIterator IterPackage(CookedTemporaryLandscapeLayers); IterPackage; ++IterPackage)
|
|
{
|
|
if (!IterPackage.Key().IsValid())
|
|
continue;
|
|
|
|
UPackage * Package = IterPackage.Key().Get();
|
|
if (!Package || UPackage::IsEmptyPackage(Package))
|
|
continue;
|
|
|
|
if (Package->IsDirty())
|
|
DirtyPackages.Add(Package);
|
|
}
|
|
|
|
if (DirtyPackages.Num() > 0)
|
|
{
|
|
FlushAsyncLoading();
|
|
|
|
FText ErrorMessage;
|
|
UPackageTools::ReloadPackages(DirtyPackages, ErrorMessage, UPackageTools::EReloadPackagesInteractionMode::AssumePositive);
|
|
}
|
|
*/
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostInitProperties()
|
|
{
|
|
Super::PostInitProperties();
|
|
|
|
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
|
|
|
|
if ( HoudiniRuntimeSettings )
|
|
{
|
|
// Copy cooking defaults from settings.
|
|
bEnableCooking = HoudiniRuntimeSettings->bEnableCooking;
|
|
bUploadTransformsToHoudiniEngine = HoudiniRuntimeSettings->bUploadTransformsToHoudiniEngine;
|
|
bTransformChangeTriggersCooks = HoudiniRuntimeSettings->bTransformChangeTriggersCooks;
|
|
|
|
// Copy static mesh generation parameters from settings.
|
|
bGeneratedDoubleSidedGeometry = HoudiniRuntimeSettings->bDoubleSidedGeometry;
|
|
GeneratedPhysMaterial = HoudiniRuntimeSettings->PhysMaterial;
|
|
DefaultBodyInstance = HoudiniRuntimeSettings->DefaultBodyInstance;
|
|
GeneratedCollisionTraceFlag = HoudiniRuntimeSettings->CollisionTraceFlag;
|
|
GeneratedLpvBiasMultiplier = HoudiniRuntimeSettings->LpvBiasMultiplier;
|
|
GeneratedLightMapResolution = HoudiniRuntimeSettings->LightMapResolution;
|
|
GeneratedLightMapCoordinateIndex = HoudiniRuntimeSettings->LightMapCoordinateIndex;
|
|
bGeneratedUseMaximumStreamingTexelRatio = HoudiniRuntimeSettings->bUseMaximumStreamingTexelRatio;
|
|
GeneratedStreamingDistanceMultiplier = HoudiniRuntimeSettings->StreamingDistanceMultiplier;
|
|
GeneratedWalkableSlopeOverride = HoudiniRuntimeSettings->WalkableSlopeOverride;
|
|
GeneratedFoliageDefaultSettings = HoudiniRuntimeSettings->FoliageDefaultSettings;
|
|
GeneratedAssetUserData = HoudiniRuntimeSettings->AssetUserData;
|
|
GeneratedDistanceFieldResolutionScale = HoudiniRuntimeSettings->GeneratedDistanceFieldResolutionScale;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
bool
|
|
UHoudiniAssetComponent::LocateStaticMeshes(
|
|
const FString & ObjectName,
|
|
TMap< FString, TArray< FHoudiniGeoPartObject > > & InOutObjectsToInstance, bool bSubstring ) const
|
|
{
|
|
// See if map has entry for this object name.
|
|
if ( !InOutObjectsToInstance.Contains( ObjectName ) )
|
|
InOutObjectsToInstance.Add( ObjectName, TArray< FHoudiniGeoPartObject >() );
|
|
|
|
{
|
|
// Get array entry for this object name.
|
|
TArray< FHoudiniGeoPartObject > & Objects = InOutObjectsToInstance[ ObjectName ];
|
|
|
|
// Go through all geo part objects and see if we have matches.
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TConstIterator Iter( StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( ObjectName.Len() > 0 )
|
|
{
|
|
if ( bSubstring && ObjectName.Len() >= HoudiniGeoPartObject.ObjectName.Len() )
|
|
{
|
|
int32 Index = ObjectName.Find(
|
|
*HoudiniGeoPartObject.ObjectName,
|
|
ESearchCase::IgnoreCase,
|
|
ESearchDir::FromEnd, INDEX_NONE );
|
|
|
|
if ( ( Index != -1 ) && ( Index + HoudiniGeoPartObject.ObjectName.Len() == ObjectName.Len() ) )
|
|
Objects.Add( HoudiniGeoPartObject );
|
|
}
|
|
else if ( HoudiniGeoPartObject.ObjectName.Equals( ObjectName ) )
|
|
{
|
|
Objects.Add( HoudiniGeoPartObject );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort arrays.
|
|
for ( TMap< FString, TArray< FHoudiniGeoPartObject > >::TIterator Iter( InOutObjectsToInstance ); Iter; ++Iter )
|
|
{
|
|
TArray< FHoudiniGeoPartObject > & Objects = Iter.Value();
|
|
Objects.Sort( FHoudiniGeoPartObjectSortPredicate() );
|
|
}
|
|
|
|
return InOutObjectsToInstance.Num() > 0;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::LocateStaticMeshes(
|
|
int32 ObjectToInstanceId,
|
|
TArray< FHoudiniGeoPartObject > & InOutObjectsToInstance ) const
|
|
{
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TConstIterator Iter( StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject& HoudiniGeoPartObject = Iter.Key();
|
|
if ( HoudiniGeoPartObject.ObjectId == ObjectToInstanceId )
|
|
{
|
|
// Check that this part isn't being instanced at the part level
|
|
if ( !HoudiniGeoPartObject.HapiPartIsInstanced() )
|
|
InOutObjectsToInstance.Add( HoudiniGeoPartObject );
|
|
}
|
|
}
|
|
|
|
// Sort array.
|
|
InOutObjectsToInstance.Sort( FHoudiniGeoPartObjectSortPredicate() );
|
|
|
|
return InOutObjectsToInstance.Num() > 0;
|
|
}
|
|
|
|
|
|
FHoudiniGeoPartObject
|
|
UHoudiniAssetComponent::LocateGeoPartObject( UStaticMesh * StaticMesh ) const
|
|
{
|
|
FHoudiniGeoPartObject GeoPartObject;
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
return GeoPartObject;
|
|
|
|
const FHoudiniGeoPartObject * FoundGeoPartObject = StaticMeshes.FindKey( StaticMesh );
|
|
if ( FoundGeoPartObject )
|
|
GeoPartObject = *FoundGeoPartObject;
|
|
|
|
return GeoPartObject;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::IsPIEActive() const
|
|
{
|
|
#if WITH_EDITOR
|
|
for( const FWorldContext& Context : GEngine->GetWorldContexts() )
|
|
{
|
|
if( Context.WorldType == EWorldType::PIE )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateCurves( const TArray< FHoudiniGeoPartObject > & FoundCurves )
|
|
{
|
|
bool bCurveCreated = false;
|
|
|
|
TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* > NewSplineComponents;
|
|
for ( TArray< FHoudiniGeoPartObject >::TConstIterator Iter( FoundCurves ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject = *Iter;
|
|
|
|
// Retrieve node id from geo part.
|
|
HAPI_NodeId NodeId = HoudiniGeoPartObject.HapiGeoGetNodeId( AssetId );
|
|
if ( NodeId == -1 )
|
|
{
|
|
// Invalid node id.
|
|
continue;
|
|
}
|
|
|
|
if ( !HoudiniGeoPartObject.HasParameters( AssetId ) )
|
|
{
|
|
// We have no parameters on this curve.
|
|
continue;
|
|
}
|
|
|
|
// We need to cook the spline node.
|
|
FHoudiniApi::CookNode(FHoudiniEngine::Get().GetSession(), NodeId, nullptr);
|
|
|
|
FString CurvePointsString;
|
|
EHoudiniSplineComponentType::Enum CurveTypeValue = EHoudiniSplineComponentType::Bezier;
|
|
EHoudiniSplineComponentMethod::Enum CurveMethodValue = EHoudiniSplineComponentMethod::CVs;
|
|
int32 CurveClosed = 1;
|
|
|
|
HAPI_AttributeInfo AttributeRefinedCurvePositions;
|
|
FHoudiniApi::AttributeInfo_Init(&AttributeRefinedCurvePositions);
|
|
|
|
TArray< float > RefinedCurvePositions;
|
|
if ( !FHoudiniEngineUtils::HapiGetAttributeDataAsFloat(
|
|
HoudiniGeoPartObject, HAPI_UNREAL_ATTRIB_POSITION,
|
|
AttributeRefinedCurvePositions, RefinedCurvePositions ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !AttributeRefinedCurvePositions.exists && RefinedCurvePositions.Num() > 0 )
|
|
continue;
|
|
|
|
// Transfer refined positions to position vector and perform necessary axis swap.
|
|
TArray< FVector > CurveDisplayPoints;
|
|
FHoudiniEngineUtils::ConvertScaleAndFlipVectorData( RefinedCurvePositions, CurveDisplayPoints );
|
|
|
|
if ( !FHoudiniEngineUtils::HapiGetParameterDataAsString(
|
|
NodeId, HAPI_UNREAL_PARAM_CURVE_COORDS, TEXT(""), CurvePointsString) ||
|
|
!FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
|
|
NodeId, HAPI_UNREAL_PARAM_CURVE_TYPE, (int32) EHoudiniSplineComponentType::Bezier, (int32&) CurveTypeValue ) ||
|
|
!FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
|
|
NodeId, HAPI_UNREAL_PARAM_CURVE_METHOD, (int32) EHoudiniSplineComponentMethod::CVs, (int32&) CurveMethodValue ) ||
|
|
!FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
|
|
NodeId, HAPI_UNREAL_PARAM_CURVE_CLOSED, 1, CurveClosed ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Process coords string and extract positions.
|
|
TArray< FVector > CurvePositions;
|
|
FHoudiniEngineUtils::ExtractStringPositions( CurvePointsString, CurvePositions );
|
|
|
|
// Check if this curve already exists.
|
|
UHoudiniSplineComponent * HoudiniSplineComponent = LocateSplineComponent( HoudiniGeoPartObject );
|
|
|
|
if ( HoudiniSplineComponent )
|
|
{
|
|
// The curve already exists, we can reuse it.
|
|
// Remove it from old map.
|
|
SplineComponents.Remove( HoudiniGeoPartObject );
|
|
}
|
|
else
|
|
{
|
|
// We need to create a new curve.
|
|
HoudiniSplineComponent = NewObject< UHoudiniSplineComponent >(
|
|
this, UHoudiniSplineComponent::StaticClass(),
|
|
NAME_None, RF_Public | RF_Transactional );
|
|
|
|
bCurveCreated = true;
|
|
}
|
|
|
|
// Set the GeoPartObject
|
|
HoudiniSplineComponent->SetHoudiniGeoPartObject( HoudiniGeoPartObject );
|
|
|
|
// If we have no parent, we need to re-attach.
|
|
if ( !HoudiniSplineComponent->GetAttachParent() )
|
|
HoudiniSplineComponent->AttachToComponent( this, FAttachmentTransformRules::KeepRelativeTransform );
|
|
|
|
HoudiniSplineComponent->SetVisibility( true );
|
|
|
|
// If component is not registered, register it.
|
|
if ( !HoudiniSplineComponent->IsRegistered() )
|
|
HoudiniSplineComponent->RegisterComponent();
|
|
|
|
// Add to map of components.
|
|
NewSplineComponents.Add( HoudiniGeoPartObject, HoudiniSplineComponent );
|
|
|
|
// Transform the component by transformation provided by HAPI.
|
|
HoudiniSplineComponent->SetRelativeTransform( HoudiniGeoPartObject.TransformMatrix );
|
|
|
|
// Create Transform for the HoudiniSplineComponents
|
|
TArray< FTransform > CurvePoints;
|
|
CurvePoints.SetNumUninitialized(CurvePositions.Num());
|
|
|
|
FTransform trans = FTransform::Identity;
|
|
for (int32 n = 0; n < CurvePoints.Num(); n++)
|
|
{
|
|
trans.SetLocation(CurvePositions[n]);
|
|
CurvePoints[n] = trans;
|
|
}
|
|
|
|
// Construct curve from available data.
|
|
HoudiniSplineComponent->Construct(
|
|
HoudiniGeoPartObject, CurvePoints, CurveDisplayPoints, CurveTypeValue,
|
|
CurveMethodValue, ( CurveClosed == 1 ) );
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
// The editor caches the current selection visualizer, so we need to trick
|
|
// and pretend the selection has changed so that the HSplineVisualizer can be drawn immediately
|
|
if ( bCurveCreated && GUnrealEd )
|
|
GUnrealEd->NoteSelectionChange();
|
|
#endif
|
|
|
|
ClearCurves();
|
|
SplineComponents = NewSplineComponents;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateParameters()
|
|
{
|
|
TMap< HAPI_ParmId, class UHoudiniAssetParameter * > NewParameters;
|
|
if( FHoudiniParamUtils::Build(AssetId, this, Parameters, NewParameters) )
|
|
{
|
|
bEditorPropertiesNeedFullUpdate = true;
|
|
|
|
// Remove all unused parameters.
|
|
ClearParameters();
|
|
|
|
// Update parameters.
|
|
Parameters = NewParameters;
|
|
for ( auto& ParmPair : NewParameters )
|
|
{
|
|
UHoudiniAssetParameter* Param = ParmPair.Value;
|
|
if( Param && !Param->IsPendingKill() )
|
|
ParameterByName.Add( Param->GetParameterName(), Param );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::NotifyParameterChanged( UHoudiniAssetParameter * HoudiniAssetParameter )
|
|
{
|
|
if ( bLoadedComponent && !FHoudiniEngineUtils::IsValidNodeId( AssetId ) && !bAssetIsBeingInstantiated )
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
|
|
if ( HoudiniAssetParameter )
|
|
{
|
|
// Some parameter types won't require a full update of the editor panel
|
|
// This will avoid breaking the current selection
|
|
UClass* FoundClass = HoudiniAssetParameter->GetClass();
|
|
/*
|
|
if ( FoundClass->IsChildOf< UHoudiniAssetParameterFloat >()
|
|
|| FoundClass->IsChildOf< UHoudiniAssetParameterInt >()
|
|
|| FoundClass->IsChildOf< UHoudiniAssetParameterString >() )
|
|
*/
|
|
if ( !FoundClass->IsChildOf< UHoudiniAssetInput >() )
|
|
bEditorPropertiesNeedFullUpdate = false;
|
|
}
|
|
|
|
bParametersChanged = true;
|
|
StartHoudiniTicking();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::NotifyHoudiniSplineChanged( UHoudiniSplineComponent * HoudiniSplineComponent )
|
|
{
|
|
if ( bLoadedComponent && !FHoudiniEngineUtils::IsValidNodeId( AssetId ) && !bAssetIsBeingInstantiated )
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
|
|
bParametersChanged = true;
|
|
StartHoudiniTicking();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UnmarkChangedParameters()
|
|
{
|
|
if ( bParametersChanged )
|
|
{
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if ( !HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill() )
|
|
continue;
|
|
|
|
// If parameter has changed, unmark it.
|
|
if ( HoudiniAssetParameter->HasChanged() )
|
|
HoudiniAssetParameter->UnmarkChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UploadChangedParameters()
|
|
{
|
|
bool Success = true;
|
|
|
|
if ( bParametersChanged )
|
|
{
|
|
// Upload inputs.
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( !HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
// If input has changed, upload it to HAPI.
|
|
if ( HoudiniAssetInput->HasChanged() )
|
|
{
|
|
Success &= HoudiniAssetInput->UploadParameterValue();
|
|
}
|
|
}
|
|
|
|
// Upload parameters.
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill())
|
|
continue;
|
|
|
|
// If parameter has changed, upload it to HAPI.
|
|
if ( HoudiniAssetParameter->HasChanged() )
|
|
{
|
|
Success &= HoudiniAssetParameter->UploadParameterValue();
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !Success )
|
|
{
|
|
HOUDINI_LOG_ERROR(TEXT("%s UploadChangedParameters failed"), GetOwner() ? *GetOwner()->GetName() : *GetName());
|
|
}
|
|
|
|
// We no longer have changed parameters.
|
|
bParametersChanged = false;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UpdateLoadedParameters()
|
|
{
|
|
if (!FHoudiniEngineUtils::IsValidNodeId(AssetId))
|
|
return;
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill())
|
|
continue;
|
|
|
|
HoudiniAssetParameter->SetNodeId( AssetId );
|
|
}
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::CreateHandles()
|
|
{
|
|
if ( !FHoudiniEngineUtils::IsValidNodeId( AssetId ) )
|
|
{
|
|
// There's no Houdini asset, we can return.
|
|
return false;
|
|
}
|
|
|
|
HAPI_AssetInfo AssetInfo;
|
|
FHoudiniApi::AssetInfo_Init(&AssetInfo);
|
|
if ( FHoudiniApi::GetAssetInfo( FHoudiniEngine::Get().GetSession(), AssetId, &AssetInfo ) != HAPI_RESULT_SUCCESS )
|
|
return false;
|
|
|
|
FHandleComponentMap NewHandleComponents;
|
|
|
|
// If we have handles.
|
|
if ( AssetInfo.handleCount > 0 )
|
|
{
|
|
TArray< HAPI_HandleInfo > HandleInfos;
|
|
HandleInfos.SetNumZeroed( AssetInfo.handleCount );
|
|
for (int32 Idx = 0; Idx < HandleInfos.Num(); Idx++)
|
|
FHoudiniApi::HandleInfo_Init(&(HandleInfos[Idx]));
|
|
|
|
if ( FHoudiniApi::GetHandleInfo(
|
|
FHoudiniEngine::Get().GetSession(), AssetId,
|
|
&HandleInfos[ 0 ], 0, AssetInfo.handleCount ) != HAPI_RESULT_SUCCESS )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for ( int32 HandleIdx = 0; HandleIdx < AssetInfo.handleCount; ++HandleIdx )
|
|
{
|
|
// Retrieve handle info for this index.
|
|
const HAPI_HandleInfo & HandleInfo = HandleInfos[ HandleIdx ];
|
|
|
|
// If we do not have bindings, we can skip.
|
|
if ( HandleInfo.bindingsCount <= 0 )
|
|
continue;
|
|
|
|
FString TypeName = TEXT( "" );
|
|
EHoudiniHandleType HandleType = EHoudiniHandleType::Unsupported;
|
|
{
|
|
FHoudiniEngineString HoudiniEngineString( HandleInfo.typeNameSH );
|
|
if( !HoudiniEngineString.ToFString( TypeName ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( TypeName.Equals( TEXT( HAPI_UNREAL_HANDLE_TRANSFORM ) ) )
|
|
HandleType = EHoudiniHandleType::Xform;
|
|
else if( TypeName.Equals( TEXT( HAPI_UNREAL_HANDLE_BOUNDER ) ) )
|
|
HandleType = EHoudiniHandleType::Bounder;
|
|
}
|
|
|
|
FString HandleName = TEXT( "" );
|
|
|
|
{
|
|
FHoudiniEngineString HoudiniEngineString( HandleInfo.nameSH );
|
|
if ( !HoudiniEngineString.ToFString( HandleName ) )
|
|
continue;
|
|
}
|
|
|
|
if( HandleType == EHoudiniHandleType::Unsupported )
|
|
{
|
|
HOUDINI_LOG_DISPLAY( TEXT( "%s: Unsupported Handle Type %s for handle %s" ), GetOwner() ? *(GetOwner()->GetName()) : *GetName(), *TypeName, *HandleName );
|
|
continue;
|
|
}
|
|
|
|
UHoudiniHandleComponent * HandleComponent = nullptr;
|
|
UHoudiniHandleComponent ** FoundHandleComponent = HandleComponents.Find( HandleName );
|
|
|
|
if ( FoundHandleComponent )
|
|
{
|
|
HandleComponent = *FoundHandleComponent;
|
|
|
|
// Remove so that it's not destroyed.
|
|
HandleComponents.Remove( HandleName );
|
|
}
|
|
else
|
|
{
|
|
HandleComponent = NewObject< UHoudiniHandleComponent >(
|
|
this, UHoudiniHandleComponent::StaticClass(),
|
|
NAME_None, RF_Public | RF_Transactional );
|
|
}
|
|
|
|
if ( !HandleComponent )
|
|
continue;
|
|
|
|
// If we have no parent, we need to re-attach.
|
|
if ( !HandleComponent->GetAttachParent() )
|
|
HandleComponent->AttachToComponent( this, FAttachmentTransformRules::KeepRelativeTransform );
|
|
|
|
HandleComponent->SetVisibility( true );
|
|
|
|
// If component is not registered, register it.
|
|
if ( !HandleComponent->IsRegistered() )
|
|
HandleComponent->RegisterComponent();
|
|
|
|
if ( HandleComponent->Construct( AssetId, HandleIdx, HandleName, HandleInfo, Parameters, HandleType ) )
|
|
NewHandleComponents.Add( HandleName, HandleComponent );
|
|
}
|
|
}
|
|
|
|
ClearHandles();
|
|
HandleComponents = NewHandleComponents;
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateInputs()
|
|
{
|
|
if ( !FHoudiniEngineUtils::IsValidNodeId( AssetId ) )
|
|
{
|
|
// There's no Houdini asset, we can return.
|
|
return;
|
|
}
|
|
|
|
HAPI_AssetInfo AssetInfo;
|
|
FHoudiniApi::AssetInfo_Init(&AssetInfo);
|
|
int32 InputCount = 0;
|
|
if ( FHoudiniApi::GetAssetInfo( FHoudiniEngine::Get().GetSession(), AssetId, &AssetInfo ) == HAPI_RESULT_SUCCESS
|
|
&& AssetInfo.hasEverCooked )
|
|
{
|
|
InputCount = AssetInfo.geoInputCount;
|
|
}
|
|
|
|
// We've already created the number of required inputs.
|
|
if( Inputs.Num() == InputCount )
|
|
return;
|
|
|
|
// Resize our inputs to match the asset
|
|
if( InputCount == 0 )
|
|
{
|
|
ClearInputs();
|
|
}
|
|
else
|
|
{
|
|
if( InputCount > Inputs.Num() )
|
|
{
|
|
int32 NumNewInputs = InputCount - Inputs.Num();
|
|
for( int32 InputIdx = Inputs.Num(); InputIdx < InputCount; ++InputIdx )
|
|
Inputs.Add( UHoudiniAssetInput::Create( this, InputIdx, AssetId ) );
|
|
}
|
|
else
|
|
{
|
|
// Must be fewer inputs
|
|
for( int32 InputIdx = InputCount; InputIdx < Inputs.Num(); ++InputIdx )
|
|
{
|
|
Inputs[ InputIdx ]->ConditionalBeginDestroy();
|
|
}
|
|
Inputs.SetNum( InputCount );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UpdateLoadedInputs( const bool& ForceRefresh )
|
|
{
|
|
if ( !FHoudiniEngineUtils::IsValidNodeId(AssetId) )
|
|
return;
|
|
|
|
bool Success = true;
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
HoudiniAssetInput->SetNodeId( AssetId );
|
|
|
|
// If we're updating the input landscape data, we need to restore the original input geometry
|
|
// to submit it as the source mesh
|
|
EHoudiniAssetInputType::Enum InputType = HoudiniAssetInput->GetChoiceIndex();
|
|
if (InputType == EHoudiniAssetInputType::LandscapeInput
|
|
&& HoudiniAssetInput->IsUpdatingInputLandscape() )
|
|
//&& !HoudiniAssetInput->IsLandscapeAssetConnected() )
|
|
FHoudiniLandscapeUtils::RestoreLandscapeFromFile( HoudiniAssetInput->GetLandscapeInput() );
|
|
|
|
Success &= HoudiniAssetInput->ChangeInputType( HoudiniAssetInput->GetChoiceIndex(), ForceRefresh );
|
|
Success &= HoudiniAssetInput->UploadParameterValue();
|
|
}
|
|
|
|
if( !Success )
|
|
{
|
|
HOUDINI_LOG_ERROR(TEXT("%s UpdateLoadedInputs failed"), GetOwner() ? *(GetOwner()->GetName()) : *GetName());
|
|
}
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::UpdateWaitingForUpstreamAssetsToInstantiate( bool bNotifyUpstreamAsset )
|
|
{
|
|
bWaitingForUpstreamAssetsToInstantiate = false;
|
|
|
|
// We first need to make sure all our asset inputs have been instantiated and reconnected.
|
|
for ( auto LocalInput : Inputs )
|
|
{
|
|
if ( !LocalInput || LocalInput->IsPendingKill() )
|
|
continue;
|
|
|
|
bool bInputAssetNeedsInstantiation = LocalInput->DoesInputAssetNeedInstantiation();
|
|
if ( !bInputAssetNeedsInstantiation )
|
|
continue;
|
|
|
|
bWaitingForUpstreamAssetsToInstantiate = true;
|
|
|
|
if ( bNotifyUpstreamAsset )
|
|
{
|
|
UHoudiniAssetComponent * LocalInputAssetComponent = LocalInput->GetConnectedInputAssetComponent();
|
|
if ( LocalInputAssetComponent && !LocalInputAssetComponent->IsPendingKill() )
|
|
LocalInputAssetComponent->NotifyParameterChanged( nullptr );
|
|
}
|
|
}
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetInput* Input = Cast< UHoudiniAssetInput >( IterParams.Value() );
|
|
if ( !Input || Input->IsPendingKill() )
|
|
continue;
|
|
|
|
bool bInputAssetNeedsInstantiation = Input->DoesInputAssetNeedInstantiation();
|
|
if ( !bInputAssetNeedsInstantiation )
|
|
continue;
|
|
|
|
bWaitingForUpstreamAssetsToInstantiate = true;
|
|
|
|
if ( bNotifyUpstreamAsset )
|
|
{
|
|
UHoudiniAssetComponent * LocalInputAssetComponent = Input->GetConnectedInputAssetComponent();
|
|
if ( LocalInputAssetComponent && !LocalInputAssetComponent->IsPendingKill() )
|
|
LocalInputAssetComponent->NotifyParameterChanged( nullptr );
|
|
}
|
|
}
|
|
|
|
return bWaitingForUpstreamAssetsToInstantiate;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::RefreshEditableNodesAfterLoad()
|
|
{
|
|
// For some reason, we need to go through all the editable nodes once
|
|
// To "Activate" them...
|
|
HAPI_AssetInfo AssetInfo;
|
|
FHoudiniApi::AssetInfo_Init(&AssetInfo);
|
|
HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetAssetInfo(
|
|
FHoudiniEngine::Get().GetSession(), AssetId, &AssetInfo), false);
|
|
|
|
// Retrieve information about each object contained within our asset.
|
|
TArray< HAPI_ObjectInfo > ObjectInfos;
|
|
if (!FHoudiniEngineUtils::HapiGetObjectInfos(AssetId, ObjectInfos))
|
|
return false;
|
|
|
|
// Iterate through all objects.
|
|
for (int32 ObjectIdx = 0; ObjectIdx < ObjectInfos.Num(); ++ObjectIdx)
|
|
{
|
|
// Retrieve object at this index.
|
|
const HAPI_ObjectInfo & ObjectInfo = ObjectInfos[ObjectIdx];
|
|
|
|
// Get all the GeoInfos for the editable nodes
|
|
int32 EditableNodeCount = 0;
|
|
HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::ComposeChildNodeList(
|
|
FHoudiniEngine::Get().GetSession(), ObjectInfo.nodeId,
|
|
HAPI_NODETYPE_SOP, HAPI_NODEFLAGS_EDITABLE,
|
|
true, &EditableNodeCount), false);
|
|
|
|
if (EditableNodeCount <= 0)
|
|
continue;
|
|
|
|
TArray< HAPI_NodeId > EditableNodeIds;
|
|
EditableNodeIds.SetNumUninitialized(EditableNodeCount);
|
|
HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetComposedChildNodeList(
|
|
FHoudiniEngine::Get().GetSession(), AssetId,
|
|
EditableNodeIds.GetData(), EditableNodeCount), false);
|
|
|
|
for (int nEditable = 0; nEditable < EditableNodeCount; nEditable++)
|
|
{
|
|
HAPI_GeoInfo CurrentEditableGeoInfo;
|
|
FHoudiniApi::GeoInfo_Init(&CurrentEditableGeoInfo);
|
|
HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::GetGeoInfo(
|
|
FHoudiniEngine::Get().GetSession(),
|
|
EditableNodeIds[nEditable],
|
|
&CurrentEditableGeoInfo), false);
|
|
|
|
if ( CurrentEditableGeoInfo.type != HAPI_GEOTYPE_CURVE )
|
|
continue;
|
|
|
|
FString NodePathTemp;
|
|
if ( !FHoudiniEngineUtils::HapiGetNodePath( CurrentEditableGeoInfo.nodeId, AssetId, NodePathTemp ) )
|
|
continue;
|
|
|
|
// We need to refresh the spline corresponding to that node
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TIterator Iter( SplineComponents ); Iter; ++Iter )
|
|
{
|
|
FHoudiniGeoPartObject & HoudiniGeoPartObject = Iter.Key();
|
|
|
|
// Get NodePath appends the partId to the node path, so we use contains instead of equals
|
|
if ( HoudiniGeoPartObject.GetNodePath().Contains( NodePathTemp ) )
|
|
{
|
|
// Update the Geo/Node Id
|
|
HoudiniGeoPartObject.GeoId = CurrentEditableGeoInfo.nodeId;
|
|
|
|
// Update the attached spline component too
|
|
UHoudiniSplineComponent * SplineComponent = Iter.Value();
|
|
if ( SplineComponent )
|
|
SplineComponent->SetHoudiniGeoPartObject( HoudiniGeoPartObject );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
UHoudiniAssetComponent::UploadLoadedCurves()
|
|
{
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TIterator Iter( SplineComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniSplineComponent * HoudiniSplineComponent = Iter.Value();
|
|
if ( !HoudiniSplineComponent )
|
|
continue;
|
|
|
|
HoudiniSplineComponent->UploadControlPoints();
|
|
}
|
|
}
|
|
|
|
UHoudiniAssetInstanceInput*
|
|
UHoudiniAssetComponent::LocateInstanceInput( const FHoudiniGeoPartObject& GeoPart ) const
|
|
{
|
|
for ( UHoudiniAssetInstanceInput* InstanceInput : InstanceInputs )
|
|
{
|
|
if ( !InstanceInput || InstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
// Verify path to instancer + various configuration flags
|
|
if ( InstanceInput->GetGeoPartObject().GetNodePath() == GeoPart.GetNodePath() &&
|
|
UHoudiniAssetInstanceInput::GetInstancerFlags(GeoPart).HoudiniAssetInstanceInputFlagsPacked ==
|
|
InstanceInput->Flags.HoudiniAssetInstanceInputFlagsPacked )
|
|
{
|
|
return InstanceInput;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CreateInstanceInputs( const TArray< FHoudiniGeoPartObject > & Instancers )
|
|
{
|
|
TArray< UHoudiniAssetInstanceInput * > NewInstanceInputs;
|
|
|
|
for ( const FHoudiniGeoPartObject& GeoPart : Instancers )
|
|
{
|
|
if ( GeoPart.IsVisible() )
|
|
{
|
|
// Check if this instance input already exists.
|
|
UHoudiniAssetInstanceInput * HoudiniAssetInstanceInput = nullptr;
|
|
|
|
UHoudiniAssetInstanceInput * FoundHoudiniAssetInstanceInput = LocateInstanceInput(GeoPart);
|
|
if ( FoundHoudiniAssetInstanceInput && !FoundHoudiniAssetInstanceInput->IsPendingKill() )
|
|
{
|
|
// Input already exists, we can reuse it.
|
|
HoudiniAssetInstanceInput = FoundHoudiniAssetInstanceInput;
|
|
|
|
// Since this is the corresponding part, we will refresh the InstanceInput's GeoPart
|
|
HoudiniAssetInstanceInput->SetGeoPartObject( GeoPart );
|
|
|
|
// Remove it from old map.
|
|
InstanceInputs.Remove( FoundHoudiniAssetInstanceInput );
|
|
}
|
|
else
|
|
{
|
|
// Otherwise we need to create new instance input.
|
|
HoudiniAssetInstanceInput = UHoudiniAssetInstanceInput::Create( this, GeoPart );
|
|
}
|
|
|
|
if ( !HoudiniAssetInstanceInput || HoudiniAssetInstanceInput->IsPendingKill() )
|
|
{
|
|
// Invalid instance input.
|
|
HOUDINI_LOG_WARNING( TEXT( "%s: Failed to create Instancer from part %s" ), GetOwner() ? *(GetOwner()->GetName()) : *GetName(), *GeoPart.GetNodePath() );
|
|
}
|
|
else
|
|
{
|
|
// Add input to new map.
|
|
NewInstanceInputs.Add( HoudiniAssetInstanceInput );
|
|
// Create or re-create this input.
|
|
HoudiniAssetInstanceInput->CreateInstanceInput();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear all the existing instance inputs and replace with the new
|
|
ClearInstanceInputs();
|
|
InstanceInputs = NewInstanceInputs;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::DuplicateParameters( UHoudiniAssetComponent * DuplicatedHoudiniComponent )
|
|
{
|
|
if ( !DuplicatedHoudiniComponent || DuplicatedHoudiniComponent->IsPendingKill() )
|
|
return;
|
|
|
|
TMap< HAPI_ParmId, UHoudiniAssetParameter * > & InParameters = DuplicatedHoudiniComponent->Parameters;
|
|
TMap< FString, UHoudiniAssetParameter * > & InParametersByName = DuplicatedHoudiniComponent->ParameterByName;
|
|
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
HAPI_ParmId HoudiniAssetParameterKey = IterParams.Key();
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if ( !HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill() )
|
|
continue;
|
|
|
|
if (HoudiniAssetParameterKey == -1)
|
|
continue;
|
|
|
|
// Duplicate parameter.
|
|
UHoudiniAssetParameter * DuplicatedHoudiniAssetParameter = HoudiniAssetParameter->Duplicate( DuplicatedHoudiniComponent );
|
|
if (!DuplicatedHoudiniAssetParameter || DuplicatedHoudiniAssetParameter->IsPendingKill())
|
|
continue;
|
|
|
|
// PIE does not like standalone flags.
|
|
DuplicatedHoudiniAssetParameter->ClearFlags( RF_Standalone );
|
|
DuplicatedHoudiniAssetParameter->SetHoudiniAssetComponent( DuplicatedHoudiniComponent );
|
|
|
|
// For Input Parameters
|
|
UHoudiniAssetInput* HoudiniAssetInputParameter = Cast< UHoudiniAssetInput >(HoudiniAssetParameter);
|
|
UHoudiniAssetInput* DuplicatedHoudiniAssetInputParameter = Cast< UHoudiniAssetInput >(DuplicatedHoudiniAssetParameter);
|
|
if(HoudiniAssetInputParameter && DuplicatedHoudiniAssetInputParameter)
|
|
{
|
|
// Invalidate the node ids on the duplicate so that new inputs will be created.
|
|
DuplicatedHoudiniAssetInputParameter->InvalidateNodeIds();
|
|
|
|
// We also need to duplicate the attached curves properly
|
|
DuplicatedHoudiniAssetInputParameter->DuplicateCurves(HoudiniAssetInputParameter);
|
|
}
|
|
|
|
InParameters.Add( HoudiniAssetParameterKey, DuplicatedHoudiniAssetParameter );
|
|
InParametersByName.Add(
|
|
DuplicatedHoudiniAssetParameter->GetParameterName(),
|
|
DuplicatedHoudiniAssetParameter );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::DuplicateHandles( UHoudiniAssetComponent * SrcAssetComponent )
|
|
{
|
|
if (!SrcAssetComponent || SrcAssetComponent->IsPendingKill())
|
|
return;
|
|
|
|
for ( auto const & SrcNameToHandle : SrcAssetComponent->HandleComponents )
|
|
{
|
|
if (!SrcNameToHandle.Value || SrcNameToHandle.Value->IsPendingKill())
|
|
continue;
|
|
|
|
// Duplicate spline component.
|
|
UHoudiniHandleComponent * NewHandleComponent =
|
|
DuplicateObject< UHoudiniHandleComponent >( SrcNameToHandle.Value, this );
|
|
|
|
if ( NewHandleComponent && !NewHandleComponent->IsPendingKill() )
|
|
{
|
|
NewHandleComponent->SetFlags( RF_Transactional | RF_Public );
|
|
NewHandleComponent->ResolveDuplicatedParameters( Parameters );
|
|
HandleComponents.Add( SrcNameToHandle.Key, NewHandleComponent );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::DuplicateInputs( UHoudiniAssetComponent * DuplicatedHoudiniComponent )
|
|
{
|
|
if (!DuplicatedHoudiniComponent || DuplicatedHoudiniComponent->IsPendingKill())
|
|
return;
|
|
|
|
TArray< UHoudiniAssetInput * > & InInputs = DuplicatedHoudiniComponent->Inputs;
|
|
for ( int32 InputIdx = 0; InputIdx < Inputs.Num(); ++InputIdx )
|
|
{
|
|
// Retrieve input at this index.
|
|
UHoudiniAssetInput * AssetInput = Inputs[ InputIdx ];
|
|
if (!AssetInput || AssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
// Duplicate input.
|
|
UHoudiniAssetInput * DuplicateAssetInput = DuplicateObject( AssetInput, DuplicatedHoudiniComponent );
|
|
if (!DuplicateAssetInput || DuplicateAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
DuplicateAssetInput->SetHoudiniAssetComponent( DuplicatedHoudiniComponent );
|
|
|
|
// Invalidate the node ids on the duplicate so that new inputs will be created.
|
|
DuplicateAssetInput->InvalidateNodeIds();
|
|
|
|
// We also need to duplicate the attached curves properly
|
|
DuplicateAssetInput->DuplicateCurves(AssetInput);
|
|
|
|
// PIE does not like standalone flags.
|
|
DuplicateAssetInput->ClearFlags( RF_Standalone );
|
|
|
|
InInputs.Add( DuplicateAssetInput );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::DuplicateInstanceInputs( UHoudiniAssetComponent * DuplicatedHoudiniComponent, const TMap<UObject*, UObject*>& ReplacementMap )
|
|
{
|
|
if ( !DuplicatedHoudiniComponent || DuplicatedHoudiniComponent->IsPendingKill() )
|
|
return;
|
|
|
|
auto& InInstanceInputs = DuplicatedHoudiniComponent->InstanceInputs;
|
|
|
|
for ( auto& HoudiniAssetInstanceInput : InstanceInputs )
|
|
{
|
|
if ( !HoudiniAssetInstanceInput && HoudiniAssetInstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
UHoudiniAssetInstanceInput * DuplicatedHoudiniAssetInstanceInput =
|
|
UHoudiniAssetInstanceInput::Create( DuplicatedHoudiniComponent, HoudiniAssetInstanceInput );
|
|
|
|
if ( !DuplicatedHoudiniAssetInstanceInput || DuplicatedHoudiniAssetInstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
// PIE does not like standalone flags.
|
|
DuplicatedHoudiniAssetInstanceInput->ClearFlags( RF_Standalone );
|
|
|
|
InInstanceInputs.Add( DuplicatedHoudiniAssetInstanceInput );
|
|
|
|
// remap our instanced objects (only necessary for unbaked assets)
|
|
for( UHoudiniAssetInstanceInputField* InputField : DuplicatedHoudiniAssetInstanceInput->GetInstanceInputFields() )
|
|
{
|
|
if ( !InputField || InputField->IsPendingKill() )
|
|
continue;
|
|
|
|
InputField->FixInstancedObjects( ReplacementMap );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::CreateAllLandscapes( const TArray< FHoudiniGeoPartObject > & FoundVolumes )
|
|
{
|
|
if ( FoundVolumes.Num() <= 0 )
|
|
return false;
|
|
|
|
// Try to create a Landscape for each HeightData found
|
|
TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> > NewLandscapes;
|
|
|
|
FHoudiniCookParams HoudiniCookParams( this );
|
|
HoudiniCookParams.StaticMeshBakeMode = FHoudiniCookParams::GetDefaultStaticMeshesCookMode();
|
|
HoudiniCookParams.MaterialAndTextureBakeMode = FHoudiniCookParams::GetDefaultMaterialAndTextureCookMode();
|
|
|
|
// Keep a map of the valid landscape, this is to ensure that none of the new/input landscapes will be destroyed when cleaning up the old map
|
|
TArray<ALandscapeProxy *> ValidLandscapes;
|
|
// See if we have any landscape input that is marked as needing an update
|
|
TArray<ALandscapeProxy *> InputLandscapesToUpdate;
|
|
// Get all the inputs, including the object merge inputs
|
|
TArray< UHoudiniAssetInput * > AllInputs;
|
|
GetInputs(AllInputs, true);
|
|
for ( auto CurrentInput : AllInputs)
|
|
{
|
|
if ( !CurrentInput )
|
|
continue;
|
|
|
|
if ( CurrentInput->GetChoiceIndex() != EHoudiniAssetInputType::Enum::LandscapeInput )
|
|
continue;
|
|
|
|
ALandscapeProxy* InputLandscape = CurrentInput->GetLandscapeInput();
|
|
if ( !InputLandscape || InputLandscape->IsPendingKill() )
|
|
continue;
|
|
|
|
ValidLandscapes.Add( InputLandscape );
|
|
|
|
if ( CurrentInput->IsUpdatingInputLandscape() )
|
|
InputLandscapesToUpdate.Add( CurrentInput->GetLandscapeInput() );
|
|
}
|
|
|
|
if ( !FHoudiniLandscapeUtils::CreateAllLandscapes( HoudiniCookParams, FoundVolumes, LandscapeComponents, NewLandscapes, InputLandscapesToUpdate ) )
|
|
return false;
|
|
|
|
// The asset needs to be static in order to attach the landscapes to it
|
|
SetMobility( EComponentMobility::Static );
|
|
|
|
for ( TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TIterator IterLandscape( NewLandscapes ); IterLandscape; ++IterLandscape )
|
|
{
|
|
ALandscapeProxy* NewLandscape = IterLandscape.Value().Get();
|
|
if ( !NewLandscape || !NewLandscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
// Add the new landscape to the valid list to avoid its destruction if we updated it
|
|
ValidLandscapes.Add( NewLandscape );
|
|
|
|
// Attach the new landscapes to ourselves if we dont already own it
|
|
if ( GetAttachChildren().Find( NewLandscape->GetRootComponent() ) == INDEX_NONE )
|
|
NewLandscape->AttachToComponent(this, FAttachmentTransformRules::KeepRelativeTransform);
|
|
|
|
FHoudiniGeoPartObject Heightfield = IterLandscape.Key();
|
|
|
|
// Update the materials from our assignement/replacement and the materials assigned on the previous version of this landscape
|
|
UpdateLandscapeMaterialsAssignementsAndReplacements( NewLandscape, Heightfield );
|
|
|
|
// Replace any reference we might still have to the old landscape with the new one
|
|
TWeakObjectPtr<ALandscapeProxy>* OldLandscapePtr = LandscapeComponents.Find( Heightfield );
|
|
if ( !OldLandscapePtr)
|
|
continue;
|
|
|
|
ALandscapeProxy* OldLandscape = OldLandscapePtr->Get();
|
|
if ( !OldLandscape || !OldLandscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
if ( OldLandscape != NewLandscape )
|
|
FHoudiniLandscapeUtils::UpdateOldLandscapeReference( OldLandscape, NewLandscape );
|
|
}
|
|
|
|
// Replace the old landscapes map with the new ones
|
|
for (TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TIterator Iter( LandscapeComponents ); Iter; ++Iter)
|
|
{
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value().Get();
|
|
if ( !HoudiniLandscape || HoudiniLandscape->IsPendingKill() || !HoudiniLandscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
if ( ValidLandscapes.Contains( HoudiniLandscape ) )
|
|
continue;
|
|
|
|
HoudiniLandscape->UnregisterAllComponents();
|
|
HoudiniLandscape->Destroy();
|
|
}
|
|
|
|
LandscapeComponents.Empty();
|
|
LandscapeComponents = NewLandscapes;
|
|
|
|
return true;
|
|
}
|
|
|
|
void UHoudiniAssetComponent::UpdateLandscapeMaterialsAssignementsAndReplacements(ALandscapeProxy* Landscape, FHoudiniGeoPartObject Heightfield )
|
|
{
|
|
if ( !Landscape )
|
|
return;
|
|
|
|
// Handle the material assignment/replacement here
|
|
UMaterialInterface* LandscapeMaterial = Landscape->GetLandscapeMaterial();
|
|
if ( LandscapeMaterial )
|
|
{
|
|
// Make sure this material is in the assignements before trying to replacing it.
|
|
if ( !GetAssignmentMaterial( LandscapeMaterial->GetName() ) && HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
HoudiniAssetComponentMaterials->Assignments.Add( LandscapeMaterial->GetName(), LandscapeMaterial );
|
|
|
|
// See if we have a replacement material for this.
|
|
UMaterialInterface * ReplacementMaterialInterface = GetReplacementMaterial( Heightfield, LandscapeMaterial->GetName() );
|
|
if ( ReplacementMaterialInterface )
|
|
LandscapeMaterial = ReplacementMaterialInterface;
|
|
}
|
|
|
|
UMaterialInterface* LandscapeHoleMaterial = Landscape->GetLandscapeHoleMaterial();
|
|
if ( LandscapeHoleMaterial )
|
|
{
|
|
// Make sure this material is in the assignemets before trying to replacing it.
|
|
if ( !GetAssignmentMaterial( LandscapeHoleMaterial->GetName() ) && HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
HoudiniAssetComponentMaterials->Assignments.Add( LandscapeHoleMaterial->GetName(), LandscapeHoleMaterial );
|
|
|
|
// See if we have a replacement material for this.
|
|
UMaterialInterface * ReplacementMaterialInterface = GetReplacementMaterial( Heightfield, LandscapeHoleMaterial->GetName() );
|
|
if ( ReplacementMaterialInterface )
|
|
LandscapeHoleMaterial = ReplacementMaterialInterface;
|
|
}
|
|
|
|
// Try to see if we can find materials used by the previous landscape for this Heightfield
|
|
// ( the user might have replaced the landscape materials manually without us knowing it )
|
|
if ( LandscapeComponents.Contains( Heightfield ) )
|
|
{
|
|
ALandscapeProxy* PreviousLandscape = LandscapeComponents[ Heightfield ].Get();
|
|
if ( PreviousLandscape && PreviousLandscape->IsValidLowLevel() )
|
|
{
|
|
// Get the previously used materials, but ignore the default ones
|
|
UMaterialInterface* PreviousLandscapeMaterial = PreviousLandscape->GetLandscapeMaterial();
|
|
if ( PreviousLandscapeMaterial == UMaterial::GetDefaultMaterial( MD_Surface ) )
|
|
PreviousLandscapeMaterial = nullptr;
|
|
|
|
if ( PreviousLandscapeMaterial && PreviousLandscapeMaterial != LandscapeMaterial )
|
|
{
|
|
ReplaceMaterial( Heightfield, PreviousLandscapeMaterial, LandscapeMaterial, 0 );
|
|
LandscapeMaterial = PreviousLandscapeMaterial;
|
|
}
|
|
|
|
// Do the same thing for the hole material
|
|
UMaterialInterface* PreviousLandscapeHoleMaterial = PreviousLandscape->GetLandscapeHoleMaterial();
|
|
if ( PreviousLandscapeHoleMaterial == UMaterial::GetDefaultMaterial( MD_Surface ) )
|
|
PreviousLandscapeHoleMaterial = nullptr;
|
|
|
|
if ( PreviousLandscapeHoleMaterial && PreviousLandscapeHoleMaterial != LandscapeHoleMaterial )
|
|
{
|
|
ReplaceMaterial( Heightfield, PreviousLandscapeHoleMaterial, LandscapeHoleMaterial, 0 );
|
|
LandscapeHoleMaterial = PreviousLandscapeHoleMaterial;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Assign the new material if they have been updated
|
|
if ( Landscape->LandscapeMaterial != LandscapeMaterial )
|
|
Landscape->LandscapeMaterial = LandscapeMaterial;
|
|
|
|
if ( Landscape->LandscapeHoleMaterial != LandscapeHoleMaterial )
|
|
Landscape->LandscapeHoleMaterial = LandscapeHoleMaterial;
|
|
|
|
Landscape->UpdateAllComponentMaterialInstances();
|
|
|
|
/*
|
|
// As UpdateAllComponentMaterialInstances() is not accessible to us, we'll try to access the Material's UProperty
|
|
// to trigger a fake Property change event that will call the Update function...
|
|
UProperty* FoundProperty = FindField< UProperty >(Landscape->GetClass(), (MaterialIdx == 0) ? TEXT("LandscapeMaterial") : TEXT("LandscapeHoleMaterial"));
|
|
if (FoundProperty)
|
|
{
|
|
FPropertyChangedEvent PropChanged(FoundProperty, EPropertyChangeType::ValueSet);
|
|
Landscape->PostEditChangeProperty(PropChanged);
|
|
}
|
|
*/
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::ReplaceLandscapeInInputs(ALandscapeProxy* Old, ALandscapeProxy* New )
|
|
{
|
|
bool bReturn = false;
|
|
|
|
// First, get all the inputs, including the object path parameters
|
|
TArray< UHoudiniAssetInput * > AllInputs;
|
|
GetInputs( AllInputs, true );
|
|
|
|
// Look for landscape input, selecting the old landscape
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( AllInputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( !HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( HoudiniAssetInput->GetChoiceIndex() != EHoudiniAssetInputType::LandscapeInput )
|
|
continue;
|
|
|
|
if ( Old != HoudiniAssetInput->GetLandscapeInput() )
|
|
continue;
|
|
|
|
HoudiniAssetInput->OnLandscapeActorSelected( New );
|
|
HoudiniAssetInput->UploadParameterValue();
|
|
|
|
bReturn = true;
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
#endif
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearInstanceInputs()
|
|
{
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if ( InstanceInput && !InstanceInput->IsPendingKill() )
|
|
InstanceInput->ConditionalBeginDestroy();
|
|
}
|
|
|
|
InstanceInputs.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearCurves()
|
|
{
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent*>::TIterator Iter( SplineComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniSplineComponent * SplineComponent = Iter.Value();
|
|
if (SplineComponent)
|
|
{
|
|
SplineComponent->DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
|
|
SplineComponent->UnregisterComponent();
|
|
SplineComponent->DestroyComponent();
|
|
}
|
|
}
|
|
|
|
SplineComponents.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearLandscapes()
|
|
{
|
|
for (TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TIterator Iter(LandscapeComponents); Iter; ++Iter)
|
|
{
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value().Get();
|
|
if ( !IsValid( HoudiniLandscape ) || !HoudiniLandscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
// Make sure we never destroy an input landscape
|
|
bool IsCurrentLandscapeAnInput = false;
|
|
for (auto CurrentInput : Inputs)
|
|
{
|
|
if (!CurrentInput)
|
|
continue;
|
|
|
|
if (CurrentInput->GetChoiceIndex() != EHoudiniAssetInputType::Enum::LandscapeInput)
|
|
continue;
|
|
|
|
ALandscapeProxy* InputLandscape = CurrentInput->GetLandscapeInput();
|
|
if (!InputLandscape || InputLandscape->IsPendingKill())
|
|
continue;
|
|
|
|
IsCurrentLandscapeAnInput = true;
|
|
break;
|
|
}
|
|
|
|
if ( IsCurrentLandscapeAnInput )
|
|
continue;
|
|
|
|
HoudiniLandscape->UnregisterAllComponents();
|
|
HoudiniLandscape->Destroy();
|
|
}
|
|
|
|
LandscapeComponents.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearParameters()
|
|
{
|
|
for ( auto Iter : Parameters )
|
|
{
|
|
if ( Iter.Value && !Iter.Value->IsPendingKill() )
|
|
{
|
|
Iter.Value->ConditionalBeginDestroy();
|
|
}
|
|
else if(GetWorld() != NULL && GetWorld()->WorldType != EWorldType::PIE)
|
|
{
|
|
// Avoid spamming that error when leaving PIE mode
|
|
HOUDINI_LOG_WARNING(TEXT("%s: null parameter when clearing"), GetOwner() ? *(GetOwner()->GetName()) : *GetName());
|
|
}
|
|
}
|
|
|
|
Parameters.Empty();
|
|
ParameterByName.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearHandles()
|
|
{
|
|
for ( auto & NameToComponent : HandleComponents )
|
|
{
|
|
UHoudiniHandleComponent * HandleComponent = NameToComponent.Value;
|
|
|
|
HandleComponent->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
|
|
HandleComponent->UnregisterComponent();
|
|
HandleComponent->DestroyComponent();
|
|
}
|
|
|
|
HandleComponents.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearInputs()
|
|
{
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( !HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if (HoudiniAssetInput->HasAnyFlags(RF_NeedLoad | RF_NeedPostLoad))
|
|
continue;
|
|
|
|
// Destroy connected Houdini asset.
|
|
HoudiniAssetInput->ConditionalBeginDestroy();
|
|
}
|
|
|
|
Inputs.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearDownstreamAssets()
|
|
{
|
|
for ( TMap< UHoudiniAssetComponent *, TSet< int32 > >::TIterator IterAssets(DownstreamAssetConnections );
|
|
IterAssets; ++IterAssets )
|
|
{
|
|
UHoudiniAssetComponent * DownstreamAsset = IterAssets.Key();
|
|
if (!DownstreamAsset || DownstreamAsset->IsPendingKill())
|
|
continue;
|
|
|
|
TSet< int32 > & LocalInputIndicies = IterAssets.Value();
|
|
for ( auto LocalInputIndex : LocalInputIndicies )
|
|
{
|
|
if( DownstreamAsset->Inputs.IsValidIndex( LocalInputIndex )
|
|
&& DownstreamAsset->Inputs[ LocalInputIndex ] != nullptr
|
|
&& !DownstreamAsset->Inputs[LocalInputIndex]->IsPendingKill() )
|
|
{
|
|
DownstreamAsset->Inputs[ LocalInputIndex ]->ExternalDisconnectInputAssetActor();
|
|
}
|
|
else
|
|
{
|
|
// It could be connected as an operator path parameter
|
|
bool DidADisconnect = false;
|
|
for( auto& OtherParmElem : DownstreamAsset->Parameters )
|
|
{
|
|
UHoudiniAssetInput* OtherParm = Cast<UHoudiniAssetInput>(OtherParmElem.Value);
|
|
if (!OtherParm || OtherParm->IsPendingKill())
|
|
continue;
|
|
|
|
if( OtherParm->GetConnectedInputAssetComponent() == this && OtherParm->IsInputAssetConnected() )
|
|
{
|
|
OtherParm->ExternalDisconnectInputAssetActor();
|
|
DidADisconnect = true;
|
|
}
|
|
}
|
|
|
|
if ( !DidADisconnect )
|
|
HOUDINI_LOG_ERROR( TEXT( "%s: Invalid downstream asset connection" ), GetOwner() ? *(GetOwner()->GetName()) : *GetName());
|
|
}
|
|
}
|
|
}
|
|
|
|
DownstreamAssetConnections.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::ClearCookTempFile()
|
|
{
|
|
// First, Clean up the assignement/replacement map
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
HoudiniAssetComponentMaterials->ResetMaterialInfo();
|
|
|
|
// Then delete all the materials
|
|
for ( TMap<FString, TWeakObjectPtr< UPackage > > ::TIterator IterPackage(CookedTemporaryPackages );
|
|
IterPackage; ++IterPackage)
|
|
{
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( !Package )
|
|
continue;
|
|
|
|
Package->ClearFlags( RF_Standalone );
|
|
//Package->ConditionalBeginDestroy();
|
|
}
|
|
|
|
CookedTemporaryPackages.Empty();
|
|
|
|
// Delete all cooked Static Meshes
|
|
for ( TMap<FHoudiniGeoPartObject, TWeakObjectPtr< UPackage > > ::TIterator IterPackage( CookedTemporaryStaticMeshPackages );
|
|
IterPackage; ++IterPackage )
|
|
{
|
|
UPackage * Package = IterPackage.Value().Get();
|
|
if ( !Package )
|
|
continue;
|
|
|
|
Package->ClearFlags( RF_Standalone );
|
|
//Package->ConditionalBeginDestroy();
|
|
}
|
|
|
|
CookedTemporaryStaticMeshPackages.Empty();
|
|
|
|
// Delete all cooked Landscape Layers
|
|
for ( TMap<TWeakObjectPtr< UPackage >, FHoudiniGeoPartObject > ::TIterator IterPackage(CookedTemporaryLandscapeLayers);
|
|
IterPackage; ++IterPackage )
|
|
{
|
|
UPackage * Package = IterPackage.Key().Get();
|
|
if ( !Package )
|
|
continue;
|
|
|
|
Package->ClearFlags( RF_Standalone );
|
|
//Package->ConditionalBeginDestroy();
|
|
}
|
|
|
|
CookedTemporaryLandscapeLayers.Empty();
|
|
}
|
|
|
|
UStaticMesh *
|
|
UHoudiniAssetComponent::LocateStaticMesh( const FHoudiniGeoPartObject & HoudiniGeoPartObject, const bool& ExactSearch ) const
|
|
{
|
|
UStaticMesh * const * FoundStaticMesh = StaticMeshes.Find( HoudiniGeoPartObject );
|
|
UStaticMesh * StaticMesh = nullptr;
|
|
|
|
if ( !ExactSearch && !FoundStaticMesh )
|
|
{
|
|
// We couldnt find the exact SM corresponding to this geo part
|
|
// Try again without caring for the split id
|
|
for (TMap< FHoudiniGeoPartObject, UStaticMesh * >::TConstIterator IterSM( StaticMeshes ); IterSM; ++IterSM )
|
|
{
|
|
const FHoudiniGeoPartObject& HGPO = IterSM.Key();
|
|
if (HGPO.AssetId == HoudiniGeoPartObject.AssetId && HGPO.ObjectId == HoudiniGeoPartObject.ObjectId
|
|
&& HGPO.GeoId == HoudiniGeoPartObject.GeoId && HGPO.PartId == HoudiniGeoPartObject.PartId)
|
|
{
|
|
FoundStaticMesh = &IterSM.Value();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( FoundStaticMesh )
|
|
StaticMesh = *FoundStaticMesh;
|
|
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
return nullptr;
|
|
|
|
return StaticMesh;
|
|
}
|
|
|
|
UStaticMeshComponent *
|
|
UHoudiniAssetComponent::LocateStaticMeshComponent( const UStaticMesh * StaticMesh ) const
|
|
{
|
|
UStaticMeshComponent * const * FoundStaticMeshComponent = StaticMeshComponents.Find( StaticMesh );
|
|
UStaticMeshComponent * StaticMeshComponent = nullptr;
|
|
|
|
if ( FoundStaticMeshComponent )
|
|
StaticMeshComponent = *FoundStaticMeshComponent;
|
|
|
|
if ( StaticMeshComponent && StaticMeshComponent->IsPendingKill() )
|
|
return nullptr;
|
|
|
|
return StaticMeshComponent;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::LocateInstancedStaticMeshComponents(
|
|
const UStaticMesh * StaticMesh, TArray< UInstancedStaticMeshComponent * > & Components ) const
|
|
{
|
|
Components.Empty();
|
|
|
|
bool bResult = false;
|
|
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if ( InstanceInput && !InstanceInput->IsPendingKill() )
|
|
bResult |= InstanceInput->CollectAllInstancedStaticMeshComponents( Components, StaticMesh );
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
UHoudiniSplineComponent*
|
|
UHoudiniAssetComponent::LocateSplineComponent(const FHoudiniGeoPartObject & HoudiniGeoPartObject) const
|
|
{
|
|
UHoudiniSplineComponent * const * FoundHoudiniSplineComponent = SplineComponents.Find(HoudiniGeoPartObject);
|
|
UHoudiniSplineComponent * SplineComponent = nullptr;
|
|
|
|
if ( FoundHoudiniSplineComponent )
|
|
SplineComponent = *FoundHoudiniSplineComponent;
|
|
|
|
if ( !SplineComponent || SplineComponent->IsPendingKill() || !SplineComponent->IsValidLowLevel() )
|
|
return nullptr;
|
|
|
|
return SplineComponent;
|
|
}
|
|
|
|
// Allow searching of geopart in array by names and not guid
|
|
UStaticMesh *
|
|
UHoudiniAssetComponent::LocateStaticMeshByNames(const FHoudiniGeoPartObject & HoudiniGeoPartObject, const TMap< FHoudiniGeoPartObject, UStaticMesh * >& FindInMap) const
|
|
{
|
|
UStaticMesh * StaticMesh = nullptr;
|
|
|
|
// Find via the object and Part names.
|
|
for (TMap< FHoudiniGeoPartObject, UStaticMesh * >::TConstIterator IterSM(FindInMap); IterSM; ++IterSM)
|
|
{
|
|
const FHoudiniGeoPartObject& HGPO = IterSM.Key();
|
|
if (HGPO.CompareNames(HoudiniGeoPartObject))
|
|
{
|
|
StaticMesh = IterSM.Value();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!StaticMesh || StaticMesh->IsPendingKill())
|
|
return nullptr;
|
|
|
|
return StaticMesh;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SerializeInputs( FArchive & Ar )
|
|
{
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
if ( !Ar.IsTransacting() )
|
|
ClearInputs();
|
|
}
|
|
|
|
// We have to make sure that inputs are NOT saved with an empty name, as this will cause UE to crash on load
|
|
for (TArray< UHoudiniAssetInput * >::TIterator IterInputs(Inputs); IterInputs; ++IterInputs)
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if (!HoudiniAssetInput || HoudiniAssetInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if (HoudiniAssetInput->GetFName() != NAME_None)
|
|
continue;
|
|
|
|
// Calling Rename with null parameters will make sure the instanced input has a unique name
|
|
HoudiniAssetInput->Rename();
|
|
}
|
|
|
|
Ar << Inputs;
|
|
|
|
if ( Ar.IsTransacting() )
|
|
{
|
|
for (int32 InputIdx = 0; InputIdx < Inputs.Num(); ++InputIdx)
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = Inputs[InputIdx];
|
|
if ( HoudiniAssetInput && !HoudiniAssetInput->IsPendingKill() )
|
|
HoudiniAssetInput->Serialize(Ar);
|
|
}
|
|
}
|
|
else if ( Ar.IsLoading() )
|
|
{
|
|
for ( int32 InputIdx = 0; InputIdx < Inputs.Num(); ++InputIdx )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = Inputs[ InputIdx ];
|
|
if (HoudiniAssetInput && !HoudiniAssetInput->IsPendingKill())
|
|
Inputs[ InputIdx ]->SetHoudiniAssetComponent( this );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SerializeInstanceInputs( FArchive & Ar )
|
|
{
|
|
if ( Ar.IsLoading() )
|
|
{
|
|
// When loading for undo, we want to call Serialize on each InstanceInput
|
|
if ( !Ar.IsTransacting() )
|
|
ClearInstanceInputs();
|
|
|
|
int32 HoudiniAssetComponentVersion = Ar.CustomVer( FHoudiniCustomSerializationVersion::GUID );
|
|
if ( HoudiniAssetComponentVersion > VER_HOUDINI_ENGINE_COMPONENT_PARAMETER_NAME_MAP )
|
|
{
|
|
Ar << InstanceInputs;
|
|
}
|
|
else
|
|
{
|
|
int32 InstanceInputCount = 0;
|
|
Ar << InstanceInputCount;
|
|
|
|
InstanceInputs.SetNumUninitialized( InstanceInputCount );
|
|
|
|
for ( int32 InstanceInputIdx = 0; InstanceInputIdx < InstanceInputCount; ++InstanceInputIdx )
|
|
{
|
|
HAPI_NodeId HoudiniInstanceInputKey = -1;
|
|
|
|
Ar << HoudiniInstanceInputKey;
|
|
Ar << InstanceInputs[ InstanceInputIdx ];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We have to make sure that instanced inputs are NOT saved with an empty name, as this will cause UE to crash on load
|
|
for ( TArray< UHoudiniAssetInstanceInput * >::TIterator IterInstance(InstanceInputs ); IterInstance; ++IterInstance )
|
|
{
|
|
UHoudiniAssetInstanceInput * HoudiniInstanceInput = *IterInstance;
|
|
if ( !HoudiniInstanceInput || HoudiniInstanceInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( HoudiniInstanceInput->GetFName() != NAME_None )
|
|
continue;
|
|
|
|
// Calling Rename with null parameters will make sure the instanced input has a unique name
|
|
HoudiniInstanceInput->Rename();
|
|
}
|
|
|
|
Ar << InstanceInputs;
|
|
}
|
|
|
|
if ( Ar.IsTransacting() )
|
|
{
|
|
for ( UHoudiniAssetInstanceInput* InstanceInput : InstanceInputs )
|
|
{
|
|
if ( InstanceInput && !InstanceInput->IsPendingKill() )
|
|
InstanceInput->Serialize( Ar );
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SerializeParameters( FArchive & Ar )
|
|
{
|
|
// We have to make sure that parameter are NOT saaved with an empty name, as this will cause UE to crash on load
|
|
for (TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams(Parameters); IterParams; ++IterParams)
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill() )
|
|
continue;
|
|
|
|
if (HoudiniAssetParameter->GetFName() != NAME_None)
|
|
continue;
|
|
|
|
// Calling Rename with null parameters will make sure the parameter has a unique name
|
|
HoudiniAssetParameter->Rename();
|
|
}
|
|
|
|
Ar << Parameters;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostLoadInitializeInstanceInputs()
|
|
{
|
|
for ( auto& InstanceInput : InstanceInputs )
|
|
{
|
|
if (InstanceInput && !InstanceInput->IsPendingKill() )
|
|
InstanceInput->SetHoudiniAssetComponent( this );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::PostLoadInitializeParameters()
|
|
{
|
|
// We need to re-patch parent parameter links.
|
|
for ( TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams( Parameters ); IterParams; ++IterParams )
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if (!HoudiniAssetParameter || HoudiniAssetParameter->IsPendingKill())
|
|
continue;
|
|
|
|
HoudiniAssetParameter->SetHoudiniAssetComponent( this );
|
|
|
|
HAPI_ParmId ParentParameterId = HoudiniAssetParameter->GetParmParentId();
|
|
if ( ParentParameterId != -1 )
|
|
{
|
|
UHoudiniAssetParameter * const * FoundParentParameter = Parameters.Find( ParentParameterId );
|
|
if (FoundParentParameter)
|
|
{
|
|
if ( *FoundParentParameter && !(*FoundParentParameter)->IsPendingKill() )
|
|
HoudiniAssetParameter->SetParentParameter(*FoundParentParameter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::RemoveStaticMeshComponent( UStaticMesh * StaticMesh )
|
|
{
|
|
UStaticMeshComponent * const * FoundStaticMeshComponent = StaticMeshComponents.Find( StaticMesh );
|
|
if ( FoundStaticMeshComponent )
|
|
{
|
|
StaticMeshComponents.Remove( StaticMesh );
|
|
|
|
UStaticMeshComponent * StaticMeshComponent = *FoundStaticMeshComponent;
|
|
if ( StaticMeshComponent && !StaticMeshComponent->IsPendingKill() )
|
|
{
|
|
StaticMeshComponent->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
|
|
StaticMeshComponent->UnregisterComponent();
|
|
StaticMeshComponent->DestroyComponent();
|
|
}
|
|
}
|
|
}
|
|
|
|
const FGuid &
|
|
UHoudiniAssetComponent::GetComponentGuid() const
|
|
{
|
|
return ComponentGUID;
|
|
}
|
|
|
|
UMaterialInterface *
|
|
UHoudiniAssetComponent::GetReplacementMaterial(
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject,
|
|
const FString & MaterialName )
|
|
{
|
|
UMaterialInterface * ReplacementMaterial = nullptr;
|
|
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
TMap< FHoudiniGeoPartObject, TMap< FString, UMaterialInterface * > > & MaterialReplacements =
|
|
HoudiniAssetComponentMaterials->Replacements;
|
|
|
|
if ( MaterialReplacements.Contains( HoudiniGeoPartObject ) )
|
|
{
|
|
TMap< FString, UMaterialInterface * > & FoundReplacements = MaterialReplacements[ HoudiniGeoPartObject ];
|
|
|
|
UMaterialInterface * const * FoundReplacementMaterial = FoundReplacements.Find( MaterialName );
|
|
if ( FoundReplacementMaterial )
|
|
ReplacementMaterial = *FoundReplacementMaterial;
|
|
}
|
|
}
|
|
|
|
return ReplacementMaterial;
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::GetReplacementMaterialShopName(
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject,
|
|
UMaterialInterface * MaterialInterface, FString & MaterialName)
|
|
{
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
TMap< FHoudiniGeoPartObject, TMap< FString, UMaterialInterface * > > & MaterialReplacements =
|
|
HoudiniAssetComponentMaterials->Replacements;
|
|
|
|
if ( MaterialReplacements.Contains( HoudiniGeoPartObject ) )
|
|
{
|
|
TMap< FString, UMaterialInterface * > & FoundReplacements = MaterialReplacements[ HoudiniGeoPartObject ];
|
|
|
|
const FString * FoundMaterialShopName = FoundReplacements.FindKey( MaterialInterface );
|
|
if ( FoundMaterialShopName )
|
|
{
|
|
MaterialName = *FoundMaterialShopName;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
UMaterialInterface *
|
|
UHoudiniAssetComponent::GetAssignmentMaterial( const FString & MaterialName )
|
|
{
|
|
UMaterialInterface * Material = nullptr;
|
|
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
TMap< FString, UMaterialInterface * > & MaterialAssignments = HoudiniAssetComponentMaterials->Assignments;
|
|
|
|
UMaterialInterface * const * FoundMaterial = MaterialAssignments.Find( MaterialName );
|
|
if ( FoundMaterial )
|
|
Material = *FoundMaterial;
|
|
}
|
|
|
|
return Material;
|
|
}
|
|
|
|
void UHoudiniAssetComponent::ClearAssignmentMaterials()
|
|
{
|
|
if( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
HoudiniAssetComponentMaterials->Assignments.Empty();
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::AddAssignmentMaterial( const FString& MaterialName, UMaterialInterface* MaterialInterface )
|
|
{
|
|
if( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
HoudiniAssetComponentMaterials->Assignments.Add( MaterialName, MaterialInterface );
|
|
}
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::ReplaceMaterial(
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject,
|
|
UMaterialInterface * NewMaterialInterface,
|
|
UMaterialInterface * OldMaterialInterface,
|
|
int32 MaterialIndex )
|
|
{
|
|
if ( !HoudiniAssetComponentMaterials || HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
return false;
|
|
|
|
// Check that we do own this GeoPartObject, either via StaticMeshes or Landscapes
|
|
UStaticMesh * StaticMesh = LocateStaticMesh( HoudiniGeoPartObject, false );
|
|
if ( StaticMesh )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = LocateStaticMeshComponent( StaticMesh );
|
|
if ( !StaticMeshComponent )
|
|
{
|
|
TArray< UInstancedStaticMeshComponent * > InstancedStaticMeshComponents;
|
|
if ( !LocateInstancedStaticMeshComponents( StaticMesh, InstancedStaticMeshComponents ) )
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !LandscapeComponents.Find( HoudiniGeoPartObject ) )
|
|
return false;
|
|
}
|
|
|
|
TMap< FHoudiniGeoPartObject, TMap< FString, UMaterialInterface * > > & MaterialReplacements =
|
|
HoudiniAssetComponentMaterials->Replacements;
|
|
|
|
TMap< FString, UMaterialInterface * > & MaterialAssignments = HoudiniAssetComponentMaterials->Assignments;
|
|
|
|
UMaterialInterface * DefaultMaterial = FHoudiniEngine::Get().GetHoudiniDefaultMaterial().Get();
|
|
|
|
if ( !MaterialReplacements.Contains( HoudiniGeoPartObject ) )
|
|
{
|
|
// If there's no replacement map for this geo part object, add one.
|
|
MaterialReplacements.Add( HoudiniGeoPartObject, TMap< FString, UMaterialInterface * >() );
|
|
}
|
|
|
|
// Retrieve replacements for this geo part object.
|
|
TMap< FString, UMaterialInterface * > & MaterialReplacementsValues = MaterialReplacements[ HoudiniGeoPartObject ];
|
|
|
|
const FString * FoundMaterialShopName = MaterialReplacementsValues.FindKey( OldMaterialInterface );
|
|
if ( FoundMaterialShopName )
|
|
{
|
|
// This material has been replaced previously. Replace old material with new material.
|
|
FString MaterialShopName = *FoundMaterialShopName;
|
|
MaterialReplacementsValues.Add( MaterialShopName, NewMaterialInterface );
|
|
}
|
|
else
|
|
{
|
|
UMaterialInterface * OldMaterial = Cast< UMaterialInterface >( OldMaterialInterface );
|
|
if ( OldMaterial )
|
|
{
|
|
// We have no previous replacement for this material, see if we have it in list of material assignments.
|
|
FoundMaterialShopName = MaterialAssignments.FindKey( OldMaterial );
|
|
if ( FoundMaterialShopName )
|
|
{
|
|
// This material has been assigned previously. Add material replacement entry.
|
|
FString MaterialShopName = *FoundMaterialShopName;
|
|
MaterialReplacementsValues.Add( MaterialShopName, NewMaterialInterface );
|
|
}
|
|
else if ( OldMaterial == DefaultMaterial )
|
|
{
|
|
// This is replacement for default material. Add material replacement entry.
|
|
FString MaterialShopName = HAPI_UNREAL_DEFAULT_MATERIAL_NAME;
|
|
MaterialReplacementsValues.Add( MaterialShopName, NewMaterialInterface );
|
|
}
|
|
else
|
|
{
|
|
// External Material?
|
|
MaterialReplacementsValues.Add(OldMaterial->GetName(), NewMaterialInterface);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::SetMaterial( int32 ElementIndex, class UMaterialInterface* Material )
|
|
{
|
|
Super::SetMaterial(ElementIndex, Material);
|
|
|
|
#if WITH_EDITOR
|
|
UpdateEditorProperties(false);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::RemoveReplacementMaterial(
|
|
const FHoudiniGeoPartObject & HoudiniGeoPartObject,
|
|
const FString & MaterialName )
|
|
{
|
|
if ( HoudiniAssetComponentMaterials && !HoudiniAssetComponentMaterials->IsPendingKill() )
|
|
{
|
|
TMap< FHoudiniGeoPartObject, TMap<FString, UMaterialInterface * > > & MaterialReplacements =
|
|
HoudiniAssetComponentMaterials->Replacements;
|
|
|
|
if ( MaterialReplacements.Contains( HoudiniGeoPartObject ) )
|
|
{
|
|
TMap< FString, UMaterialInterface * > & MaterialReplacementsValues =
|
|
MaterialReplacements[ HoudiniGeoPartObject ];
|
|
|
|
MaterialReplacementsValues.Remove( MaterialName );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::CreateOrUpdateMaterialInstances()
|
|
{
|
|
#if WITH_EDITOR
|
|
FHoudiniCookParams HoudiniCookParams( this );
|
|
HoudiniCookParams.PackageGUID = ComponentGUID;
|
|
HoudiniCookParams.MaterialAndTextureBakeMode = FHoudiniCookParams::GetDefaultMaterialAndTextureCookMode();
|
|
|
|
bool bMaterialReplaced = false;
|
|
|
|
// 1. FOR STATIC MESHES
|
|
// Handling the creation of material instances from attributes
|
|
for ( TMap< FHoudiniGeoPartObject, UStaticMesh * >::TIterator Iter( StaticMeshes ); Iter; ++Iter )
|
|
{
|
|
const FHoudiniGeoPartObject HoudiniGeoPartObject = Iter.Key();
|
|
UStaticMesh * StaticMesh = Iter.Value();
|
|
|
|
// Invisible meshes are used for instancers, so we will not skip them as the material instance/parameter attributes
|
|
// need to be set on the "source" mesh
|
|
//if ( !HoudiniGeoPartObject.IsVisible() )
|
|
// continue;
|
|
|
|
if ( !StaticMesh || StaticMesh->IsPendingKill() )
|
|
continue;
|
|
|
|
// Replace the source material with the newly created/updated instance
|
|
for( int32 MatIdx = 0; MatIdx < StaticMesh->StaticMaterials.Num(); MatIdx++ )
|
|
{
|
|
// The "source" material we want to create an instance of should have already been assigned to the mesh
|
|
UMaterialInstance* NewMaterialInstance = nullptr;
|
|
UMaterialInterface* SourceMaterialInterface = nullptr;
|
|
|
|
// Create a new material instance if needed and update its parameter if needed
|
|
if (!FHoudiniEngineMaterialUtils::CreateMaterialInstances(
|
|
HoudiniGeoPartObject, HoudiniCookParams, NewMaterialInstance, SourceMaterialInterface,
|
|
HAPI_UNREAL_ATTRIB_MATERIAL_INSTANCE, MatIdx ) )
|
|
continue;
|
|
|
|
if (!NewMaterialInstance || !SourceMaterialInterface)
|
|
continue;
|
|
|
|
UMaterialInterface * SMMatInterface = StaticMesh->StaticMaterials[ MatIdx ].MaterialInterface;
|
|
if ( SMMatInterface != SourceMaterialInterface && SMMatInterface->GetBaseMaterial() != SourceMaterialInterface )
|
|
continue;
|
|
|
|
// Replace the material assignment
|
|
if ( !ReplaceMaterial( HoudiniGeoPartObject, NewMaterialInstance, SourceMaterialInterface, MatIdx ) )
|
|
continue;
|
|
|
|
// Update the StaticMesh, StaticMeshComponents and Instanced Static Mesh Components
|
|
StaticMesh->Modify();
|
|
StaticMesh->PreEditChange( nullptr );
|
|
StaticMesh->StaticMaterials[ MatIdx ].MaterialInterface = NewMaterialInstance;
|
|
StaticMesh->PostEditChange();
|
|
StaticMesh->MarkPackageDirty();
|
|
|
|
UStaticMeshComponent * StaticMeshComponent = LocateStaticMeshComponent( StaticMesh );
|
|
if ( StaticMeshComponent )
|
|
{
|
|
StaticMeshComponent->Modify();
|
|
StaticMeshComponent->SetMaterial( MatIdx, NewMaterialInstance );
|
|
|
|
bMaterialReplaced = true;
|
|
}
|
|
|
|
TArray< UInstancedStaticMeshComponent * > InstancedStaticMeshComponents;
|
|
if ( LocateInstancedStaticMeshComponents( StaticMesh, InstancedStaticMeshComponents ) )
|
|
{
|
|
for ( int32 Idx = 0; Idx < InstancedStaticMeshComponents.Num(); ++Idx )
|
|
{
|
|
UInstancedStaticMeshComponent * InstancedStaticMeshComponent = InstancedStaticMeshComponents[ Idx ];
|
|
if ( InstancedStaticMeshComponent )
|
|
{
|
|
InstancedStaticMeshComponent->Modify();
|
|
InstancedStaticMeshComponent->SetMaterial( MatIdx, NewMaterialInstance );
|
|
|
|
bMaterialReplaced = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. FOR LANDSCAPES
|
|
// Handling the creation of material instances from attributes
|
|
for ( TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TIterator Iter( LandscapeComponents ); Iter; ++Iter )
|
|
{
|
|
FHoudiniGeoPartObject HoudiniGeoPartObject = Iter.Key();
|
|
ALandscapeProxy* Landscape = Iter.Value().Get();
|
|
if ( !Landscape || !Landscape->IsValidLowLevel() )
|
|
continue;
|
|
|
|
// The "source" landscape material we want to create an instance of should have already been assigned to the landscape
|
|
UMaterialInstance* NewMaterialInstance = nullptr;
|
|
UMaterialInterface* SourceMaterialInterface = nullptr;
|
|
// Create/update a material instance if needed for the Landscape Material
|
|
bool bLandscapeMaterialReplaced = false;
|
|
if ( FHoudiniEngineMaterialUtils::CreateMaterialInstances(
|
|
HoudiniGeoPartObject, HoudiniCookParams, NewMaterialInstance, SourceMaterialInterface, HAPI_UNREAL_ATTRIB_MATERIAL_INSTANCE ) )
|
|
{
|
|
if ( NewMaterialInstance && SourceMaterialInterface )
|
|
{
|
|
// Get the old material.
|
|
UMaterialInterface * OldMaterial = Landscape->GetLandscapeMaterial();
|
|
if ( OldMaterial == SourceMaterialInterface || OldMaterial->GetBaseMaterial() == SourceMaterialInterface )
|
|
{
|
|
// Update our replacement table
|
|
bLandscapeMaterialReplaced = ReplaceMaterial( HoudiniGeoPartObject, OldMaterial, NewMaterialInstance, 0 );
|
|
|
|
// Update the landscape's material itself
|
|
Landscape->Modify();
|
|
Landscape->LandscapeMaterial = NewMaterialInstance;
|
|
bLandscapeMaterialReplaced = true;
|
|
bMaterialReplaced = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Repeat the same process for the Landscape HoleMaterial
|
|
// The "source" hole material we want to create an instance of should have already been assigned to the landscape
|
|
UMaterialInstance* NewHoleMaterialInstance = nullptr;
|
|
UMaterialInterface* SourceHoleMaterialInterface = nullptr;
|
|
// Create/update a material instance if needed for the Landscape Hole Material
|
|
bool bLandscapeHoleMaterialReplaced = false;
|
|
if ( FHoudiniEngineMaterialUtils::CreateMaterialInstances(
|
|
HoudiniGeoPartObject, HoudiniCookParams, NewHoleMaterialInstance, SourceHoleMaterialInterface, HAPI_UNREAL_ATTRIB_MATERIAL_HOLE_INSTANCE ) )
|
|
{
|
|
if ( NewHoleMaterialInstance && SourceHoleMaterialInterface )
|
|
{
|
|
// Get old material.
|
|
UMaterialInterface * OldHoleMaterial = Landscape->GetLandscapeHoleMaterial();
|
|
if (OldHoleMaterial == SourceHoleMaterialInterface || OldHoleMaterial->GetBaseMaterial() == SourceHoleMaterialInterface)
|
|
{
|
|
// Update our replacement table
|
|
bLandscapeHoleMaterialReplaced = ReplaceMaterial(HoudiniGeoPartObject, OldHoleMaterial, NewHoleMaterialInstance, 0);
|
|
|
|
// Update the landscape's hole material
|
|
Landscape->Modify();
|
|
Landscape->LandscapeHoleMaterial = NewHoleMaterialInstance;
|
|
bLandscapeHoleMaterialReplaced = true;
|
|
bMaterialReplaced = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// For the landscape update:
|
|
// As UpdateAllComponentMaterialInstances() is not accessible to us, we'll try to access the Material's UProperty
|
|
// to trigger a fake Property change event that will call the Update function...
|
|
if ( bLandscapeMaterialReplaced )
|
|
{
|
|
FProperty* FoundProperty = FindFProperty< FProperty >( Landscape->GetClass(), TEXT( "LandscapeMaterial" ) );
|
|
if ( FoundProperty )
|
|
{
|
|
FPropertyChangedEvent PropChanged( FoundProperty, EPropertyChangeType::ValueSet );
|
|
Landscape->PostEditChangeProperty( PropChanged );
|
|
}
|
|
}
|
|
|
|
if ( bLandscapeHoleMaterialReplaced )
|
|
{
|
|
FProperty* FoundProperty = FindFProperty< FProperty >( Landscape->GetClass(), TEXT( "LandscapeHoleMaterial" ) );
|
|
if ( FoundProperty )
|
|
{
|
|
FPropertyChangedEvent PropChanged( FoundProperty, EPropertyChangeType::ValueSet );
|
|
Landscape->PostEditChangeProperty( PropChanged );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bMaterialReplaced )
|
|
UpdateEditorProperties( false );
|
|
|
|
return bMaterialReplaced;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool
|
|
UHoudiniAssetComponent::HasAnySockets() const
|
|
{
|
|
// Return true if any of our StaticMeshComponent HasAnySocket
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TConstIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( StaticMeshComponent->HasAnySockets() )
|
|
return true;
|
|
}
|
|
|
|
return Super::HasAnySockets();
|
|
}
|
|
|
|
|
|
/** Get a list of sockets this component contains */
|
|
void
|
|
UHoudiniAssetComponent::QuerySupportedSockets( TArray<FComponentSocketDescription>& OutSockets ) const
|
|
{
|
|
// Query all the sockets in our StaticMeshComponents
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TConstIterator Iter(StaticMeshComponents); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( !StaticMeshComponent->HasAnySockets() )
|
|
continue;
|
|
|
|
TArray< FComponentSocketDescription > ComponentSocket;
|
|
StaticMeshComponent->QuerySupportedSockets( ComponentSocket );
|
|
|
|
OutSockets.Append( ComponentSocket );
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
UHoudiniAssetComponent::DoesSocketExist( FName SocketName ) const
|
|
{
|
|
// Query all the sockets in our StaticMeshComponents
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TConstIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( StaticMeshComponent->DoesSocketExist( SocketName ) )
|
|
return true;
|
|
}
|
|
|
|
return Super::DoesSocketExist( SocketName );
|
|
}
|
|
|
|
|
|
FTransform
|
|
UHoudiniAssetComponent::GetSocketTransform( FName InSocketName, ERelativeTransformSpace TransformSpace ) const
|
|
{
|
|
// Query all the sockets in our StaticMeshComponents
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TConstIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( !StaticMeshComponent )
|
|
continue;
|
|
|
|
if ( !StaticMeshComponent->DoesSocketExist( InSocketName ) )
|
|
continue;
|
|
|
|
return StaticMeshComponent->GetSocketTransform( InSocketName, TransformSpace );
|
|
}
|
|
|
|
return Super::GetSocketTransform( InSocketName, TransformSpace );
|
|
}
|
|
|
|
FBox
|
|
UHoudiniAssetComponent::GetAssetBounds( UHoudiniAssetInput* IgnoreInput, const bool& bIgnoreGeneratedLandscape ) const
|
|
{
|
|
FBox BoxBounds( ForceInitToZero );
|
|
|
|
// Query the bounds of all our static mesh components..
|
|
for ( TMap< UStaticMesh *, UStaticMeshComponent * >::TConstIterator Iter( StaticMeshComponents ); Iter; ++Iter )
|
|
{
|
|
UStaticMeshComponent * StaticMeshComponent = Iter.Value();
|
|
if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
|
|
continue;
|
|
|
|
FBox StaticMeshBounds = StaticMeshComponent->Bounds.GetBox();
|
|
if ( StaticMeshBounds.IsValid )
|
|
BoxBounds += StaticMeshBounds;
|
|
}
|
|
|
|
// Also scan all our decendants for SMC bounds not just top-level children
|
|
// ( split mesh instances' mesh bounds were not gathered proiperly )
|
|
TArray<USceneComponent*> LocalAttachedChildren;
|
|
LocalAttachedChildren.Reserve(16);
|
|
GetChildrenComponents(true, LocalAttachedChildren);
|
|
for (int32 Idx = 0; Idx < LocalAttachedChildren.Num(); ++Idx)
|
|
{
|
|
if (!LocalAttachedChildren[Idx])
|
|
continue;
|
|
|
|
USceneComponent * pChild = LocalAttachedChildren[Idx];
|
|
if (UStaticMeshComponent * StaticMeshComponent = Cast<UStaticMeshComponent>(pChild))
|
|
{
|
|
if (!StaticMeshComponent || StaticMeshComponent->IsPendingKill())
|
|
continue;
|
|
|
|
FBox StaticMeshBounds = StaticMeshComponent->Bounds.GetBox();
|
|
if (StaticMeshBounds.IsValid)
|
|
BoxBounds += StaticMeshBounds;
|
|
}
|
|
}
|
|
|
|
//... all our Handles
|
|
for ( TMap< FString, UHoudiniHandleComponent * >::TConstIterator Iter( HandleComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniHandleComponent * HandleComponent = Iter.Value();
|
|
if ( !HandleComponent )
|
|
continue;
|
|
|
|
BoxBounds += HandleComponent->GetComponentLocation();
|
|
}
|
|
|
|
// ... all our curves
|
|
for ( TMap< FHoudiniGeoPartObject, UHoudiniSplineComponent* >::TConstIterator Iter( SplineComponents ); Iter; ++Iter )
|
|
{
|
|
UHoudiniSplineComponent * SplineComponent = Iter.Value();
|
|
if ( !SplineComponent || !SplineComponent->IsValidLowLevel() )
|
|
continue;
|
|
|
|
TArray<FVector> SplinePositions;
|
|
SplineComponent->GetCurvePositions( SplinePositions );
|
|
|
|
for (int32 n = 0; n < SplinePositions.Num(); n++)
|
|
{
|
|
BoxBounds += SplinePositions[ n ];
|
|
}
|
|
}
|
|
|
|
// ... and inputs
|
|
for ( int32 n = 0; n < Inputs.Num(); n++ )
|
|
{
|
|
UHoudiniAssetInput* CurrentInput = Inputs[ n ];
|
|
if ( !CurrentInput || CurrentInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( CurrentInput == IgnoreInput )
|
|
continue;
|
|
|
|
FBox StaticMeshBounds = CurrentInput->GetInputBounds( GetComponentLocation() );
|
|
if ( StaticMeshBounds.IsValid )
|
|
BoxBounds += StaticMeshBounds;
|
|
}
|
|
|
|
// ... all our landscapes
|
|
if ( !bIgnoreGeneratedLandscape )
|
|
{
|
|
for (TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >::TConstIterator Iter( LandscapeComponents ); Iter; ++Iter )
|
|
{
|
|
ALandscapeProxy * Landscape = Iter.Value().Get();
|
|
if ( !Landscape )
|
|
continue;
|
|
|
|
FVector Origin, Extent;
|
|
Landscape->GetActorBounds( false, Origin, Extent );
|
|
|
|
FBox LandscapeBounds = FBox::BuildAABB( Origin, Extent );
|
|
BoxBounds += LandscapeBounds;
|
|
}
|
|
}
|
|
|
|
// If nothing was found, init with the asset's location
|
|
if ( BoxBounds.GetVolume() == 0.0f )
|
|
BoxBounds += GetComponentLocation();
|
|
|
|
return BoxBounds;
|
|
}
|
|
|
|
bool UHoudiniAssetComponent::HasLandscapeActor(ALandscapeProxy* LandscapeActor ) const
|
|
{
|
|
// Check if we created the landscape
|
|
for (TMap<FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy>>::TConstIterator Iter(LandscapeComponents); Iter; ++Iter)
|
|
{
|
|
ALandscapeProxy * HoudiniLandscape = Iter.Value().Get();
|
|
if ( HoudiniLandscape && HoudiniLandscape == LandscapeActor )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> > *
|
|
UHoudiniAssetComponent::GetLandscapeComponents()
|
|
{
|
|
return &LandscapeComponents;
|
|
}
|
|
|
|
|
|
/** Set the preset Input for HoudiniTools **/
|
|
void
|
|
UHoudiniAssetComponent::SetHoudiniToolInputPresets( const TMap<UObject*, int32>& InPresets )
|
|
{
|
|
#if WITH_EDITOR
|
|
HoudiniToolInputPreset = InPresets;
|
|
#endif
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
void
|
|
UHoudiniAssetComponent::ApplyHoudiniToolInputPreset()
|
|
{
|
|
if ( HoudiniToolInputPreset.Num() <= 0 )
|
|
return;
|
|
|
|
// We'll ignore inputs that have been preset to a curve type
|
|
TArray< UHoudiniAssetInput*> InputArray;
|
|
for ( auto CurrentInput : Inputs )
|
|
{
|
|
if (!CurrentInput || CurrentInput->IsPendingKill())
|
|
continue;
|
|
|
|
if ( CurrentInput->GetChoiceIndex() != EHoudiniAssetInputType::CurveInput )
|
|
InputArray.Add( CurrentInput );
|
|
}
|
|
|
|
// Also look for ObjectPath parameter inputs
|
|
for ( auto CurrentParam : Parameters )
|
|
{
|
|
UHoudiniAssetInput* CurrentInput = Cast< UHoudiniAssetInput > ( CurrentParam.Value );
|
|
if ( !CurrentInput || CurrentInput->IsPendingKill() )
|
|
continue;
|
|
|
|
if ( CurrentInput->GetChoiceIndex() != EHoudiniAssetInputType::CurveInput )
|
|
InputArray.Add( CurrentInput );
|
|
}
|
|
|
|
// Identify some special cases first
|
|
bool OnlyHoudiniAssets = true;
|
|
bool OnlyLandscapes = true;
|
|
bool OnlyOneInput = true;
|
|
for ( TMap< UObject*, int32 >::TIterator IterToolPreset( HoudiniToolInputPreset ); IterToolPreset; ++IterToolPreset )
|
|
{
|
|
UObject * Object = IterToolPreset.Key();
|
|
AHoudiniAssetActor* HAsset = Cast<AHoudiniAssetActor>( Object );
|
|
if ( !HAsset || HAsset->IsPendingKill() )
|
|
OnlyHoudiniAssets = false;
|
|
|
|
ALandscapeProxy* Landscape = Cast<ALandscapeProxy>( Object );
|
|
if ( !Landscape || Landscape->IsPendingKill() )
|
|
OnlyLandscapes = false;
|
|
|
|
if ( IterToolPreset.Value() != 0 )
|
|
OnlyOneInput = false;
|
|
}
|
|
|
|
/*
|
|
if ( OnlyHoudiniAssets )
|
|
{
|
|
// Try to apply the supplied Object to the Input
|
|
for (TMap< UObject*, int32 >::TIterator IterToolPreset( HoudiniToolInputPreset ); IterToolPreset; ++IterToolPreset)
|
|
{
|
|
AHoudiniAssetActor* HAsset = Cast< AHoudiniAssetActor >( IterToolPreset.Key() );
|
|
if (!HAsset)
|
|
continue;
|
|
|
|
int32 InputNumber = IterToolPreset.Value();
|
|
if ( !InputArray.IsValidIndex( InputNumber ) )
|
|
continue;
|
|
|
|
InputArray[ InputNumber ]->ChangeInputType( EHoudiniAssetInputType::AssetInput );
|
|
InputArray[ InputNumber ]->OnInputActorSelected( HAsset );
|
|
}
|
|
}
|
|
else if ( OnlyLandscapes )
|
|
{
|
|
// Try to apply the supplied Object to the Input
|
|
for (TMap< UObject*, int32 >::TIterator IterToolPreset( HoudiniToolInputPreset ); IterToolPreset; ++IterToolPreset)
|
|
{
|
|
ALandscapeProxy* Landscape = Cast< ALandscape >( IterToolPreset.Key() );
|
|
if ( !Landscape )
|
|
continue;
|
|
|
|
int32 InputNumber = IterToolPreset.Value();
|
|
if ( !InputArray.IsValidIndex( InputNumber ) )
|
|
continue;
|
|
|
|
InputArray[ InputNumber ]->ChangeInputType( EHoudiniAssetInputType::LandscapeInput );
|
|
InputArray[ InputNumber ]->OnLandscapeActorSelected( Landscape );
|
|
}
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
// Try to apply the supplied Object to the Input
|
|
for (TMap< UObject*, int32 >::TIterator IterToolPreset( HoudiniToolInputPreset ); IterToolPreset; ++IterToolPreset)
|
|
{
|
|
UObject * Object = IterToolPreset.Key();
|
|
if (!Object || Object->IsPendingKill())
|
|
continue;
|
|
|
|
int32 InputNumber = IterToolPreset.Value();
|
|
|
|
if ( !InputArray.IsValidIndex( InputNumber ) )
|
|
continue;
|
|
|
|
InputArray[ InputNumber ]->AddInputObject( Object );
|
|
|
|
if ( OnlyLandscapes && ( InputArray[ InputNumber ]->GetChoiceIndex() != EHoudiniAssetInputType::LandscapeInput ) )
|
|
InputArray[ InputNumber ]->ChangeInputType( EHoudiniAssetInputType::LandscapeInput, true );
|
|
|
|
// Dont auto select asset inputs because they dont have the unreal transform, which can cause issue, prefer WorldInput instead
|
|
//if ( OnlyHoudiniAssets && ( InputArray[ InputNumber ]->GetChoiceIndex() != EHoudiniAssetInputType::AssetInput ) )
|
|
// InputArray[ InputNumber ]->ChangeInputType( EHoudiniAssetInputType::AssetInput );
|
|
}
|
|
}
|
|
|
|
// Discard the tool presets after their first setup
|
|
HoudiniToolInputPreset.Empty();
|
|
}
|
|
#endif
|
|
|
|
FPrimitiveSceneProxy*
|
|
UHoudiniAssetComponent::CreateSceneProxy()
|
|
{
|
|
/** Represents a UHoudiniAssetComponent to the scene manager. */
|
|
class FHoudiniAssetSceneProxy final : public FPrimitiveSceneProxy
|
|
{
|
|
public:
|
|
SIZE_T GetTypeHash() const override
|
|
{
|
|
static size_t UniquePointer;
|
|
return reinterpret_cast<size_t>( &UniquePointer );
|
|
}
|
|
|
|
FHoudiniAssetSceneProxy( const UHoudiniAssetComponent* InComponent )
|
|
: FPrimitiveSceneProxy( InComponent )
|
|
{
|
|
}
|
|
|
|
virtual FPrimitiveViewRelevance GetViewRelevance(const FSceneView* View) const override
|
|
{
|
|
FPrimitiveViewRelevance Result;
|
|
Result.bDrawRelevance = IsShown( View );
|
|
return Result;
|
|
}
|
|
|
|
virtual uint32 GetMemoryFootprint( void ) const override { return( sizeof( *this ) + GetAllocatedSize() ); }
|
|
uint32 GetAllocatedSize( void ) const { return( FPrimitiveSceneProxy::GetAllocatedSize() ); }
|
|
};
|
|
|
|
return new FHoudiniAssetSceneProxy( this );
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::NotifyAssetNeedsToBeReinstantiated()
|
|
{
|
|
bLoadedComponentRequiresInstantiation = true;
|
|
bLoadedComponent = true;
|
|
bFullyLoaded = false;
|
|
AssetCookCount = 0;
|
|
AssetId = -1;
|
|
|
|
// Mark all input as changed
|
|
for ( TArray< UHoudiniAssetInput * >::TIterator IterInputs( Inputs ); IterInputs; ++IterInputs )
|
|
{
|
|
UHoudiniAssetInput * HoudiniAssetInput = *IterInputs;
|
|
if ( HoudiniAssetInput && !HoudiniAssetInput->IsPendingKill() )
|
|
HoudiniAssetInput->MarkChanged( false );
|
|
}
|
|
|
|
// Upload parameters.
|
|
for (TMap< HAPI_ParmId, UHoudiniAssetParameter * >::TIterator IterParams(Parameters); IterParams; ++IterParams)
|
|
{
|
|
UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
|
|
if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
|
|
HoudiniAssetParameter->MarkChanged( false );
|
|
}
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::UpdateMobility()
|
|
{
|
|
// If we generated a landscape, force ourself to Static!
|
|
if ( LandscapeComponents.Num() > 0 )
|
|
{
|
|
SetMobility(EComponentMobility::Static);
|
|
}
|
|
else
|
|
{
|
|
// Changed GetAttachChildren to 'GetAllDescendants' due to HoudiniMeshSplitInstanceComponent
|
|
// not propagating property changes to their own child StaticMeshComponents.
|
|
TArray< USceneComponent * > LocalAttachChildren;
|
|
GetChildrenComponents(true, LocalAttachChildren);
|
|
|
|
// If one of the children we created is movable, we need to set ourselves to movable as well
|
|
for (TArray< USceneComponent * >::TConstIterator Iter(LocalAttachChildren); Iter; ++Iter)
|
|
{
|
|
USceneComponent * SceneComponent = *Iter;
|
|
if (SceneComponent->Mobility == EComponentMobility::Movable)
|
|
SetMobility(EComponentMobility::Movable);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
ELightMapInteractionType UHoudiniAssetComponent::GetStaticLightingType() const
|
|
{
|
|
// Override preventing the automatic reset to default of LightmapType in UPrimitiveComponent::PostEditChangeProperty
|
|
// see UStaticMeshComponent::GetStaticLightingType and UStaticMeshComponent::GetStaticLightingInfo
|
|
switch (LightmapType)
|
|
{
|
|
//default and ForceSurface are Texture mode.
|
|
case ELightmapType::Default:
|
|
case ELightmapType::ForceSurface:
|
|
return LMIT_Texture;
|
|
|
|
case ELightmapType::ForceVolumetric:
|
|
return LMIT_GlobalVolume;
|
|
}
|
|
|
|
return LMIT_None;
|
|
}
|
|
|
|
void
|
|
UHoudiniAssetComponent::CopyComponentPropertiesTo(UPrimitiveComponent * pPrimComp)
|
|
{
|
|
// Fixes UProperties not being propagated to newly created UStaticMeshComponents
|
|
// Copies all of the properties that would normally get propagated.
|
|
if (!pPrimComp || pPrimComp->IsPendingKill())
|
|
return;
|
|
|
|
pPrimComp->CastShadow = this->CastShadow;
|
|
pPrimComp->bCastDynamicShadow = this->bCastDynamicShadow;
|
|
pPrimComp->bCastStaticShadow = this->bCastStaticShadow;
|
|
pPrimComp->bCastVolumetricTranslucentShadow = this->bCastVolumetricTranslucentShadow;
|
|
pPrimComp->bCastInsetShadow = this->bCastInsetShadow;
|
|
pPrimComp->bCastHiddenShadow = this->bCastHiddenShadow;
|
|
pPrimComp->bCastShadowAsTwoSided = this->bCastShadowAsTwoSided;
|
|
pPrimComp->LightmapType = this->LightmapType;
|
|
pPrimComp->bLightAttachmentsAsGroup = this->bLightAttachmentsAsGroup;
|
|
pPrimComp->IndirectLightingCacheQuality = this->IndirectLightingCacheQuality;
|
|
pPrimComp->bVisibleInReflectionCaptures = this->bVisibleInReflectionCaptures;
|
|
pPrimComp->bRenderInMainPass = this->bRenderInMainPass;
|
|
//pPrimComp->bRenderInMono = this->bRenderInMono;
|
|
pPrimComp->bOwnerNoSee = this->bOwnerNoSee;
|
|
pPrimComp->bOnlyOwnerSee = this->bOnlyOwnerSee;
|
|
pPrimComp->bTreatAsBackgroundForOcclusion = this->bTreatAsBackgroundForOcclusion;
|
|
pPrimComp->bUseAsOccluder = this->bUseAsOccluder;
|
|
pPrimComp->bRenderCustomDepth = this->bRenderCustomDepth;
|
|
pPrimComp->CustomDepthStencilValue = this->CustomDepthStencilValue;
|
|
pPrimComp->CustomDepthStencilWriteMask = this->CustomDepthStencilWriteMask;
|
|
pPrimComp->TranslucencySortPriority = this->TranslucencySortPriority;
|
|
pPrimComp->LpvBiasMultiplier = this->LpvBiasMultiplier;
|
|
pPrimComp->bReceivesDecals = this->bReceivesDecals;
|
|
pPrimComp->BoundsScale = this->BoundsScale;
|
|
pPrimComp->bUseAttachParentBound = this->bUseAttachParentBound;
|
|
pPrimComp->bAlwaysCreatePhysicsState = this->bAlwaysCreatePhysicsState;
|
|
pPrimComp->bMultiBodyOverlap = this->bMultiBodyOverlap;
|
|
//pPrimComp->bCheckAsyncSceneOnMove = this->bCheckAsyncSceneOnMove;
|
|
pPrimComp->bTraceComplexOnMove = this->bTraceComplexOnMove;
|
|
pPrimComp->bReturnMaterialOnMove = this->bReturnMaterialOnMove;
|
|
pPrimComp->BodyInstance = this->BodyInstance;
|
|
pPrimComp->CanCharacterStepUpOn = this->CanCharacterStepUpOn;
|
|
pPrimComp->bIgnoreRadialImpulse = this->bIgnoreRadialImpulse;
|
|
pPrimComp->bIgnoreRadialForce = this->bIgnoreRadialForce;
|
|
pPrimComp->bApplyImpulseOnDamage = this->bApplyImpulseOnDamage;
|
|
pPrimComp->MinDrawDistance = this->MinDrawDistance;
|
|
pPrimComp->LDMaxDrawDistance = this->LDMaxDrawDistance;
|
|
pPrimComp->CachedMaxDrawDistance = this->CachedMaxDrawDistance;
|
|
pPrimComp->bAllowCullDistanceVolume = this->bAllowCullDistanceVolume;
|
|
pPrimComp->DetailMode = this->DetailMode;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE |