/*
* 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 "HoudiniAssetInput.h"

#include "HoudiniApi.h"
#include "HoudiniEngineUtils.h"
#include "HoudiniSplineComponent.h"
#include "HoudiniAssetParameter.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniAssetParameterInt.h"
#include "HoudiniAssetParameterChoice.h"
#include "HoudiniAssetParameterToggle.h"
#include "HoudiniEngine.h"
#include "HoudiniAssetActor.h"
#include "HoudiniPluginSerializationVersion.h"
#include "HoudiniEngineString.h"
#include "HoudiniLandscapeUtils.h"
#include "HoudiniEngineRuntimePrivatePCH.h"

#include "Components/SplineComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Engine/Selection.h"
#include "Internationalization/Internationalization.h"
#include "EngineUtils.h" // for TActorIterator<>

#if WITH_EDITOR
#include "Editor.h"
#include "Editor/UnrealEdEngine.h"
#include "UnrealEdGlobals.h"
#endif

#if WITH_EDITOR
// Allows checking of objects currently being dragged around
struct FHoudiniMoveTracker
{
    FHoudiniMoveTracker() : IsObjectMoving(false)
    {
        GEditor->OnBeginObjectMovement().AddLambda([this](UObject&) { IsObjectMoving = true; });
        GEditor->OnEndObjectMovement().AddLambda([this](UObject&) { IsObjectMoving = false; });
    }
    static FHoudiniMoveTracker& Get() { static FHoudiniMoveTracker Instance; return Instance; }

    bool IsObjectMoving;
};
#endif

static FName NAME_HoudiniNoUpload( TEXT( "HoudiniNoUpload" ) );


#define LOCTEXT_NAMESPACE HOUDINI_MODULE_RUNTIME

void
FHoudiniAssetInputOutlinerMesh::Serialize( FArchive & Ar )
{
    Ar.UsingCustomVersion( FHoudiniCustomSerializationVersion::GUID );

    HoudiniAssetParameterVersion = VER_HOUDINI_PLUGIN_SERIALIZATION_AUTOMATIC_VERSION;
    Ar << HoudiniAssetParameterVersion;

    Ar << ActorPtr;
    if ( ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_OUTLINER_INPUT_SAVE_ACTOR_PATHNAME )
        && ( HoudiniAssetParameterVersion != VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_419_SERIALIZATION_FIX ) )
    {
        Ar << ActorPathName;
    }

    if ( HoudiniAssetParameterVersion < VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_OUTLINER_INPUT_SAVE_ACTOR_ONLY )
    {
        Ar << StaticMeshComponent;
        Ar << StaticMesh;
    }

    Ar << ActorTransform;

    Ar << AssetId;
    if ( Ar.IsLoading() && !Ar.IsTransacting() )
        AssetId = -1;

    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_ADDED_UNREAL_SPLINE 
        && HoudiniAssetParameterVersion < VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_OUTLINER_INPUT_SAVE_ACTOR_ONLY )
    {
        Ar << SplineComponent;
        Ar << NumberOfSplineControlPoints;
        Ar << SplineLength;
        Ar << SplineResolution;
        Ar << ComponentTransform;
    }

    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_ADDED_KEEP_TRANSFORM )
        Ar << KeepWorldTransform;

    // UE4.19 SERIALIZATION FIX:
    // The component materials serialization (24) was actually missing in the UE4.19 H17.0 / H16.5 plugin.
    // However subsequent serialized changes (25+) were present in those version. This caused crashes when loading
    // a level that was saved with 4.19+16.5/17.0 on a newer version of Unreal or Houdini...
    // If the serialized version is exactly that of the fix, we can ignore the materials paths as well
    if ( ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_OUTLINER_INPUT_SAVE_MAT )
        && (HoudiniAssetParameterVersion != VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_419_SERIALIZATION_FIX ) )
        Ar << MeshComponentsMaterials;

    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_OUTLINER_INSTANCE_INDEX )
        Ar << InstanceIndex;
}

void 
FHoudiniAssetInputOutlinerMesh::RebuildSplineTransformsArrayIfNeeded()
{
    // Rebuilding the SplineTransform array after reloading the asset
    // This is required to properly detect Transform changes after loading the asset.

    // We need an Unreal spline
    if ( !SplineComponent || SplineComponent->IsPendingKill() )
        return;

    // If those are different, the input component has changed
    if ( NumberOfSplineControlPoints != SplineComponent->GetNumberOfSplinePoints() )
        return;

    // If those are equals, there's no need to rebuild the array
    if ( SplineControlPointsTransform.Num() == SplineComponent->GetNumberOfSplinePoints() )
        return;

    SplineControlPointsTransform.SetNumUninitialized(SplineComponent->GetNumberOfSplinePoints());
    for ( int32 n = 0; n < SplineControlPointsTransform.Num(); n++ )
        SplineControlPointsTransform[n] = SplineComponent->GetTransformAtSplinePoint( n, ESplineCoordinateSpace::Local, true );
}

bool
FHoudiniAssetInputOutlinerMesh::HasSplineComponentChanged(float fCurrentSplineResolution) const
{
    if ( !SplineComponent || SplineComponent->IsPendingKill() )
        return false;

    // Total length of the spline has changed ?
    if ( SplineComponent->GetSplineLength() != SplineLength )
        return true;

    // Number of CVs has changed ?
    if ( NumberOfSplineControlPoints != SplineComponent->GetNumberOfSplinePoints() )
        return true;

    if ( SplineControlPointsTransform.Num() != SplineComponent->GetNumberOfSplinePoints() )
        return true;

    // Current Spline resolution has changed?
    if ( fCurrentSplineResolution == -1.0 && SplineResolution != -1.0)
    {
        const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
        if ( HoudiniRuntimeSettings )
            fCurrentSplineResolution = HoudiniRuntimeSettings->MarshallingSplineResolution;
        else
            fCurrentSplineResolution = HAPI_UNREAL_PARAM_SPLINE_RESOLUTION_DEFAULT;
    }

    if ( SplineResolution != fCurrentSplineResolution )
        return true;

    // Has any of the CV's transform been modified?
    for ( int32 n = 0; n < SplineControlPointsTransform.Num(); n++ )
    {
        if ( !SplineControlPointsTransform[ n ].GetLocation().Equals( SplineComponent->GetLocationAtSplinePoint( n, ESplineCoordinateSpace::Local) ) )
            return true;

        if ( !SplineControlPointsTransform[ n ].GetRotation().Equals( SplineComponent->GetQuaternionAtSplinePoint( n, ESplineCoordinateSpace::World ) ) )
            return true;

        if ( !SplineControlPointsTransform[ n ].GetScale3D().Equals( SplineComponent->GetScaleAtSplinePoint( n ) ) )
            return true;
    }

    return false;
}


bool 
FHoudiniAssetInputOutlinerMesh::HasActorTransformChanged() const
{
    if ( !ActorPtr.IsValid() )
        return false;

    if ( !ActorTransform.Equals( ActorPtr->GetTransform() ) )
        return true;

    return false;
}


bool
FHoudiniAssetInputOutlinerMesh::HasComponentTransformChanged() const
{
    if ( StaticMeshComponent && !StaticMeshComponent->IsPendingKill() )
    {
        // Handle instances here
        UInstancedStaticMeshComponent * InstancedStaticMeshComponent = Cast< UInstancedStaticMeshComponent >( StaticMeshComponent );
        if (InstancedStaticMeshComponent )
        {
            FTransform InstanceTransform;
            if ( InstancedStaticMeshComponent->GetInstanceTransform( InstanceIndex, InstanceTransform, true ) )
                return !ComponentTransform.Equals( InstanceTransform );
        }
        else
            return !ComponentTransform.Equals( StaticMeshComponent->GetComponentTransform() );
    }

    if ( SplineComponent && !SplineComponent->IsPendingKill() )
        return !ComponentTransform.Equals( SplineComponent->GetComponentTransform() );

    return false;
}

bool
FHoudiniAssetInputOutlinerMesh::HasComponentMaterialsChanged() const
{
    if ( !StaticMeshComponent || StaticMeshComponent->IsPendingKill() )
        return false;

    if ( StaticMeshComponent->GetNumMaterials() != MeshComponentsMaterials.Num() )
        return true;

    for ( int32 n = 0; n < MeshComponentsMaterials.Num(); n++ )
    {
        UMaterialInterface* MI = StaticMeshComponent->GetMaterial(n);
        FString mat_interface_path = MI->GetPathName();
        if (!MI || MI->IsPendingKill())
            mat_interface_path = FString();

        if (mat_interface_path != MeshComponentsMaterials[ n ])
            return true;
    }

    return false;
}

bool
FHoudiniAssetInputOutlinerMesh::NeedsComponentUpdate() const 
{
    if ( !ActorPtr.IsValid() || ActorPtr->IsPendingKill() )
        return false;

    if ( StaticMesh && ( !StaticMesh->IsValidLowLevel() || StaticMesh->IsPendingKill() ) )
        return true;

    if ( StaticMeshComponent && ( !StaticMeshComponent->IsValidLowLevel() || StaticMeshComponent->IsPendingKill() ) )
        return true;

    if ( SplineComponent && ( !SplineComponent->IsValidLowLevel() || SplineComponent->IsPendingKill() ) )
        return true;

    if ( !StaticMesh && !StaticMeshComponent && !SplineComponent )
        return true;

    return false;
}


bool
FHoudiniAssetInputOutlinerMesh::TryToUpdateActorPtrFromActorPathName()
{
    // Ensure our current ActorPathName looks valid
    if (ActorPathName.IsEmpty() || ActorPathName.Equals(TEXT("None"), ESearchCase::IgnoreCase))
        return false;

    // We'll try to find the corresponding actor by browsing through all the actors in the world..
    // Get the editor world
    UWorld* World = nullptr;
#if WITH_EDITOR
    World = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
#endif
    if (!World)
        return false;

    // Then try to find the actor corresponding to our path/name
    bool FoundActor = false;
    for (TActorIterator<AActor> ActorIt(World); ActorIt; ++ActorIt)
    {
        if (ActorIt->GetPathName() != ActorPathName)
            continue;

        // We found the actor
        ActorPtr = *ActorIt;
        FoundActor = true;

        break;
    }

    if ( FoundActor )
    {
        // We need to invalid our components so they can be updated later
        // from the new actor
        StaticMesh = NULL;
        StaticMeshComponent = NULL;
        SplineComponent = NULL;
    }

    return FoundActor;
}

UHoudiniAssetInput::UHoudiniAssetInput( const FObjectInitializer & ObjectInitializer )
    : Super( ObjectInitializer )
    , InputCurve( nullptr )
    , InputAssetComponent( nullptr )
    , InputLandscapeProxy( nullptr )
    , ConnectedAssetId( -1 )
    , InputIndex( 0 )
    , ChoiceIndex( EHoudiniAssetInputType::GeometryInput )
    , UnrealSplineResolution( -1.0f )
    , OutlinerInputsNeedPostLoadInit( false )
    , HoudiniAssetInputFlagsPacked( 0u )
{
    // flags
    bLandscapeExportMaterials = true;
    bKeepWorldTransform = 2;
    bLandscapeExportAsHeightfield = true;
    bLandscapeAutoSelectComponent = true;
    bPackBeforeMerge = false;
    bExportAllLODs = false;
    bExportSockets = false;
    bUpdateInputLandscape = false;

    ChoiceStringValue = TEXT( "" );

    // Initialize the arrays
    InputObjects.SetNumUninitialized( 1 );
    InputObjects[ 0 ] = nullptr;
    InputTransforms.SetNumUninitialized( 1 );
    InputTransforms[ 0 ] = FTransform::Identity;
    TransformUIExpanded.SetNumUninitialized( 1 );
    TransformUIExpanded[ 0 ] = false;
    SkeletonInputObjects.SetNumUninitialized(1);
    SkeletonInputObjects[0] = nullptr;
    InputLandscapeTransform = FTransform::Identity;
}

UHoudiniAssetInput *
UHoudiniAssetInput::Create( UObject * InPrimaryObject, int32 InInputIndex, HAPI_NodeId InNodeId )
{
    UHoudiniAssetInput * HoudiniAssetInput = nullptr;

    if (!InPrimaryObject || InPrimaryObject->IsPendingKill())
        return HoudiniAssetInput;

    // Get name of this input.
    HAPI_StringHandle InputStringHandle;
    if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetNodeInputName(
            FHoudiniEngine::Get().GetSession(),
            InNodeId, InInputIndex, &InputStringHandle ) )
    {
        return HoudiniAssetInput;
    }

    HoudiniAssetInput = NewObject< UHoudiniAssetInput >(
        InPrimaryObject,
        UHoudiniAssetInput::StaticClass(),
        NAME_None, RF_Public | RF_Transactional );

    // Set component and other information.
    HoudiniAssetInput->PrimaryObject = InPrimaryObject;
    HoudiniAssetInput->InputIndex = InInputIndex;

    // Get input string from handle.
    HoudiniAssetInput->SetNameAndLabel( InputStringHandle );

    HoudiniAssetInput->SetNodeId( InNodeId );

    // Set the default input type from the input's label
    HoudiniAssetInput->SetDefaultInputTypeFromLabel();

    // Create necessary widget resources.
    HoudiniAssetInput->CreateWidgetResources();

    return HoudiniAssetInput;
}

UHoudiniAssetInput *
UHoudiniAssetInput::Create(
    UObject * InPrimaryObject,
    UHoudiniAssetParameter * InParentParameter,
    HAPI_NodeId InNodeId, 
    const HAPI_ParmInfo & ParmInfo)
{
    UObject * Outer = InPrimaryObject;
    if (!Outer)
    {
        Outer = InParentParameter;
        if (!Outer)
        {
            // Must have either component or parent not null.
            check(false);
        }
    }

    UHoudiniAssetInput * HoudiniAssetInput = NewObject< UHoudiniAssetInput >(
        Outer, UHoudiniAssetInput::StaticClass(), NAME_None, RF_Public | RF_Transactional);

    // This is being used as a parameter
    HoudiniAssetInput->bIsObjectPathParameter = true;

    HoudiniAssetInput->CreateParameter(InPrimaryObject, InParentParameter, InNodeId, ParmInfo);

    HoudiniAssetInput->SetNodeId( InNodeId );

    // Set the default input type from the input's label
    HoudiniAssetInput->SetDefaultInputTypeFromLabel();

    // Create necessary widget resources.
    HoudiniAssetInput->CreateWidgetResources();

    // Use the value of the object path param to preset the 
    // default object for Geometry inputs 
    HoudiniAssetInput->SetDefaultAssetFromHDA();

    return HoudiniAssetInput;
}

void
UHoudiniAssetInput::CreateWidgetResources()
{
    ChoiceStringValue = TEXT( "" );
    StringChoiceLabels.Empty();

    {
        FString * ChoiceLabel = new FString( TEXT( "Geometry Input" ) );
        StringChoiceLabels.Add( TSharedPtr< FString >( ChoiceLabel ) );

        if ( ChoiceIndex == EHoudiniAssetInputType::GeometryInput )
            ChoiceStringValue = *ChoiceLabel;
    }
    {
        FString * ChoiceLabel = new FString( TEXT( "Asset Input" ) );
        StringChoiceLabels.Add( TSharedPtr< FString >( ChoiceLabel ) );

        if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
            ChoiceStringValue = *ChoiceLabel;
    }
    {
        FString * ChoiceLabel = new FString( TEXT( "Curve Input" ) );
        StringChoiceLabels.Add( TSharedPtr< FString >( ChoiceLabel ) );

        if ( ChoiceIndex == EHoudiniAssetInputType::CurveInput )
            ChoiceStringValue = *ChoiceLabel;
    }
    {
        FString * ChoiceLabel = new FString( TEXT( "Landscape Input" ) );
        StringChoiceLabels.Add( TSharedPtr< FString >( ChoiceLabel ) );

        if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
            ChoiceStringValue = *ChoiceLabel;
    }
    {
        FString * ChoiceLabel = new FString( TEXT( "World Outliner Input" ) );
        StringChoiceLabels.Add( TSharedPtr< FString >( ChoiceLabel ) );

        if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
            ChoiceStringValue = *ChoiceLabel;
    }
    {
        FString * ChoiceLabel = new FString(TEXT("Skeletal Mesh Input"));
        StringChoiceLabels.Add(TSharedPtr< FString >(ChoiceLabel));

        if (ChoiceIndex == EHoudiniAssetInputType::SkeletonInput)
            ChoiceStringValue = *ChoiceLabel;
    }
}

void
UHoudiniAssetInput::DisconnectAndDestroyInputAsset()
{
    if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
    {
        if( bIsObjectPathParameter )
        {
            FHoudiniApi::SetParmStringValue(
                FHoudiniEngine::Get().GetSession(), NodeId, "",
                ParmId, 0 );
        }
        if ( InputAssetComponent )
            InputAssetComponent->RemoveDownstreamAsset( GetHoudiniAssetComponent(), InputIndex );

        bInputAssetConnectedInHoudini = false;
        ConnectedAssetId = -1;
    }
    else
    {
        if ( bIsObjectPathParameter )
        {
            FHoudiniApi::SetParmStringValue(
                FHoudiniEngine::Get().GetSession(), NodeId, "", ParmId, 0 );
        }
        else
        {
            HAPI_NodeId HostAssetId = GetAssetId();
            if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) && FHoudiniEngineUtils::IsValidNodeId( HostAssetId ) )
                FHoudiniEngineUtils::HapiDisconnectAsset( HostAssetId, InputIndex );
        }

        // Destroy all the geo input assets
        for ( HAPI_NodeId AssetNodeId : CreatedInputDataAssetIds )
        {
            if ( FHoudiniEngineUtils::IsHoudiniNodeValid( AssetNodeId ) )
                FHoudiniEngineUtils::DestroyHoudiniAsset( AssetNodeId );
        }
        CreatedInputDataAssetIds.Empty();

        // Then simply destroy the input's parent OBJ node
        if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) )
        {
            HAPI_NodeId ParentId = FHoudiniEngineUtils::HapiGetParentNodeId( ConnectedAssetId );
            if ( FHoudiniEngineUtils::IsHoudiniNodeValid( ParentId ) )
                FHoudiniEngineUtils::DestroyHoudiniAsset( ParentId );

                FHoudiniEngineUtils::DestroyHoudiniAsset( ConnectedAssetId );
        }
        ConnectedAssetId = -1;
        if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
        {
            // World Input Actors' Meshes need to have their corresponding Input Assets destroyed too.
            for ( int32 n = 0; n < InputOutlinerMeshArray.Num(); n++ )
            {
                InputOutlinerMeshArray[ n ].AssetId = -1;
            }
        }

        /*
        if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
        {
            // World Input Actors' Meshes need to have their corresponding Input Assets destroyed too.
            for ( int32 n = 0; n < InputOutlinerMeshArray.Num(); n++ )
            {
                if ( FHoudiniEngineUtils::IsValidAssetId( InputOutlinerMeshArray[n].AssetId ) )
                {
                    FHoudiniEngineUtils::HapiDisconnectAsset( ConnectedAssetId, n );//InputOutlinerMeshArray[n].AssetId);
                    FHoudiniEngineUtils::DestroyHoudiniAsset( InputOutlinerMeshArray[n].AssetId );
                    InputOutlinerMeshArray[n].AssetId = -1;
                }
            }
        }
        else if ( ChoiceIndex == EHoudiniAssetInputType::GeometryInput )
        {
            // Destroy all the geo input assets
            for ( HAPI_NodeId AssetNodeId : CreatedInputDataAssetIds )
            {
                FHoudiniEngineUtils::DestroyHoudiniAsset( AssetNodeId );
            }
            CreatedInputDataAssetIds.Empty();
        }
        else if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
        {
            // Destroy the landscape node
            // If the landscape was sent as a heightfield, also destroy the heightfield's input node
            FHoudiniLandscapeUtils::DestroyLandscapeAssetNode( ConnectedAssetId, CreatedInputDataAssetIds );
        }
        else if ( ChoiceIndex == EHoudiniAssetInputType::SkeletonInput )
        {
            // Destroy all the skeleton input assets
            for ( HAPI_NodeId AssetNodeId : CreatedInputDataAssetIds )
            {
                FHoudiniEngineUtils::DestroyHoudiniAsset( AssetNodeId );
            }
            CreatedInputDataAssetIds.Empty();
        }

        if ( FHoudiniEngineUtils::IsValidAssetId( ConnectedAssetId ) )
        {
            FHoudiniEngineUtils::DestroyHoudiniAsset( ConnectedAssetId );
            ConnectedAssetId = -1;
        }
        */
    }
}

bool
UHoudiniAssetInput::CreateParameter(
    UObject * InPrimaryObject,
    UHoudiniAssetParameter * InParentParameter,
    HAPI_NodeId InNodeId, const HAPI_ParmInfo & ParmInfo)
{
    // Inputs should never call this
    check(bIsObjectPathParameter);

    if (!Super::CreateParameter(InPrimaryObject, InParentParameter, InNodeId, ParmInfo))
        return false;

    // We can only handle node type.
    if (ParmInfo.type != HAPI_PARMTYPE_NODE)
        return false;

    return true;
}

#if WITH_EDITOR

void
UHoudiniAssetInput::PostEditUndo()
{
    Super::PostEditUndo();

    if ( InputCurve
        && !InputCurve->IsPendingKill()
        && ChoiceIndex == EHoudiniAssetInputType::CurveInput )
    {
        USceneComponent* RootComp = GetHoudiniAssetComponent();
        if ( RootComp && !RootComp->IsPendingKill() )
        {
            AActor* Owner = RootComp->GetOwner();
            if ( Owner && !Owner->IsPendingKill() )
                Owner->AddOwnedComponent( InputCurve );

            InputCurve->AttachToComponent( RootComp, FAttachmentTransformRules::KeepRelativeTransform );
            InputCurve->RegisterComponent();
            InputCurve->SetVisibility( true );
        }
    }
}

void
UHoudiniAssetInput::ForceSetInputObject(UObject * InObject, int32 AtIndex, bool CommitChange)
{
    EHoudiniAssetInputType::Enum NewInputType = EHoudiniAssetInputType::GeometryInput;
    if ( AActor* Actor = Cast<AActor>( InObject ) )
    {
        // Update the OutlinerInputArray from the actor
        UpdateInputOulinerArrayFromActor(Actor, true);
        if ( InputOutlinerMeshArray.Num() > 0 )
            NewInputType = EHoudiniAssetInputType::WorldInput;

        // Looking for houdini assets
        if ( AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( Actor ) )
        {
            OnInputActorSelected( Actor );
            if ( InputAssetComponent )
                NewInputType = EHoudiniAssetInputType::AssetInput;

        }

        // Looking for Landscapes
        if (ALandscapeProxy * Landscape = Cast< ALandscapeProxy >( Actor ) )
        {
            // Store new landscape.
            OnLandscapeActorSelected( Actor );
            NewInputType = EHoudiniAssetInputType::LandscapeInput;
        }
    }
    else
    {
        // The object is not a world actor, so add it to the geo input
        if( InputObjects.IsValidIndex( AtIndex ) )
        {
            InputObjects[ AtIndex ] = InObject;
        }
        else
        {
            InputObjects.Insert( InObject, AtIndex );
        }

        if ( !InputTransforms.IsValidIndex( AtIndex ) )
        {
            InputTransforms.Insert( FTransform::Identity, AtIndex );
        }

        if ( !TransformUIExpanded.IsValidIndex( AtIndex ) )
        {
            TransformUIExpanded.Insert( false, AtIndex );
        }
    }

    if( CommitChange )
    {
        // We must change ChoiceIndex's value manually before calling ChangeInputType: 
        // If we are forcing the input to an asset input, not doing so would actually destroy the 
        // parent HDA node on the houdini side, making the input HDA to need a reinstantiation on first cook...
        ChoiceIndex = NewInputType;

        ChangeInputType( NewInputType, true );
        MarkChanged();
    }
}

// Note: This method is only used for testing
void 
UHoudiniAssetInput::ClearInputs()
{
    ChangeInputType( EHoudiniAssetInputType::GeometryInput, true );
    InputOutlinerMeshArray.Empty();
    InputObjects.Empty();
    InputTransforms.Empty();
    TransformUIExpanded.Empty();
    MarkChanged();
}

#endif  // WITH_EDITOR

bool
UHoudiniAssetInput::ConnectInputNode()
{
    if (!FHoudiniEngineUtils::IsValidNodeId(ConnectedAssetId))
        return false;

    // Helper for connecting our input or setting the object path parameter
    if (!bIsObjectPathParameter)
    {
        // Now we can connect input node to the asset node.
        HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::ConnectNodeInput(
            FHoudiniEngine::Get().GetSession(), GetAssetId(), InputIndex,
            ConnectedAssetId, 0), false);
    }
    else
    {
        if (!FHoudiniEngineUtils::IsValidNodeId(NodeId))
            return false;

        // Now we can assign the input node path to the parameter
        std::string ParamNameString = TCHAR_TO_UTF8(*GetParameterName());
        HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetParmNodeValue(
            FHoudiniEngine::Get().GetSession(), NodeId,
            ParamNameString.c_str(), ConnectedAssetId), false);
    }
    return true;
}

bool
UHoudiniAssetInput::UploadParameterValue()
{
    bool Success = true;

    if ( !PrimaryObject || PrimaryObject->IsPendingKill() )
        return false;
    
    HAPI_NodeId HostAssetId = GetAssetId();

    switch ( ChoiceIndex )
    {
        case EHoudiniAssetInputType::GeometryInput:
        {
            if ( !InputObjects.Num() )
            {
                // Either mesh was reset or null mesh has been assigned.
                DisconnectAndDestroyInputAsset();
            }
            else
            {
                if ( bStaticMeshChanged || bLoadedParameter )
                {
                    // Disconnect and destroy currently connected asset, if there's one.
                    DisconnectAndDestroyInputAsset();

                    // Connect input and create connected asset. Will return by reference.
                    if ( !FHoudiniEngineUtils::HapiCreateInputNodeForObjects( 
                        HostAssetId, InputObjects, InputTransforms,
                        ConnectedAssetId, CreatedInputDataAssetIds,
                        false, bExportAllLODs, bExportSockets ) )
                    {
                        bChanged = false;
                        ConnectedAssetId = -1;
                        return false;
                    }
                    else
                    {
                        Success &= ConnectInputNode();
                    }

                    bStaticMeshChanged = false;
                }

                Success &= UpdateObjectMergeTransformType();
                Success &= UpdateObjectMergePackBeforeMerge();
            }
            break;
        }
    
        case EHoudiniAssetInputType::AssetInput:
        {
            // Process connected asset.
            if ( InputAssetComponent
                && !InputAssetComponent->IsPendingKill()
                && FHoudiniEngineUtils::IsValidNodeId( InputAssetComponent->GetAssetId() ) )
            {
                // Connect a new asset / we have previously connected asset 
                if (!bInputAssetConnectedInHoudini)
                    ConnectInputAssetActor();
                else
                    bChanged = false;

                Success &= bInputAssetConnectedInHoudini;
                Success &= UpdateObjectMergeTransformType();
            }
            else if ( bInputAssetConnectedInHoudini && ( !InputAssetComponent || InputAssetComponent->IsPendingKill() ) )
            {
                // Previously connected asset deleted/invalid
                DisconnectInputAssetActor();
            }
            else
            {
                // Nothing to connect
                bChanged = false;
                if ( InputAssetComponent )
                    return false;
            }
            break;
        }

        case EHoudiniAssetInputType::CurveInput:
        {
            // If we have no curve node, create it.
            bool bCreated = false;
            if ( !FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) )
            {
                if ( !FHoudiniEngineUtils::HapiCreateCurveNode( ConnectedAssetId ) )
                {
                    bChanged = false;
                    ConnectedAssetId = -1;
                    return false;
                }

                // Connect the node to the asset.
                Success &= ConnectInputNode();

                bCreated = true;
            }

            if ( bLoadedParameter || bCreated )
            {
                // If we just loaded or created our curve, we need to set parameters.
                for (TMap< FString, UHoudiniAssetParameter * >::TIterator
                    IterParams(InputCurveParameters); IterParams; ++IterParams)
                {
                    UHoudiniAssetParameter * Parameter = IterParams.Value();
                    if ( !Parameter || Parameter->IsPendingKill() )
                        continue;

                    // We need to update the node id for the parameters.
                    Parameter->SetNodeId(ConnectedAssetId);

                    // Upload parameter value.
                    Success &= Parameter->UploadParameterValue();
                }
            }

            if ( ConnectedAssetId != -1 && InputCurve && !InputCurve->IsPendingKill() )
            {
                // The curve node has now been created and set up, we can upload points and rotation/scale attributes
                const TArray< FTransform > & CurvePoints = InputCurve->GetCurvePoints();
                TArray<FVector> Positions;
                InputCurve->GetCurvePositions(Positions);

                TArray<FQuat> Rotations;
                InputCurve->GetCurveRotations(Rotations);

                TArray<FVector> Scales;
                InputCurve->GetCurveScales(Scales);

                if(!FHoudiniEngineUtils::HapiCreateCurveInputNodeForData(
                        HostAssetId,
                        ConnectedAssetId,
                        &Positions,
                        &Rotations,
                        &Scales,
                        nullptr))
                {
                    bChanged = false;
                    ConnectedAssetId = -1;
                    return false;
                }
            }
            
            if (bCreated && InputCurve && !InputCurve->IsPendingKill() )
            {
                // We need to check that the SplineComponent has no offset.
                // if the input was set to WorldOutliner before, it might have one
                FTransform CurveTransform = InputCurve->GetRelativeTransform();
                if (!CurveTransform.GetLocation().IsZero())
                    InputCurve->SetRelativeLocation(FVector::ZeroVector);
            }

            Success &= UpdateObjectMergeTransformType();

            // Cook the spline node.
            if( HAPI_RESULT_SUCCESS != FHoudiniApi::CookNode( FHoudiniEngine::Get().GetSession(), ConnectedAssetId, nullptr ) )
                Success = false;

            // We need to update the curve.
            Success &= UpdateInputCurve();

            bSwitchedToCurve = false;

            break;
        }

        case EHoudiniAssetInputType::LandscapeInput:
        {
            if ( !InputLandscapeProxy || InputLandscapeProxy->IsPendingKill() )
            {
                // Either landscape was reset or null landscape has been assigned.
                DisconnectAndDestroyInputAsset();
            }
            else
            {
                // Disconnect and destroy currently connected asset, if there's one.
                DisconnectAndDestroyInputAsset();

                // If we're auto-selecting the components, we need to get the asset's bound 
                FBox Bounds(ForceInitToZero);
                if ( bLandscapeAutoSelectComponent )
                {
                    // Get our asset's or our connected input asset's bounds
                    UHoudiniAssetComponent* AssetComponent = (UHoudiniAssetComponent*)PrimaryObject;
                    if (!AssetComponent || AssetComponent->IsPendingKill())
                        AssetComponent = InputAssetComponent;

                    // Get the bounds, without this input
                    if (AssetComponent && !AssetComponent->IsPendingKill())
                        Bounds = AssetComponent->GetAssetBounds(this, true);
                }

                // Connect input and create connected asset. Will return by reference.
                if ( !FHoudiniEngineUtils::HapiCreateInputNodeForLandscape(
                        HostAssetId, InputLandscapeProxy.Get(),
                        ConnectedAssetId, CreatedInputDataAssetIds,
                        bLandscapeExportSelectionOnly, bLandscapeExportCurves,
                        bLandscapeExportMaterials, bLandscapeExportAsMesh, bLandscapeExportLighting,
                        bLandscapeExportNormalizedUVs, bLandscapeExportTileUVs, Bounds,
                        bLandscapeExportAsHeightfield, bLandscapeAutoSelectComponent ) )
                {
                    bChanged = false;
                    ConnectedAssetId = -1;
                    return false;
                }

                // Connect the inputs and update the transform type
                Success &= ConnectInputNode();
                Success &= UpdateObjectMergeTransformType();
            }
            break;
        }

        case EHoudiniAssetInputType::WorldInput:
        {
            if ( InputOutlinerMeshArray.Num() <= 0 )
            {
                // Either mesh was reset or null mesh has been assigned.
                DisconnectAndDestroyInputAsset();
            }
            else
            {
                if ( bStaticMeshChanged || bLoadedParameter )
                {
                    // Disconnect and destroy currently connected asset, if there's one.
                    DisconnectAndDestroyInputAsset();

                    // Connect input and create connected asset. Will return by reference.
                    if ( !FHoudiniEngineUtils::HapiCreateInputNodeForWorldOutliner(
                        HostAssetId, InputOutlinerMeshArray, ConnectedAssetId, CreatedInputDataAssetIds,
                        UnrealSplineResolution, bExportAllLODs, bExportSockets ) )
                    {
                        bChanged = false;
                        ConnectedAssetId = -1;
                        return false;
                    }
                    else
                    {
                        Success &= ConnectInputNode();
                    }

                    bStaticMeshChanged = false;

                    Success &= UpdateObjectMergeTransformType();
                }

                Success &= UpdateObjectMergePackBeforeMerge();
            }
            break;
        }

        case EHoudiniAssetInputType::SkeletonInput:
        {
            if (!SkeletonInputObjects.Num())
            {
                // Either mesh was reset or null mesh has been assigned.
                DisconnectAndDestroyInputAsset();
            }
            else
            {
                if (bStaticMeshChanged || bLoadedParameter)
                {
                    // Disconnect and destroy currently connected asset, if there's one.
                    DisconnectAndDestroyInputAsset();

                    // Connect input and create connected asset. Will return by reference.
                    if ( !FHoudiniEngineUtils::HapiCreateInputNodeForObjects(
                        HostAssetId, SkeletonInputObjects, InputTransforms,
                        ConnectedAssetId, CreatedInputDataAssetIds, true ) )
                    {
                        bChanged = false;
                        ConnectedAssetId = -1;
                        return false;
                    }
                    else
                    {
                        Success &= ConnectInputNode();
                    }

                    bStaticMeshChanged = false;
                }

                Success &= UpdateObjectMergeTransformType();
                Success &= UpdateObjectMergePackBeforeMerge();
            }
            break;
        }

        default:
        {
            check( 0 );
        }
    }

    bLoadedParameter = false;
    return Success & Super::UploadParameterValue();
}


uint32
UHoudiniAssetInput::GetDefaultTranformTypeValue() const
{
    switch (ChoiceIndex)
    {
    // NONE
    case EHoudiniAssetInputType::CurveInput:
    case EHoudiniAssetInputType::GeometryInput:
        return 0;
    
    // INTO THIS OBJECT
    case EHoudiniAssetInputType::AssetInput:
    case EHoudiniAssetInputType::LandscapeInput:
    case EHoudiniAssetInputType::WorldInput:
        return 1;
    }

    return 0;
}


UObject* 
UHoudiniAssetInput::GetInputObject( int32 AtIndex ) const
{
    return InputObjects.IsValidIndex( AtIndex ) ? InputObjects[ AtIndex ] : nullptr;
}

FTransform
UHoudiniAssetInput::GetInputTransform( int32 AtIndex ) const
{
    return InputTransforms.IsValidIndex( AtIndex ) ? InputTransforms[ AtIndex ] : FTransform::Identity;
}

UObject*
UHoudiniAssetInput::GetSkeletonInputObject( int32 AtIndex ) const
{
    return SkeletonInputObjects.IsValidIndex( AtIndex ) ? SkeletonInputObjects[ AtIndex ] : nullptr;
}

UHoudiniAssetComponent* 
UHoudiniAssetInput::GetHoudiniAssetComponent()
{
    return Cast<UHoudiniAssetComponent>( PrimaryObject );
}

const UHoudiniAssetComponent*
UHoudiniAssetInput::GetHoudiniAssetComponent() const
{
    return Cast<const UHoudiniAssetComponent>( PrimaryObject );
}

HAPI_NodeId 
UHoudiniAssetInput::GetAssetId() const
{
    return NodeId;
}

bool
UHoudiniAssetInput::UpdateObjectMergeTransformType()
{
    if ( !PrimaryObject || PrimaryObject->IsPendingKill() )
        return false;

    uint32 nTransformType = -1;
    if ( bKeepWorldTransform == 2 )
        nTransformType = GetDefaultTranformTypeValue();
    else if ( bKeepWorldTransform )
        nTransformType = 1; 
    else
        nTransformType = 0;

    // Geometry inputs are always set to none
    if ( ChoiceIndex == EHoudiniAssetInputType::GeometryInput )
        nTransformType = 0;

    // Get the Input node ID from the host ID
    HAPI_NodeId InputNodeId = -1;
    HAPI_NodeId HostAssetId = GetAssetId();

    bool bSuccess = false;
    const std::string sXformType = "xformtype";

    if ( bIsObjectPathParameter )
    {
        // Directly change the Parameter xformtype
        if ( HAPI_RESULT_SUCCESS == FHoudiniApi::SetParmIntValue(
            FHoudiniEngine::Get().GetSession(),
            NodeId, sXformType.c_str(), 0, nTransformType ) )
            bSuccess = true;
    }
    else
    {
        // Query the object merge's node ID via the input
        if ( HAPI_RESULT_SUCCESS == FHoudiniApi::QueryNodeInput(
            FHoudiniEngine::Get().GetSession(),
            HostAssetId, InputIndex, &InputNodeId ) )
        {
            // Change Parameter xformtype
            if ( HAPI_RESULT_SUCCESS == FHoudiniApi::SetParmIntValue(
                FHoudiniEngine::Get().GetSession(), 
                InputNodeId, sXformType.c_str(), 0, nTransformType ) )
                bSuccess = true;
        }
    }

    if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
    {
        // For World Inputs, we need to go through each asset selected
        // and change the transform type on the merge node's input
        for ( int32 n = 0; n < InputOutlinerMeshArray.Num(); n++ )
        {
            // Get the Input node ID from the host ID
            InputNodeId = -1;
            if ( HAPI_RESULT_SUCCESS != FHoudiniApi::QueryNodeInput(
                FHoudiniEngine::Get().GetSession(),
                ConnectedAssetId, n, &InputNodeId ) )
                continue;

            if ( InputNodeId == -1 )
                continue;

            // Change Parameter xformtype
            if ( HAPI_RESULT_SUCCESS != FHoudiniApi::SetParmIntValue(
                FHoudiniEngine::Get().GetSession(), InputNodeId,
                sXformType.c_str(), 0, nTransformType ) )
                bSuccess = false;
        }
    }

    return bSuccess;
}


bool
UHoudiniAssetInput::UpdateObjectMergePackBeforeMerge()
{
    if ( !PrimaryObject || PrimaryObject->IsPendingKill() )
        return false;

    uint32 nPackValue = bPackBeforeMerge ? 1 : 0;

    // Get the Input node ID from the host ID
    HAPI_NodeId InputNodeId = -1;
    HAPI_NodeId HostAssetId = GetAssetId();

    bool bSuccess = true;
    const std::string sPack = "pack";

    // Going through each input asset plugged in the geometry input,
    // or through each input asset select in a world input.    
    int32 NumberOfInputObjects = 0;
    if (ChoiceIndex == EHoudiniAssetInputType::GeometryInput)
        NumberOfInputObjects = InputObjects.Num();
    else if (ChoiceIndex == EHoudiniAssetInputType::WorldInput)
        NumberOfInputObjects = InputOutlinerMeshArray.Num();

	if (bIsObjectPathParameter)
	{
		// Directly change the Parameter xformtype
		if (HAPI_RESULT_SUCCESS == FHoudiniApi::SetParmIntValue(
			FHoudiniEngine::Get().GetSession(),
			NodeId, sPack.c_str(), 0, nPackValue))
			bSuccess = true;
	}
	else
	{
		// Query the object merge's node ID via the input
		if (HAPI_RESULT_SUCCESS == FHoudiniApi::QueryNodeInput(
			FHoudiniEngine::Get().GetSession(),
			HostAssetId, InputIndex, &InputNodeId))
		{
			// Change Parameter xformtype
			if (HAPI_RESULT_SUCCESS == FHoudiniApi::SetParmIntValue(
				FHoudiniEngine::Get().GetSession(),
				InputNodeId, sPack.c_str(), 0, nPackValue))
				bSuccess = true;
		}
	}

    // We also need to modify the transform types of the merge node's inputs
    for ( int n = 0; n < NumberOfInputObjects; n++ )
    {
        // Get the Input node ID from the host ID
        InputNodeId = -1;
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::QueryNodeInput(
            FHoudiniEngine::Get().GetSession(),
            ConnectedAssetId, n, &InputNodeId ) )
            continue;

        if ( InputNodeId == -1 )
            continue;

        // Change Parameter xformtype
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::SetParmIntValue(
            FHoudiniEngine::Get().GetSession(), InputNodeId,
            sPack.c_str(), 0, nPackValue ) )
            bSuccess = false;
    }

    return bSuccess;
}

void
UHoudiniAssetInput::BeginDestroy()
{
    Super::BeginDestroy();

    // Destroy anything curve related.
    DestroyInputCurve();

    // Disconnect and destroy the asset we may have connected.
    DisconnectAndDestroyInputAsset();
}

void
UHoudiniAssetInput::PostLoad()
{
    Super::PostLoad();

    // Generate widget related resources.
    CreateWidgetResources();

    // Patch input curve parameter links.
    for ( TMap< FString, UHoudiniAssetParameter * >::TIterator IterParams( InputCurveParameters ); IterParams; ++IterParams )
    {
        FString ParameterKey = IterParams.Key();
        UHoudiniAssetParameter * Parameter = IterParams.Value();

        if ( Parameter )
        {
            Parameter->SetHoudiniAssetComponent( nullptr );
            Parameter->SetParentParameter( this );
        }
    }
  
    if ( InputCurve && !InputCurve->IsPendingKill() )
    {
        if (ChoiceIndex == EHoudiniAssetInputType::CurveInput)
        {
            // Set input callback object for this curve.
            InputCurve->SetHoudiniAssetInput(this);
            USceneComponent* RootComp = GetHoudiniAssetComponent();
            if( RootComp && !RootComp->IsPendingKill() )
            {
                InputCurve->AttachToComponent( RootComp, FAttachmentTransformRules::KeepRelativeTransform );
            }
        }
        else
        {
            // Manually destroying the "ghost" curve
            InputCurve->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
            InputCurve->UnregisterComponent();
            InputCurve->DestroyComponent();
            InputCurve = nullptr;
        }
    }

    if (InputOutlinerMeshArray.Num() > 0)
    {
        // Proper initialization of the outliner inputs is delayed to the first WorldTick,
        // As some of the Actors' components might not be properly initialized yet
        OutlinerInputsNeedPostLoadInit = true;

#if WITH_EDITOR
        StartWorldOutlinerTicking();
#endif
    }

    // Also set the expanded ui
    TransformUIExpanded.SetNumZeroed( InputObjects.Num() );
}

void
UHoudiniAssetInput::Serialize( FArchive & Ar )
{
    // Call base implementation.
    Super::Serialize( Ar );

    Ar.UsingCustomVersion( FHoudiniCustomSerializationVersion::GUID );

    // Serialize current choice selection.
    SerializeEnumeration< EHoudiniAssetInputType::Enum >( Ar, ChoiceIndex );
    Ar << ChoiceStringValue;

    // We need these temporary variables for undo state tracking.
    bool bLocalInputAssetConnectedInHoudini = bInputAssetConnectedInHoudini;
    UHoudiniAssetComponent * LocalInputAssetComponent = InputAssetComponent;

    Ar << HoudiniAssetInputFlagsPacked;

    // Serialize input index.
    Ar << InputIndex;

    // Serialize input objects (if it's assigned).
    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_MULTI_GEO_INPUT)
    {
        Ar << InputObjects;
    }
    else
    {
        UObject* InputObject = nullptr;
        Ar << InputObject;
        InputObjects.Empty();
        InputObjects.Add( InputObject );
    }

    // Serialize input asset.
    Ar << InputAssetComponent;

    // Serialize curve and curve parameters (if we have those).
    Ar << InputCurve;
    Ar << InputCurveParameters;

    // Serialize landscape used for input.
    if (HoudiniAssetParameterVersion >= VER_HOUDINI_ENGINE_PARAM_LANDSCAPE_INPUT)
    {
        if (HoudiniAssetParameterVersion < VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_INPUT_SOFT_REF)
        {
            ALandscapeProxy* InputLandscapePtr = nullptr;
            Ar << InputLandscapePtr;

            InputLandscapeProxy = InputLandscapePtr;
        }
        else
        {
            Ar << InputLandscapeProxy;
        }

    }

    // Serialize world outliner inputs.
    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_ENGINE_PARAM_WORLD_OUTLINER_INPUT )
    {
        Ar << InputOutlinerMeshArray;
    }

    // Create necessary widget resources.
    if ( Ar.IsLoading() )
    {
        bLoadedParameter = true;

        if ( Ar.IsTransacting() )
        {
            bInputAssetConnectedInHoudini = bLocalInputAssetConnectedInHoudini;

            if ( LocalInputAssetComponent != InputAssetComponent )
            {
                if ( InputAssetComponent )
                    bInputAssetConnectedInHoudini = false;

                if ( LocalInputAssetComponent )
                    LocalInputAssetComponent->RemoveDownstreamAsset( GetHoudiniAssetComponent(), InputIndex );
            }
        }
        else
        {
            // If we're loading for real for the first time we need to reset this
            // flag so we can reconnect when we get our parameters uploaded.
            bInputAssetConnectedInHoudini = false;
        }
    }

    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_UNREAL_SPLINE_RESOLUTION_PER_INPUT )
        Ar << UnrealSplineResolution;

    if ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_GEOMETRY_INPUT_TRANSFORMS )
    {
        Ar << InputTransforms;
    }
    else
    {
        InputTransforms.SetNum( InputObjects.Num() );
        for( int32 n = 0; n < InputTransforms.Num(); n++ )
            InputTransforms[ n ] = FTransform::Identity;
    }

    if ( ( HoudiniAssetParameterVersion >= VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_INPUT_LANDSCAPE_TRANSFORM )
        && ( HoudiniAssetParameterVersion != VER_HOUDINI_PLUGIN_SERIALIZATION_VERSION_419_SERIALIZATION_FIX ) )
        Ar << InputLandscapeTransform;
}

void
UHoudiniAssetInput::AddReferencedObjects( UObject * InThis, FReferenceCollector & Collector )
{
    UHoudiniAssetInput * HoudiniAssetInput = Cast< UHoudiniAssetInput >( InThis );
    if ( HoudiniAssetInput && !HoudiniAssetInput->IsPendingKill() )
    {
        // Add reference to held geometry object.
        if ( HoudiniAssetInput->InputObjects.Num() 
            && ( HoudiniAssetInput->GetChoiceIndex() == EHoudiniAssetInputType::GeometryInput ) )
            Collector.AddReferencedObjects( HoudiniAssetInput->InputObjects, InThis );

        /*
        // Add reference to held input asset component, if we have one.
        if ( HoudiniAssetInput->InputAssetComponent && !HoudiniAssetInput->InputAssetComponent->IsPendingKill() 
            && ( HoudiniAssetInput->GetChoiceIndex() == EHoudiniAssetInputType::AssetInput ) )
            Collector.AddReferencedObject( HoudiniAssetInput->InputAssetComponent, InThis );
        */

        // Add reference to held curve object.
        if ( HoudiniAssetInput->InputCurve && !HoudiniAssetInput->InputCurve->IsPendingKill() )
            Collector.AddReferencedObject( HoudiniAssetInput->InputCurve, InThis );

        // Do not add references to Actors/Landscapes in our world outliner as if they are in 
        // an other level it will prevent saving due to the external references...
        // Add references for all curve input parameters.
        for ( TMap< FString, UHoudiniAssetParameter * >::TIterator IterParams( HoudiniAssetInput->InputCurveParameters );
            IterParams; ++IterParams )
        {
            UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
            if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
                Collector.AddReferencedObject( HoudiniAssetParameter, InThis );
        }
    }

    // Call base implementation.
    Super::AddReferencedObjects( InThis, Collector );
}

void
UHoudiniAssetInput::ClearInputCurveParameters()
{
    for( TMap< FString, UHoudiniAssetParameter * >::TIterator IterParams( InputCurveParameters ); IterParams; ++IterParams )
    {
        UHoudiniAssetParameter * HoudiniAssetParameter = IterParams.Value();
        if ( HoudiniAssetParameter )
            HoudiniAssetParameter->ConditionalBeginDestroy();
    }

    InputCurveParameters.Empty();
}

void
UHoudiniAssetInput::DisconnectInputCurve()
{
    // If we have spline, delete it.
    if ( InputCurve && !InputCurve->IsPendingKill() )
    {
        InputCurve->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
        InputCurve->UnregisterComponent();
    }
}

void
UHoudiniAssetInput::DestroyInputCurve()
{
    // If we have spline, delete it.
    if ( InputCurve && !InputCurve->IsPendingKill() )
    {
        InputCurve->DetachFromComponent( FDetachmentTransformRules::KeepRelativeTransform );
        InputCurve->UnregisterComponent();
        InputCurve->DestroyComponent();

        InputCurve = nullptr;
    }

    ClearInputCurveParameters();
}

#if WITH_EDITOR

void
UHoudiniAssetInput::OnStaticMeshDropped( UObject * InObject, int32 AtIndex )
{
    UObject* InputObject = GetInputObject( AtIndex );
    if ( InObject != InputObject )
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
            PrimaryObject );
        Modify();

        if ( InputObjects.IsValidIndex( AtIndex ) )
        {
            InputObjects[ AtIndex ] = InObject;
        }
        else
        {
            check( AtIndex == 0 );
            InputObjects.Add( InObject );
        }

        if ( !InputTransforms.IsValidIndex( AtIndex ) )
            InputTransforms.Add( FTransform::Identity );

        if ( !TransformUIExpanded.IsValidIndex( AtIndex ) )
            TransformUIExpanded.Add( false );

        bStaticMeshChanged = true;
        MarkChanged();

        OnParamStateChanged();
    }
}

void
UHoudiniAssetInput::OnSkeletalMeshDropped( UObject * InObject, int32 AtIndex )
{
    UObject* InputObject = GetSkeletonInputObject( AtIndex );
    if ( InObject != InputObject )
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Skeleton Input Change" ),
            PrimaryObject );
        Modify();

        if ( SkeletonInputObjects.IsValidIndex( AtIndex ) )
        {
            SkeletonInputObjects[ AtIndex ] = InObject;
        }
        else
        {
            check( AtIndex == 0 );
            SkeletonInputObjects.Add( InObject );
        }

        /*
        if ( !InputTransforms.IsValidIndex( AtIndex ) )
            InputTransforms.Add( FTransform::Identity );

        if ( !TransformUIExpanded.IsValidIndex( AtIndex ) )
            TransformUIExpanded.Add( false );
        */

        bStaticMeshChanged = true;
        MarkChanged();

        OnParamStateChanged();
    }
}


FReply
UHoudiniAssetInput::OnThumbnailDoubleClick( const FGeometry & InMyGeometry, const FPointerEvent & InMouseEvent, int32 AtIndex )
{
    UObject* InputObject = GetInputObject( AtIndex );
    if ( InputObject && InputObject->IsA( UStaticMesh::StaticClass() ) && GEditor )
        GEditor->EditObject( InputObject );

    return FReply::Handled();
}

void UHoudiniAssetInput::OnStaticMeshBrowse( int32 AtIndex )
{
    UObject* InputObject = GetInputObject( AtIndex );
    if ( GEditor && InputObject )
    {
        TArray< UObject * > Objects;
        Objects.Add( InputObject );
        GEditor->SyncBrowserToObjects( Objects );
    }
}

void UHoudiniAssetInput::OnSkeletalMeshBrowse( int32 AtIndex )
{
    UObject* InputObject = GetSkeletonInputObject( AtIndex );
    if ( GEditor && InputObject )
    {
        TArray< UObject * > Objects;
        Objects.Add( InputObject );
        GEditor->SyncBrowserToObjects( Objects );
    }
}

FReply
UHoudiniAssetInput::OnResetStaticMeshClicked( int32 AtIndex )
{
    OnStaticMeshDropped( nullptr, AtIndex );
    return FReply::Handled();
}

FReply
UHoudiniAssetInput::OnResetSkeletalMeshClicked( int32 AtIndex )
{
    OnSkeletalMeshDropped( nullptr, AtIndex );
    return FReply::Handled();
}

void
UHoudiniAssetInput::OnChoiceChange( TSharedPtr< FString > NewChoice )
{
    if ( !NewChoice.IsValid() )
        return;

    ChoiceStringValue = *( NewChoice.Get() );

    // We need to match selection based on label.
    bool bLocalChanged = false;
    int32 ActiveLabel = 0;

    for ( int32 LabelIdx = 0; LabelIdx < StringChoiceLabels.Num(); ++LabelIdx )
    {
        FString * ChoiceLabel = StringChoiceLabels[ LabelIdx ].Get();

        if ( ChoiceLabel && ChoiceLabel->Equals( ChoiceStringValue ) )
        {
            bLocalChanged = true;
            ActiveLabel = LabelIdx;
            break;
        }
    }

    if ( !bLocalChanged )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Type Change" ),
        PrimaryObject );
    Modify();

    // Switch mode.
    EHoudiniAssetInputType::Enum newChoice = static_cast<EHoudiniAssetInputType::Enum>(ActiveLabel);
    ChangeInputType( newChoice, false );
    MarkChanged();
}

bool
UHoudiniAssetInput::ChangeInputType(const EHoudiniAssetInputType::Enum& newType, const bool& ForceRefresh )
{
    if ( ChoiceIndex == newType && !ForceRefresh )
        return true;

    switch ( ChoiceIndex )
    {
        case EHoudiniAssetInputType::GeometryInput:
        {
            // We are switching away from geometry input.
            break;
        }

        case EHoudiniAssetInputType::AssetInput:
        {
            // We are switching away from asset input.  WIll be handled in DisconnectAndDestroyInputAsset
            break;
        }

        case EHoudiniAssetInputType::CurveInput:
        {
            // We are switching away from curve input.
            DisconnectInputCurve();
            break;
        }

        case EHoudiniAssetInputType::LandscapeInput:
        {
            break;
        }

        case EHoudiniAssetInputType::WorldInput:
        {
            // We are switching away from World Outliner input.
            // Stop monitoring the Actors for transform changes.
            StopWorldOutlinerTicking();

            break;
        }

        case EHoudiniAssetInputType::SkeletonInput:
        {
            // We are switching away from a skeleton input.
            break;
        }

        default:
        {
            // Unhandled new input type?
            check(0);
            break;
        }
    }

    // Disconnect currently connected asset.
    DisconnectAndDestroyInputAsset();

    // Make sure we'll fully update the editor properties
    if ( ChoiceIndex != newType && InputAssetComponent )
        InputAssetComponent->bEditorPropertiesNeedFullUpdate = true;

    // Switch mode.
    ChoiceIndex = newType;

    // Switch mode.
    switch ( newType )
    {
        case EHoudiniAssetInputType::GeometryInput:
        {
            // We are switching to geometry input.
            if ( InputObjects.Num() )
                bStaticMeshChanged = true;
            break;
        }

        case EHoudiniAssetInputType::AssetInput:
        {
            // We are switching to asset input.
            ConnectInputAssetActor();
            break;
        }

        case EHoudiniAssetInputType::CurveInput:
        {
            // We are switching to curve input.

            // Create new spline component if necessary.
            USceneComponent* RootComp = GetHoudiniAssetComponent();
            if( RootComp && !RootComp->IsPendingKill()
                && RootComp->GetOwner() && !RootComp->GetOwner()->IsPendingKill() )
            {
                if( !InputCurve || InputCurve->IsPendingKill() )
                {
                    InputCurve = NewObject< UHoudiniSplineComponent >(
                        RootComp->GetOwner(), UHoudiniSplineComponent::StaticClass(),
                        NAME_None, RF_Public | RF_Transactional );
                }
                // Attach or re-attach curve component to asset.
                InputCurve->AttachToComponent( RootComp, FAttachmentTransformRules::KeepRelativeTransform );
                InputCurve->RegisterComponent();
                InputCurve->SetVisibility( true );
                InputCurve->SetHoudiniAssetInput( this );

                bSwitchedToCurve = true;
            }
            break;
        }

        case EHoudiniAssetInputType::LandscapeInput:
        {
            // We are switching to Landscape input.
            break;
        }

        case EHoudiniAssetInputType::WorldInput:
        {
            // We are switching to World Outliner input.

            // Start monitoring the Actors for transform changes.
            StartWorldOutlinerTicking();

            // Force recook and reconnect of the input assets.
            HAPI_NodeId HostAssetId = GetAssetId();
            if ( FHoudiniEngineUtils::HapiCreateInputNodeForWorldOutliner(
                HostAssetId, InputOutlinerMeshArray,
                ConnectedAssetId, CreatedInputDataAssetIds,
                UnrealSplineResolution ) )
            {
                ConnectInputNode();
            }

            break;
        }

        case EHoudiniAssetInputType::SkeletonInput:
        {
            // We are switching to skeleton input.
            if ( SkeletonInputObjects.Num() )
                bStaticMeshChanged = true;
            break;
        }

        default:
        {
            // Unhandled new input type?
            check(0);
            break;
        }
    }

    // Make sure the Input choice string corresponds to the selected input type
    if ( StringChoiceLabels.IsValidIndex( ChoiceIndex ) )
    {
        FString NewStringChoice = *( StringChoiceLabels[ ChoiceIndex ].Get() );
        if ( !ChoiceStringValue.Equals(NewStringChoice, ESearchCase::IgnoreCase ) )
            ChoiceStringValue = NewStringChoice;
    }

    // If we have input object and geometry asset, we need to connect it back.
    MarkChanged();

    return true;
}

bool
UHoudiniAssetInput::OnShouldFilterActor( const AActor * const Actor ) const
{
    if ( !Actor )
        return false;

    if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
    {
        // Only return HoudiniAssetActors
        if ( Actor->IsA<AHoudiniAssetActor>() )
        {
            // But not our own Asset Actor
            if( const USceneComponent* RootComp = Cast<const USceneComponent>( GetHoudiniAssetComponent() ))
            {
                if( RootComp && Cast<AHoudiniAssetActor>( RootComp->GetOwner() ) != Actor )
                    return true;
            }
            return false;
        }
    }
    else if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
    {
        // Only returns Landscape
        if ( Actor->IsA<ALandscapeProxy>() )
        {
            ALandscapeProxy* LandscapeProxy = const_cast<ALandscapeProxy *>(Cast<const ALandscapeProxy>(Actor));
            // But not a landscape generated by this asset
            const UHoudiniAssetComponent * HoudiniAssetComponent = GetHoudiniAssetComponent();
            if (HoudiniAssetComponent && LandscapeProxy && !HoudiniAssetComponent->HasLandscapeActor( LandscapeProxy->GetLandscapeActor() ) )
                return true;
        }
        return false;
    }        
    else if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
    {
        for ( auto & OutlinerMesh : InputOutlinerMeshArray )
            if ( OutlinerMesh.ActorPtr.Get() == Actor )
                return true;
    }

    return false;
}

void
UHoudiniAssetInput::OnActorSelected( AActor * Actor )
{
    if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
        return OnInputActorSelected( Actor );
    else if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
        return OnWorldOutlinerActorSelected( Actor );
    else if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
        return OnLandscapeActorSelected( Actor );
}

void
UHoudiniAssetInput::OnInputActorSelected( AActor * Actor )
{
    if ( ( !Actor || Actor->IsPendingKill() )
        && ( InputAssetComponent && !InputAssetComponent->IsPendingKill() ) )
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Asset Change" ),
            PrimaryObject );
        Modify();

        // Tell the old input asset we are no longer connected.
        InputAssetComponent->RemoveDownstreamAsset( GetHoudiniAssetComponent(), InputIndex );

        // We cleared the selection so just reset all the values.
        InputAssetComponent = nullptr;
        ConnectedAssetId = -1;
    }
    else
    {
        AHoudiniAssetActor * HoudiniAssetActor = (AHoudiniAssetActor *)Actor;
        if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
            return;

        UHoudiniAssetComponent * ConnectedHoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
        if ( !ConnectedHoudiniAssetComponent || ConnectedHoudiniAssetComponent->IsPendingKill() )
            return;

        // If we just selected the already selected Actor do nothing if we are properly connected.
        if ( ConnectedHoudiniAssetComponent == InputAssetComponent && bInputAssetConnectedInHoudini)
            return;

        // Do not allow the input asset to be ourself!
        if ( ConnectedHoudiniAssetComponent == PrimaryObject )
            return;

        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Asset Change" ),
            PrimaryObject );
        Modify();

        // Tell the old input asset we are no longer connected.
        if ( InputAssetComponent && !InputAssetComponent->IsPendingKill() )
            InputAssetComponent->RemoveDownstreamAsset( GetHoudiniAssetComponent(), InputIndex );

        InputAssetComponent = ConnectedHoudiniAssetComponent;
        ConnectedAssetId = InputAssetComponent->GetAssetId();

        // Do we have to wait for the input asset to cook?
        const UHoudiniAssetComponent* HAC = GetHoudiniAssetComponent();
        if ( HAC && !HAC->IsPendingKill() )
            GetHoudiniAssetComponent()->UpdateWaitingForUpstreamAssetsToInstantiate( true );

        // Mark as disconnected since we need to reconnect to the new asset.
        bInputAssetConnectedInHoudini = false;
    }

    MarkChanged();
}

void
UHoudiniAssetInput::OnLandscapeActorSelected( AActor * Actor )
{
    ALandscapeProxy * LandscapeProxy = Cast< ALandscapeProxy >( Actor );
    if ( LandscapeProxy && !LandscapeProxy->IsPendingKill() )
    {
        // If we just selected the already selected landscape, do nothing.
        if ( LandscapeProxy == InputLandscapeProxy )
            return;

        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Landscape Change." ),
            PrimaryObject );
        Modify();

        // Store new landscape.
        InputLandscapeProxy = LandscapeProxy;
        InputLandscapeTransform = LandscapeProxy->ActorToWorld();
    }
    else
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Landscape Change." ),
            PrimaryObject );
        Modify();

        InputLandscapeProxy = nullptr;
        InputLandscapeTransform = FTransform::Identity;
    }

    MarkChanged();
}

void
UHoudiniAssetInput::OnWorldOutlinerActorSelected( AActor * )
{
    // Do nothing.
}

void
UHoudiniAssetInput::TickWorldOutlinerInputs()
{
    // Do not tick non world inputs
    if (ChoiceIndex != EHoudiniAssetInputType::WorldInput)
    {
        return;
    }

    // Only tick/cook when in Editor
    // This prevents PIE cooks or runtime cooks due to inputs moving
    if (!GetWorld() || (GetWorld()->WorldType != EWorldType::Editor))
    {
        return;
    }

#if WITH_EDITOR
    // Stop outliner objects from causing recooks while input objects are dragged around
    if (FHoudiniMoveTracker::Get().IsObjectMoving)
    {
        return;
    }
#endif

    // PostLoad initialization must be done on the first tick
    // as some components might now have been fully initialized during PostLoad()
    if ( OutlinerInputsNeedPostLoadInit )
    {
        for (auto & OutlinerInput : InputOutlinerMeshArray)
        {
            if (OutlinerInput.ActorPtr.IsValid())
                continue;

            // Try to update the actor ptr via the pathname
            OutlinerInput.TryToUpdateActorPtrFromActorPathName();
        }

        UpdateInputOulinerArray();

        // The spline Transform array might need to be rebuilt after loading
        for (auto & OutlinerInput : InputOutlinerMeshArray)
        {
            OutlinerInput.RebuildSplineTransformsArrayIfNeeded();
            OutlinerInput.KeepWorldTransform = bKeepWorldTransform;
            OutlinerInput.SplineResolution = UnrealSplineResolution;
        }

        OutlinerInputsNeedPostLoadInit = false;
        return;
    }

    // Don't do anything more if HEngine cooking is paused
    // We need to be able to detect updates/changes to the input actor when cooking is unpaused
    if ( !FHoudiniEngine::Get().GetEnableCookingGlobal() )
        return;

    // Lambda use to Modify / Prechange only once
    bool bLocalChanged = false;
    auto MarkLocalChanged = [&]()
    {
        if ( !bLocalChanged )
        {
            Modify();
            bLocalChanged = true;
        }
    };
    
    // Refresh the input's component from the actor
    // If the Actor is a blueprint, its component are recreated for every modification
    if ( UpdateInputOulinerArray() )
    {
        MarkLocalChanged();
        bStaticMeshChanged = true;
        MarkChanged();
    }

    //
    if ( bStaticMeshChanged )
        return;

    // Check for destroyed / modified outliner inputs
    for ( auto & OutlinerInput : InputOutlinerMeshArray )
    {
        if ( !OutlinerInput.ActorPtr.IsValid() )
            continue;

        if ( OutlinerInput.HasActorTransformChanged() && ( OutlinerInput.AssetId >= 0 ) )
        {
            MarkLocalChanged();

            // Updates to the new Transform
            UpdateWorldOutlinerTransforms( OutlinerInput );

            HAPI_TransformEuler HapiTransform;
            FHoudiniApi::TransformEuler_Init(&HapiTransform);
            //FMemory::Memzero< HAPI_TransformEuler >( HapiTransform );
            FHoudiniEngineUtils::TranslateUnrealTransform( OutlinerInput.ComponentTransform, HapiTransform );

            HAPI_NodeInfo LocalAssetNodeInfo;
            FHoudiniApi::NodeInfo_Init(&LocalAssetNodeInfo);
            const HAPI_Result LocalResult = FHoudiniApi::GetNodeInfo(
                FHoudiniEngine::Get().GetSession(), OutlinerInput.AssetId,
                &LocalAssetNodeInfo);

            if ( LocalResult == HAPI_RESULT_SUCCESS )
                FHoudiniApi::SetObjectTransform(
                    FHoudiniEngine::Get().GetSession(),
                    LocalAssetNodeInfo.parentId, &HapiTransform );
        }
        else if ( OutlinerInput.HasComponentTransformChanged() 
                || ( OutlinerInput.HasSplineComponentChanged( UnrealSplineResolution ) )
                || ( OutlinerInput.KeepWorldTransform != bKeepWorldTransform ) )
        {
            MarkLocalChanged();

            // Update to the new Transforms
            UpdateWorldOutlinerTransforms( OutlinerInput );

            // The component or spline has been modified so so we need to indicate that the "static mesh" 
            // has changed in order to rebuild the asset properly in UploadParameterValue()
            bStaticMeshChanged = true;
        }
        else if ( OutlinerInput.HasComponentMaterialsChanged() )
        {
            MarkLocalChanged();

            // Update the materials
            UpdateWorldOutlinerMaterials( OutlinerInput );

            // The materials have been changed so so we need to indicate that the "static mesh" 
            // has changed in order to rebuild the asset properly in UploadParameterValue()
            bStaticMeshChanged = true;
        }
    }

    if ( bLocalChanged )
        MarkChanged();
}

#endif

void
UHoudiniAssetInput::ConnectInputAssetActor()
{
    // Check the component we're connected to is valid
    if ( !InputAssetComponent )
        return;

    if ( !FHoudiniEngineUtils::IsValidNodeId( InputAssetComponent->GetAssetId() ) )
        return;

    // Check we have the correct Id
    if ( ConnectedAssetId != InputAssetComponent->GetAssetId() )
        ConnectedAssetId = InputAssetComponent->GetAssetId();

    // Connect if needed
    if ( !bInputAssetConnectedInHoudini )
    {
        InputAssetComponent->AddDownstreamAsset( GetHoudiniAssetComponent(), InputIndex );
        bInputAssetConnectedInHoudini = ConnectInputNode();
    }
}

void
UHoudiniAssetInput::DisconnectInputAssetActor()
{
    if ( bInputAssetConnectedInHoudini && !InputAssetComponent )
    {
        if( bIsObjectPathParameter )
        {
            std::string ParamNameString = TCHAR_TO_UTF8( *GetParameterName() );

            FHoudiniApi::SetParmStringValue(
                FHoudiniEngine::Get().GetSession(), NodeId, "",
                ParmId, 0);
        }
        else
        {
            FHoudiniEngineUtils::HapiDisconnectAsset( GetAssetId(), InputIndex );
        }
        bInputAssetConnectedInHoudini = false;
    }
}

void
UHoudiniAssetInput::ConnectLandscapeActor()
{}

void
UHoudiniAssetInput::DisconnectLandscapeActor()
{}

HAPI_NodeId
UHoudiniAssetInput::GetConnectedAssetId() const
{
    return ConnectedAssetId;
}

bool
UHoudiniAssetInput::IsGeometryAssetConnected() const
{
    if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) && ( ChoiceIndex == EHoudiniAssetInputType::GeometryInput ) )
    {
        for ( auto InputObject : InputObjects )
        {
            if ( InputObject && !InputObject->IsPendingKill() )
                return true;
        }
    }

    return false;
}

bool
UHoudiniAssetInput::IsInputAssetConnected() const
{
    if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId )
        && InputAssetComponent
        && !InputAssetComponent->IsPendingKill()
        && bInputAssetConnectedInHoudini )
    {
        if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
            return true;
    }

    return false;
}

bool
UHoudiniAssetInput::IsCurveAssetConnected() const
{
    if (InputCurve && !InputCurve->IsPendingKill() && ( ChoiceIndex == EHoudiniAssetInputType::CurveInput ) )
        return true;

    return false;
}

bool
UHoudiniAssetInput::IsLandscapeAssetConnected() const
{
    if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) )
    {
        if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
            return true;
    }

    return false;
}

bool
UHoudiniAssetInput::IsWorldInputAssetConnected() const
{
    if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) )
    {
        if ( ChoiceIndex == EHoudiniAssetInputType::WorldInput )
            return true;
    }

    return false;
}

void
UHoudiniAssetInput::OnInputCurveChanged()
{
    MarkChanged();
}

void
UHoudiniAssetInput::ExternalDisconnectInputAssetActor()
{
    InputAssetComponent = nullptr;
    ConnectedAssetId = -1;

    MarkChanged();
}

bool
UHoudiniAssetInput::DoesInputAssetNeedInstantiation()
{
    //if ( ChoiceIndex != EHoudiniAssetInputType::AssetInput )
    //    return false;

    if ( InputAssetComponent == nullptr )
        return false;

    if ( !FHoudiniEngineUtils::IsValidNodeId(InputAssetComponent->GetAssetId() ) )
        return true;

    return false;
}

UHoudiniAssetComponent *
UHoudiniAssetInput::GetConnectedInputAssetComponent()
{
    return InputAssetComponent;
}

void
UHoudiniAssetInput::NotifyChildParameterChanged( UHoudiniAssetParameter * HoudiniAssetParameter )
{
    if ( HoudiniAssetParameter && ChoiceIndex == EHoudiniAssetInputType::CurveInput )
    {
        if ( FHoudiniEngineUtils::IsValidNodeId( ConnectedAssetId ) )
        {
            // We need to upload changed param back to HAPI.
            if (! HoudiniAssetParameter->UploadParameterValue() )
            {
                HOUDINI_LOG_ERROR( TEXT("%s UploadParameterValue failed"), InputAssetComponent ? *InputAssetComponent->GetOwner()->GetName() : TEXT("unknown") );
            }
        }

        MarkChanged();
    }
}

bool
UHoudiniAssetInput::UpdateInputCurve()
{
    bool Success = true;
    FString CurvePointsString;
    EHoudiniSplineComponentType::Enum CurveTypeValue = EHoudiniSplineComponentType::Bezier;
    EHoudiniSplineComponentMethod::Enum CurveMethodValue = EHoudiniSplineComponentMethod::CVs;
    int32 CurveClosed = 1;

    if(ConnectedAssetId != -1)
    {
        FHoudiniEngineUtils::HapiGetParameterDataAsString(
            ConnectedAssetId, HAPI_UNREAL_PARAM_CURVE_COORDS, TEXT( "" ),
            CurvePointsString );
        FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
            ConnectedAssetId, HAPI_UNREAL_PARAM_CURVE_TYPE,
            (int32) EHoudiniSplineComponentType::Bezier, (int32 &) CurveTypeValue );
        FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
            ConnectedAssetId, HAPI_UNREAL_PARAM_CURVE_METHOD,
            (int32) EHoudiniSplineComponentMethod::CVs, (int32 &) CurveMethodValue );
        FHoudiniEngineUtils::HapiGetParameterDataAsInteger(
            ConnectedAssetId, HAPI_UNREAL_PARAM_CURVE_CLOSED, 1, CurveClosed );
    }

    // We need to get the NodeInfo to get the parent id
    HAPI_NodeInfo NodeInfo;
    FHoudiniApi::NodeInfo_Init(&NodeInfo);
    HOUDINI_CHECK_ERROR_RETURN(
        FHoudiniApi::GetNodeInfo(FHoudiniEngine::Get().GetSession(), ConnectedAssetId, &NodeInfo),
        false);

    // Construct geo part object.
    FHoudiniGeoPartObject HoudiniGeoPartObject( ConnectedAssetId, NodeInfo.parentId, ConnectedAssetId, 0 );
    HoudiniGeoPartObject.bIsCurve = true;

    HAPI_AttributeInfo AttributeRefinedCurvePositions;
    FHoudiniApi::AttributeInfo_Init(&AttributeRefinedCurvePositions);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeRefinedCurvePositions );

    TArray< float > RefinedCurvePositions;
    FHoudiniEngineUtils::HapiGetAttributeDataAsFloat(
        HoudiniGeoPartObject, HAPI_UNREAL_ATTRIB_POSITION,
        AttributeRefinedCurvePositions, RefinedCurvePositions );

    // Process coords string and extract positions.
    TArray< FVector > CurvePoints;
    FHoudiniEngineUtils::ExtractStringPositions( CurvePointsString, CurvePoints );

    TArray< FVector > CurveDisplayPoints;
    FHoudiniEngineUtils::ConvertScaleAndFlipVectorData( RefinedCurvePositions, CurveDisplayPoints );

    if (InputCurve && !InputCurve->IsPendingKill() )
    {
        InputCurve->Construct(
            HoudiniGeoPartObject, CurveDisplayPoints, CurveTypeValue, CurveMethodValue,
            (CurveClosed == 1));
    }

    // We also need to construct curve parameters we care about.
    TMap< FString, UHoudiniAssetParameter * > NewInputCurveParameters;

    TArray< HAPI_ParmInfo > ParmInfos;
    ParmInfos.SetNumUninitialized( NodeInfo.parmCount );
    for (int32 Idx = 0; Idx < ParmInfos.Num(); Idx++)
        FHoudiniApi::ParmInfo_Init(&(ParmInfos[Idx]));

    HOUDINI_CHECK_ERROR_RETURN(
        FHoudiniApi::GetParameters(
            FHoudiniEngine::Get().GetSession(), ConnectedAssetId, 
            &ParmInfos[ 0 ], 0, NodeInfo.parmCount ), false);

    // Retrieve integer values for this asset.
    TArray< int32 > ParmValueInts;
    ParmValueInts.SetNumZeroed( NodeInfo.parmIntValueCount );
    if ( NodeInfo.parmIntValueCount > 0 )
    {
        HOUDINI_CHECK_ERROR_RETURN(
            FHoudiniApi::GetParmIntValues(
                FHoudiniEngine::Get().GetSession(), ConnectedAssetId, &ParmValueInts[ 0 ], 0, NodeInfo.parmIntValueCount ),
        false );
    }

    // Retrieve float values for this asset.
    TArray< float > ParmValueFloats;
    ParmValueFloats.SetNumZeroed( NodeInfo.parmFloatValueCount );
    if ( NodeInfo.parmFloatValueCount > 0 )
    {
        HOUDINI_CHECK_ERROR_RETURN(
            FHoudiniApi::GetParmFloatValues(
                FHoudiniEngine::Get().GetSession(), ConnectedAssetId, &ParmValueFloats[ 0 ], 0, NodeInfo.parmFloatValueCount ),
        false );
    }

    // Retrieve string values for this asset.
    TArray< HAPI_StringHandle > ParmValueStrings;
    ParmValueStrings.SetNumZeroed( NodeInfo.parmStringValueCount );
    if ( NodeInfo.parmStringValueCount > 0 )
    {
        HOUDINI_CHECK_ERROR_RETURN(
            FHoudiniApi::GetParmStringValues(
                FHoudiniEngine::Get().GetSession(), ConnectedAssetId, true, &ParmValueStrings[ 0 ], 0, NodeInfo.parmStringValueCount ),
        false );
    }

    // Create properties for parameters.
    for ( int32 ParamIdx = 0; ParamIdx < NodeInfo.parmCount; ++ParamIdx )
    {
        // Retrieve param info at this index.
        const HAPI_ParmInfo & ParmInfo = ParmInfos[ ParamIdx ];

        // If parameter is invisible, skip it.
        if ( ParmInfo.invisible )
            continue;

        FString LocalParameterName;
        FHoudiniEngineString HoudiniEngineString( ParmInfo.nameSH );
        if ( !HoudiniEngineString.ToFString( LocalParameterName ) )
        {
            // We had trouble retrieving name of this parameter, skip it.
            continue;
        }

        // See if it's one of parameters we are interested in.
        if ( !LocalParameterName.Equals( TEXT( HAPI_UNREAL_PARAM_CURVE_METHOD ) ) &&
            !LocalParameterName.Equals( TEXT( HAPI_UNREAL_PARAM_CURVE_TYPE ) ) &&
            !LocalParameterName.Equals( TEXT( HAPI_UNREAL_PARAM_CURVE_CLOSED ) ) )
        {
            // Not parameter we are interested in.
            continue;
        }

        // See if this parameter has already been created.
        UHoudiniAssetParameter * const * FoundHoudiniAssetParameter = InputCurveParameters.Find( LocalParameterName );
        UHoudiniAssetParameter * HoudiniAssetParameter = FoundHoudiniAssetParameter ? *FoundHoudiniAssetParameter : nullptr;

        // If parameter exists, we can reuse it.
        if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
        {
            // Remove parameter from current map.
            InputCurveParameters.Remove( LocalParameterName );

            // Reinitialize parameter and add it to map.
            HoudiniAssetParameter->CreateParameter( nullptr, this, ConnectedAssetId, ParmInfo );
            NewInputCurveParameters.Add( LocalParameterName, HoudiniAssetParameter );
            continue;
        }
        else
        {
            if ( ParmInfo.type == HAPI_PARMTYPE_INT )
            {
                if ( !ParmInfo.choiceCount )
                    HoudiniAssetParameter = UHoudiniAssetParameterInt::Create( nullptr, this, ConnectedAssetId, ParmInfo );
                else
                    HoudiniAssetParameter = UHoudiniAssetParameterChoice::Create( nullptr, this, ConnectedAssetId, ParmInfo );
            }
            else if ( ParmInfo.type == HAPI_PARMTYPE_TOGGLE )
            {
                HoudiniAssetParameter = UHoudiniAssetParameterToggle::Create( nullptr, this, ConnectedAssetId, ParmInfo );
            }
            else
            {
                Success = false;
                check( false );
            }

            if ( HoudiniAssetParameter && !HoudiniAssetParameter->IsPendingKill() )
                NewInputCurveParameters.Add( LocalParameterName, HoudiniAssetParameter );
        }
    }

    ClearInputCurveParameters();
    InputCurveParameters = NewInputCurveParameters;

    if ( bSwitchedToCurve )
    {

#if WITH_EDITOR
        // We need to trigger details panel update.
        OnParamStateChanged();

        // 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 (GUnrealEd)
            GUnrealEd->NoteSelectionChange();
#endif

        bSwitchedToCurve = false;
    }
    return Success;
}

FText
UHoudiniAssetInput::HandleChoiceContentText() const
{
    return FText::FromString( ChoiceStringValue );
}

#if WITH_EDITOR

void
UHoudiniAssetInput::CheckStateChangedExportOnlySelected( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportSelectionOnly != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Selected Landscape Components mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportSelectionOnly = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportOnlySelected() const
{
    if ( bLandscapeExportSelectionOnly )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedAutoSelectLandscape( ECheckBoxState NewState )
{
    int32 bState = (NewState == ECheckBoxState::Checked);

    if (bLandscapeAutoSelectComponent != bState)
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT(HOUDINI_MODULE_RUNTIME),
            LOCTEXT("HoudiniInputChange", "Houdini Export Auto-Select Landscape Components mode change."),
            PrimaryObject);
        Modify();

        bLandscapeAutoSelectComponent = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedAutoSelectLandscape() const
{
    if ( bLandscapeAutoSelectComponent )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportCurves( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportCurves != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape Curve mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportCurves = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportCurves() const
{
    if ( bLandscapeExportCurves )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportAsMesh( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportAsMesh != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape As Mesh mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportAsMesh = bState;

        if ( bState )
            bLandscapeExportAsHeightfield = false;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportAsMesh() const
{
    if ( bLandscapeExportAsMesh )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportAsHeightfield( ECheckBoxState NewState ) 
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportAsHeightfield != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT(HOUDINI_MODULE_RUNTIME),
            LOCTEXT("HoudiniInputChange", "Houdini Export Landscape As Heightfield mode change."),
            PrimaryObject);
        Modify();

        bLandscapeExportAsHeightfield = bState;
        if ( bState )
            bLandscapeExportAsMesh = false;
        else
            bLandscapeExportAsMesh = true;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportAsHeightfield() const
{
    if ( bLandscapeExportAsHeightfield )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportAsPoints( ECheckBoxState NewState )
{
    int32 bState = (NewState == ECheckBoxState::Checked);

    uint32 bExportAsPoints = !bLandscapeExportAsHeightfield && !bLandscapeExportAsMesh;
    if (bExportAsPoints != bState)
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT(HOUDINI_MODULE_RUNTIME),
            LOCTEXT("HoudiniInputChange", "Houdini Export Landscape As Points mode change."),
            PrimaryObject);
        Modify();

        if ( bState )
        {
            bLandscapeExportAsHeightfield = false;
            bLandscapeExportAsMesh = false;
        }
        else
        {
            bLandscapeExportAsHeightfield = true;
            bLandscapeExportAsMesh = false;
        }

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportAsPoints() const
{
    if ( !bLandscapeExportAsHeightfield && !bLandscapeExportAsMesh )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportMaterials( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportMaterials != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape Materials mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportMaterials = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportMaterials() const
{
    if ( bLandscapeExportMaterials )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportLighting( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportLighting != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape Lighting mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportLighting = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportLighting() const
{
    if ( bLandscapeExportLighting )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportNormalizedUVs( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportNormalizedUVs != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape Normalized UVs mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportNormalizedUVs = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportNormalizedUVs() const
{
    if ( bLandscapeExportNormalizedUVs )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportTileUVs( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bLandscapeExportTileUVs != bState )
    {
        // Record undo information.
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Export Landscape Tile UVs mode change." ),
            PrimaryObject );
        Modify();

        bLandscapeExportTileUVs = bState;

        // Mark this parameter as changed.
        MarkChanged();
    }
}


ECheckBoxState
UHoudiniAssetInput::IsCheckedExportTileUVs() const
{
    if ( bLandscapeExportTileUVs )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedKeepWorldTransform(ECheckBoxState NewState)
{ 
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bKeepWorldTransform == bState )
        return;

    // Record undo information.
    FScopedTransaction Transaction(
        TEXT(HOUDINI_MODULE_RUNTIME),
        LOCTEXT("HoudiniInputChange", "Houdini Input Transform Type change."),
        PrimaryObject);
    Modify();

    bKeepWorldTransform = bState;

    // Mark this parameter as changed.
    MarkChanged();
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedKeepWorldTransform() const
{
    if ( bKeepWorldTransform == 2 )
    {
        if (GetDefaultTranformTypeValue())
            return ECheckBoxState::Checked;
        else
            return ECheckBoxState::Unchecked;
    }
    else if ( bKeepWorldTransform )
        return ECheckBoxState::Checked;
    
    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportAllLODs( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bExportAllLODs == bState )
        return;

    // Record undo information.
    FScopedTransaction Transaction(
        TEXT(HOUDINI_MODULE_RUNTIME),
        LOCTEXT("HoudiniInputChange", "Houdini Input Export all LODs changed."),
        PrimaryObject);
    Modify();

    bExportAllLODs = bState;

    // Changing the export of LODs changes the StaticMesh!
    if ( HasLODs() )
        bStaticMeshChanged = true;

    // Mark this parameter as changed.
    MarkChanged();
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportAllLODs() const
{
    if ( bExportAllLODs )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedExportSockets( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bExportSockets == bState )
        return;

    // Record undo information.
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input export sockets changed." ),
        PrimaryObject );
    Modify();

    bExportSockets = bState;

    // Changing the export of LODs changes the StaticMesh!
    if ( HasSockets() )
        bStaticMeshChanged = true;

    // Mark this parameter as changed.
    MarkChanged();
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedExportSockets() const
{
    if (bExportSockets)
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedUpdateInputLandscape( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bUpdateInputLandscape == bState )
        return;

    // Record undo information.
    FScopedTransaction Transaction(
        TEXT(HOUDINI_MODULE_RUNTIME),
        LOCTEXT("HoudiniInputChange", "Houdini Input Update Input Landscape changed."),
        PrimaryObject);
    Modify();

    UHoudiniAssetComponent* ParentComponent = GetHoudiniAssetComponent();
    if ( InputLandscapeProxy && ParentComponent )
    {        
        if ( bState )
        {
            // Build the backup file name
            FString BackupBaseName = ParentComponent->GetTempCookFolder().ToString()
                + TEXT("/")
                + InputLandscapeProxy->GetName()
                + TEXT("_")
                + ParentComponent->GetComponentGuid().ToString().Left(FHoudiniEngineUtils::PackageGUIDComponentNameLength);

            // We need to cache the input landscape to a file
            //FString BaseName = TEXT("/Game/HoudiniEngine/Temp/LandscapeBak");
            FHoudiniLandscapeUtils::BackupLandscapeToFile( BackupBaseName, InputLandscapeProxy.Get());
            InputLandscapeTransform = InputLandscapeProxy->ActorToWorld();
        }
        else
        {
            // Detach the input landscape from the HDA            
            InputLandscapeProxy->DetachFromActor( FDetachmentTransformRules::KeepWorldTransform );

            // Clear the landscape map to avoid reusing the input landscape
            ParentComponent->ClearLandscapes();

            // Restore the input landscape's backup data
            FHoudiniLandscapeUtils::RestoreLandscapeFromFile( InputLandscapeProxy.Get());

            // Reapply the source Landscape's transform
            InputLandscapeProxy->SetActorTransform(InputLandscapeTransform);
        }
    }

    bUpdateInputLandscape = bState;

    // Mark this parameter as changed.
    MarkChanged();
}

ECheckBoxState
UHoudiniAssetInput::IsCheckedUpdateInputLandscape() const
{
    if ( bUpdateInputLandscape )
        return ECheckBoxState::Checked;

    return ECheckBoxState::Unchecked;
}

void
UHoudiniAssetInput::CheckStateChangedPackBeforeMerge( ECheckBoxState NewState )
{
    int32 bState = ( NewState == ECheckBoxState::Checked );

    if ( bPackBeforeMerge == bState )
        return;

    // Record undo information.
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Pack Before Merge changed." ),
        PrimaryObject );
    Modify();

    bPackBeforeMerge = bState;

    // Mark this parameter as changed.
    MarkChanged( true );
}


ECheckBoxState
UHoudiniAssetInput::IsCheckedPackBeforeMerge() const
{
    if ( bPackBeforeMerge )
        return ECheckBoxState::Checked;
    else
        return ECheckBoxState::Unchecked;
}

void 
UHoudiniAssetInput::OnInsertGeo( int32 AtIndex )
{
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
        PrimaryObject );
    Modify();
    InputObjects.Insert( nullptr, AtIndex );
    InputTransforms.Insert( FTransform::Identity, AtIndex );
    TransformUIExpanded.Insert( false, AtIndex );
    bStaticMeshChanged = true;
    MarkChanged();
    OnParamStateChanged();
}

void 
UHoudiniAssetInput::OnDeleteGeo( int32 AtIndex )
{
    if ( ensure( InputObjects.IsValidIndex( AtIndex ) && InputTransforms.IsValidIndex( AtIndex ) ) )
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
            PrimaryObject );
        Modify();
        InputObjects.RemoveAt( AtIndex );
        InputTransforms.RemoveAt( AtIndex );
        TransformUIExpanded.RemoveAt( AtIndex );
        bStaticMeshChanged = true;
        MarkChanged();
        OnParamStateChanged();
    }
}

void 
UHoudiniAssetInput::OnDuplicateGeo( int32 AtIndex )
{
    if ( ensure( InputObjects.IsValidIndex( AtIndex ) ) && InputTransforms.IsValidIndex( AtIndex ) )
    {
        FScopedTransaction Transaction(
            TEXT( HOUDINI_MODULE_RUNTIME ),
            LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
            PrimaryObject );
        Modify();
        UObject* Dupe = InputObjects[AtIndex];
        InputObjects.Insert( Dupe, AtIndex );
        FTransform DupeTransform = InputTransforms[AtIndex];
        InputTransforms.Insert( DupeTransform, AtIndex );
        bool DupeUIExpanded = TransformUIExpanded[AtIndex];
        TransformUIExpanded.Insert( DupeUIExpanded, AtIndex );
        bStaticMeshChanged = true;
        MarkChanged();
        OnParamStateChanged();
    }
}

FReply
UHoudiniAssetInput::OnButtonClickRecommit()
{
    // There's no undo operation for button.
    MarkChanged();

    return FReply::Handled();
}

void
UHoudiniAssetInput::StartWorldOutlinerTicking()
{
    if ( InputOutlinerMeshArray.Num() > 0 && !WorldOutlinerTimerDelegate.IsBound() && GEditor )
    {
        WorldOutlinerTimerDelegate = FTimerDelegate::CreateUObject( this, &UHoudiniAssetInput::TickWorldOutlinerInputs );

        // We need to register delegate with the timer system.
        static const float TickTimerDelay = 0.5f;
        GEditor->GetTimerManager()->SetTimer( WorldOutlinerTimerHandle, WorldOutlinerTimerDelegate, TickTimerDelay, true );
    }
}

void
UHoudiniAssetInput::StopWorldOutlinerTicking()
{
    if ( InputOutlinerMeshArray.Num() <= 0 && WorldOutlinerTimerDelegate.IsBound() && GEditor )
    {
        GEditor->GetTimerManager()->ClearTimer( WorldOutlinerTimerHandle );
        WorldOutlinerTimerDelegate.Unbind();
    }
}

void UHoudiniAssetInput::InvalidateNodeIds()
{
    ConnectedAssetId = -1;
    for (auto& OutlinerInputMesh : InputOutlinerMeshArray)
    {
        OutlinerInputMesh.AssetId = -1;
    }
}

void UHoudiniAssetInput::DuplicateCurves(UHoudiniAssetInput * OriginalInput)
{
    if (!InputCurve || InputCurve->IsPendingKill() )
        return;

    if (!OriginalInput || OriginalInput->IsPendingKill())
        return;

    USceneComponent* RootComp = GetHoudiniAssetComponent();
    if( !RootComp || RootComp->IsPendingKill() )
        return;

    if ( !RootComp->GetOwner() || RootComp->GetOwner()->IsPendingKill() )
        return;

    // The previous call to DuplicateObject did not duplicate the curves properly
    // Both the original and duplicated Inputs now share the same InputCurve, so we 
    // need to create a proper copy of that curve

    // Keep the original pointer to the curve, as we need to duplicate its data
    UHoudiniSplineComponent* OriginalCurve = InputCurve;

    // Creates a new Curve
    InputCurve = NewObject< UHoudiniSplineComponent >(
        RootComp->GetOwner(), UHoudiniSplineComponent::StaticClass(),
        NAME_None, RF_Public | RF_Transactional);

    // Attach curve component to asset.
    InputCurve->AttachToComponent( RootComp, FAttachmentTransformRules::KeepRelativeTransform);
    InputCurve->RegisterComponent();
    InputCurve->SetVisibility(true);

    // The new curve need do know that it is connected to this Input
    InputCurve->SetHoudiniAssetInput(this);
    
    // The call to DuplicateObject has actually modified the original object's Input
    // so we need to fix that as well.
    OriginalCurve->SetHoudiniAssetInput(OriginalInput);

    // "Copy" the old curves parameters to the new one
    InputCurve->CopyFrom(OriginalCurve);

    // to force rebuild...
    bSwitchedToCurve = true;
}

void 
UHoudiniAssetInput::RemoveWorldOutlinerInput( int32 AtIndex )
{
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini World Outliner Input Change" ),
        PrimaryObject );
    Modify();

    bStaticMeshChanged = true;
    InputOutlinerMeshArray.RemoveAt( AtIndex );
    MarkChanged();
}

void
UHoudiniAssetInput::UpdateWorldOutlinerTransforms( FHoudiniAssetInputOutlinerMesh& OutlinerMesh )
{
    // Update to the new Transforms
    if ( OutlinerMesh.ActorPtr.IsValid() )
        OutlinerMesh.ActorTransform = OutlinerMesh.ActorPtr->GetTransform();

    if ( OutlinerMesh.StaticMeshComponent && !OutlinerMesh.StaticMeshComponent->IsPendingKill() )
    {
        OutlinerMesh.ComponentTransform = OutlinerMesh.StaticMeshComponent->GetComponentTransform();

        // Handle instances here
        UInstancedStaticMeshComponent * InstancedStaticMeshComponent = Cast< UInstancedStaticMeshComponent >(OutlinerMesh.StaticMeshComponent);
        if (InstancedStaticMeshComponent)
        {
            FTransform InstanceTransform;
            if (InstancedStaticMeshComponent->GetInstanceTransform(OutlinerMesh.InstanceIndex, InstanceTransform, true))
                OutlinerMesh.ComponentTransform = InstanceTransform;
        }
    }
    else if (OutlinerMesh.SplineComponent && !OutlinerMesh.SplineComponent->IsPendingKill() )
    {
        OutlinerMesh.ComponentTransform = OutlinerMesh.SplineComponent->GetComponentTransform();
    }

    OutlinerMesh.KeepWorldTransform = bKeepWorldTransform;
}

void
UHoudiniAssetInput::UpdateWorldOutlinerMaterials(FHoudiniAssetInputOutlinerMesh& OutlinerMesh)
{
    OutlinerMesh.MeshComponentsMaterials.Empty();
    if ( !OutlinerMesh.StaticMeshComponent || OutlinerMesh.StaticMeshComponent->IsPendingKill() )
        return;

    // Keep track of the materials used by the SMC
    for ( int32 n = 0; n < OutlinerMesh.StaticMeshComponent->GetNumMaterials(); n++ )
    {
        UMaterialInterface* mi = OutlinerMesh.StaticMeshComponent->GetMaterial( n );
        if ( !mi || mi->IsPendingKill() )
            OutlinerMesh.MeshComponentsMaterials.Add( FString() );
        else
            OutlinerMesh.MeshComponentsMaterials.Add( mi->GetPathName() );
    }
}

void UHoudiniAssetInput::OnAddToInputObjects()
{
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
        PrimaryObject );
    Modify();
    InputObjects.Add( nullptr );
    InputTransforms.Add( FTransform::Identity );
    TransformUIExpanded.Add( false );
    MarkChanged();
    bStaticMeshChanged = true;
    OnParamStateChanged();
}

void UHoudiniAssetInput::OnEmptyInputObjects()
{
    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Geometry Change" ),
        PrimaryObject );
    Modify();

    // Empty the arrays
    InputObjects.Empty();
    InputTransforms.Empty();
    TransformUIExpanded.Empty();

    // To avoid displaying 0 elements when there's one (empty), initialize the array
    InputObjects.Add( nullptr );
    InputTransforms.Add( FTransform::Identity );
    TransformUIExpanded.Add( false );
    MarkChanged();
    bStaticMeshChanged = true;
    OnParamStateChanged();
}

void UHoudiniAssetInput::OnAddToSkeletonInputObjects()
{
    FScopedTransaction Transaction(
        TEXT(HOUDINI_MODULE_RUNTIME),
        LOCTEXT("HoudiniInputChange", "Houdini Input Geometry Change"),
        PrimaryObject);
    Modify();
    SkeletonInputObjects.Add(nullptr);
    //InputTransforms.Add(FTransform::Identity);
    //TransformUIExpanded.Add(false);
    MarkChanged();
    bStaticMeshChanged = true;
    OnParamStateChanged();
}

void UHoudiniAssetInput::OnEmptySkeletonInputObjects()
{
    FScopedTransaction Transaction(
        TEXT(HOUDINI_MODULE_RUNTIME),
        LOCTEXT("HoudiniInputChange", "Houdini Input Geometry Change"),
        PrimaryObject);
    Modify();

    // Empty the arrays
    SkeletonInputObjects.Empty();
    //InputTransforms.Empty();
    //TransformUIExpanded.Empty();

    // To avoid displaying 0 elements when there's one (empty), initialize the array
    SkeletonInputObjects.Add(nullptr);
    //InputTransforms.Add(FTransform::Identity);
    //TransformUIExpanded.Add(false);
    MarkChanged();
    bStaticMeshChanged = true;
    OnParamStateChanged();
}

TOptional< float >
UHoudiniAssetInput::GetSplineResolutionValue() const
{
    if (UnrealSplineResolution != -1.0f)
        return UnrealSplineResolution;

    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if (HoudiniRuntimeSettings)
        return HoudiniRuntimeSettings->MarshallingSplineResolution;
    else
        return HAPI_UNREAL_PARAM_SPLINE_RESOLUTION_DEFAULT;
}


void
UHoudiniAssetInput::SetSplineResolutionValue(float InValue)
{
    if (InValue < 0)
        OnResetSplineResolutionClicked();
    else
        UnrealSplineResolution = FMath::Clamp< float >(InValue, 0.0f, 10000.0f);
}


bool
UHoudiniAssetInput::IsSplineResolutionEnabled() const
{
    if (ChoiceIndex != EHoudiniAssetInputType::WorldInput)
        return false;

    for (int32 n = 0; n < InputOutlinerMeshArray.Num(); n++)
    {
        if (InputOutlinerMeshArray[n].SplineComponent && !InputOutlinerMeshArray[n].SplineComponent->IsPendingKill() )
            return true;
    }

    return false;
}


FReply
UHoudiniAssetInput::OnResetSplineResolutionClicked()
{
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if (HoudiniRuntimeSettings)
        UnrealSplineResolution = HoudiniRuntimeSettings->MarshallingSplineResolution;
    else
        UnrealSplineResolution = HAPI_UNREAL_PARAM_SPLINE_RESOLUTION_DEFAULT;

    return FReply::Handled();
}

FText
UHoudiniAssetInput::GetCurrentSelectionText() const
{
    FText CurrentSelectionText;
    if ( ChoiceIndex == EHoudiniAssetInputType::AssetInput )
    {
        if ( InputAssetComponent && !InputAssetComponent->IsPendingKill() && InputAssetComponent->GetHoudiniAssetActorOwner() )
        {
            CurrentSelectionText = FText::FromString( InputAssetComponent->GetHoudiniAssetActorOwner()->GetName() );
        }
    }
    else if ( ChoiceIndex == EHoudiniAssetInputType::LandscapeInput )
    {
        if ( InputLandscapeProxy && !InputLandscapeProxy->IsPendingKill() )
        {
            CurrentSelectionText = FText::FromString( InputLandscapeProxy->GetName() );
        }
    }

    return CurrentSelectionText;
}

#endif

FArchive &
operator<<( FArchive & Ar, FHoudiniAssetInputOutlinerMesh & HoudiniAssetInputOutlinerMesh )
{
    HoudiniAssetInputOutlinerMesh.Serialize( Ar );
    return Ar;
}

FBox
UHoudiniAssetInput::GetInputBounds( const FVector& ParentLocation ) const
{
    FBox Bounds( ForceInitToZero );

    if ( IsCurveAssetConnected() && InputCurve && !InputCurve->IsPendingKill() )
    {
        // Houdini Curves are expressed locally so we need to add the parent component's transform
        TArray<FVector> CurvePositions;
        InputCurve->GetCurvePositions( CurvePositions );

        for ( int32 n = 0; n < CurvePositions.Num(); n++ )
            Bounds += ( ParentLocation + CurvePositions[ n ] );
    }

    if ( IsWorldInputAssetConnected() )
    {
        for (int32 n = 0; n < InputOutlinerMeshArray.Num(); n++)
        {
            if ( !InputOutlinerMeshArray[ n ].ActorPtr.IsValid() )
                continue;

            FVector Origin, Extent;
            InputOutlinerMeshArray[ n ].ActorPtr->GetActorBounds( false, Origin, Extent );

            Bounds += FBox::BuildAABB( Origin, Extent );
        }
    }

    if ( IsInputAssetConnected() && InputAssetComponent && !InputAssetComponent->IsPendingKill() )
    {
        Bounds += InputAssetComponent->GetAssetBounds();
    }

    if ( IsLandscapeAssetConnected() && InputLandscapeProxy && !InputLandscapeProxy->IsPendingKill() )
    {
        FVector Origin, Extent;
        InputLandscapeProxy->GetActorBounds( false, Origin, Extent );

        Bounds += FBox::BuildAABB( Origin, Extent );
    }

    return Bounds;
}

void UHoudiniAssetInput::SetDefaultInputTypeFromLabel()
{
#if WITH_EDITOR
    // Look if we can find an input type prefix in the input name
    FString inputName = GetParameterLabel();

    // We'll try to find these magic words to try to detect the default input type
    //FString geoPrefix = TEXT("geo");
    FString curvePrefix        = TEXT( "curve" );
    FString landscapePrefix    = TEXT( "landscape" );
    FString landscapePrefix2    = TEXT( "terrain" );
    FString landscapePrefix3    = TEXT( "heightfield" );
    FString worldPrefix        = TEXT( "world" );
    FString worldPrefix2    = TEXT( "outliner" );
    FString assetPrefix        = TEXT( "asset" );
    FString assetPrefix2    = TEXT( "hda" );

    // By default, geometry input is chosen.
    EHoudiniAssetInputType::Enum newInputType = EHoudiniAssetInputType::GeometryInput;

    if ( inputName.Contains( curvePrefix, ESearchCase::IgnoreCase ) )
        newInputType = EHoudiniAssetInputType::CurveInput;

    else if ( ( inputName.Contains( landscapePrefix, ESearchCase::IgnoreCase ) ) 
            || ( inputName.Contains( landscapePrefix2, ESearchCase::IgnoreCase ) )
            || ( inputName.Contains( landscapePrefix3, ESearchCase::IgnoreCase ) ) )
        newInputType = EHoudiniAssetInputType::LandscapeInput;

    else if ( ( inputName.Contains( worldPrefix, ESearchCase::IgnoreCase ) )
            || ( inputName.Contains( worldPrefix2, ESearchCase::IgnoreCase ) ) )
        newInputType = EHoudiniAssetInputType::WorldInput;

    else if ( ( inputName.Contains( assetPrefix, ESearchCase::IgnoreCase ) )
            || ( inputName.Contains( assetPrefix2, ESearchCase::IgnoreCase ) ) )
        newInputType = EHoudiniAssetInputType::AssetInput;

    if ( ChoiceIndex != newInputType )
        ChangeInputType( newInputType, false );

#else
    ChoiceIndex = EHoudiniAssetInputType::GeometryInput;
#endif
}

bool
UHoudiniAssetInput::HasChanged() const
{
    // Inputs should be considered changed after being loaded
    return bChanged || bLoadedParameter || ( !bInputAssetConnectedInHoudini && ChoiceIndex == EHoudiniAssetInputType::AssetInput );
}

#if WITH_EDITOR
bool
UHoudiniAssetInput::UpdateInputOulinerArray()
{
    bool NeedsUpdate = false;

    // See if some outliner inputs need to be updated, or removed
    // If an input's Actor is no longer valid, then when need to remove that input.
    // If an input's Components needs to be updated (are no longer valid), then all the components 
    // from the same actor needs to be updated as well.
    // This can happen for example when a blueprint actor is modified/serialized etc..
    TArray<AActor *> ActorToUpdateArray;
    for ( int32 n = InputOutlinerMeshArray.Num() - 1; n >= 0; n-- )
    {
        FHoudiniAssetInputOutlinerMesh& OutlinerInput = InputOutlinerMeshArray[ n ];
        if (OutlinerInput.ActorPtr.IsStale()) // || !OutlinerInput.ActorPtr.IsValid());
        {
            // If our ActorPtr is stale, try to find an updated version of it by pathname
            // This can happen when a blueprint is updated or recompiled...
            OutlinerInput.TryToUpdateActorPtrFromActorPathName();
        }
        
        if ( !OutlinerInput.ActorPtr.IsValid() )
        {
            // This input has an invalid actor: destroy it and its asset
            NeedsUpdate = true;

            // Destroy Houdini asset
            if ( FHoudiniEngineUtils::IsValidNodeId( OutlinerInput.AssetId ) )
            {
                FHoudiniEngineUtils::DestroyHoudiniAsset( OutlinerInput.AssetId );
                OutlinerInput.AssetId = -1;
            }

            // Remove that input
            InputOutlinerMeshArray.RemoveAt( n );
        }
        else
        {
            // This input has a valid actor, see if its component needs to be updated
            if ( !OutlinerInput.NeedsComponentUpdate() )
                continue;

            if ( ActorToUpdateArray.Contains( OutlinerInput.ActorPtr.Get() ) )
                continue;

            ActorToUpdateArray.Add( OutlinerInput.ActorPtr.Get() );

            NeedsUpdate = true;
        }
    }

    // Creates the inputs from the actors
    for ( auto & CurrentActor : ActorToUpdateArray )
        UpdateInputOulinerArrayFromActor( CurrentActor, true );

    return NeedsUpdate;
}

void
UHoudiniAssetInput::UpdateInputOulinerArrayFromActor( AActor * Actor, const bool& NeedCleanUp )
{
    if ( !Actor )
        return;

    // Don't allow selection of ourselves. Bad things happen if we do.
    if ( GetHoudiniAssetComponent() && ( Actor == GetHoudiniAssetComponent()->GetOwner() ) )
        return;

    // Destroy previous outliner inputs linked to this actor if needed
    if (NeedCleanUp)
    {
        for (int32 n = InputOutlinerMeshArray.Num() - 1; n >= 0; n--)
        {
            if (InputOutlinerMeshArray[n].ActorPtr.Get() != Actor)
                continue;

            // Remove from the input array.
            // No need to destroy the houdini nodes since this will be taken care of
            // when we update the input. (see bug 95415)
            InputOutlinerMeshArray.RemoveAt(n);
        }
    }

    // Looking for StaticMeshes
    TArray< UStaticMeshComponent* > AllSMComponents;
    Actor->GetComponents<UStaticMeshComponent>(AllSMComponents);
    for (UStaticMeshComponent * StaticMeshComponent : AllSMComponents)
    {
        if ( !StaticMeshComponent || StaticMeshComponent->ComponentHasTag( NAME_HoudiniNoUpload ) )
            continue;

        UStaticMesh * StaticMesh = StaticMeshComponent->GetStaticMesh();
        if ( !StaticMesh )
            continue;

        UInstancedStaticMeshComponent * InstancedStaticMeshComponent = Cast< UInstancedStaticMeshComponent >(StaticMeshComponent);
        if (InstancedStaticMeshComponent)
        {
            // Handle ISM separately
            // We'll create an Outliner Mesh for each of the instances..
            for (int32 n = 0; n < InstancedStaticMeshComponent->GetInstanceCount(); n++)
            {
                // Add the mesh to the array
                FHoudiniAssetInputOutlinerMesh OutlinerMesh;
                OutlinerMesh.ActorPtr = Actor;
                OutlinerMesh.ActorPathName = Actor->GetPathName();
                OutlinerMesh.StaticMeshComponent = InstancedStaticMeshComponent;
                OutlinerMesh.StaticMesh = StaticMesh;
                OutlinerMesh.SplineComponent = nullptr;
                OutlinerMesh.AssetId = -1;
                OutlinerMesh.InstanceIndex = n;

                UpdateWorldOutlinerTransforms(OutlinerMesh);
                UpdateWorldOutlinerMaterials(OutlinerMesh);

                InputOutlinerMeshArray.Add(OutlinerMesh);
            }
        }
        else
        {
            // Add the Static Mesh to the array
            FHoudiniAssetInputOutlinerMesh OutlinerMesh;
            OutlinerMesh.ActorPtr = Actor;
            OutlinerMesh.ActorPathName = Actor->GetPathName();
            OutlinerMesh.StaticMeshComponent = StaticMeshComponent;
            OutlinerMesh.StaticMesh = StaticMesh;
            OutlinerMesh.SplineComponent = nullptr;
            OutlinerMesh.AssetId = -1;

            UpdateWorldOutlinerTransforms(OutlinerMesh);
            UpdateWorldOutlinerMaterials(OutlinerMesh);

            InputOutlinerMeshArray.Add(OutlinerMesh);
        }
    }

    // Looking for Splines
    TArray< USplineComponent* > AllSplineComponents;
    Actor->GetComponents<USplineComponent>(AllSplineComponents);
    for (USplineComponent * SplineComponent : AllSplineComponents)
    {
        if ( !SplineComponent || SplineComponent->ComponentHasTag( NAME_HoudiniNoUpload ) )
            continue;

        // Add the spline to the array
        FHoudiniAssetInputOutlinerMesh OutlinerMesh;

        OutlinerMesh.ActorPtr = Actor;
        OutlinerMesh.ActorPathName = Actor->GetPathName();
        OutlinerMesh.StaticMeshComponent = nullptr;
        OutlinerMesh.StaticMesh = nullptr;
        OutlinerMesh.SplineComponent = SplineComponent;
        OutlinerMesh.AssetId = -1;

        UpdateWorldOutlinerTransforms( OutlinerMesh );

        // Updating the OutlinerMesh's struct infos
        OutlinerMesh.SplineResolution = UnrealSplineResolution;
        OutlinerMesh.SplineLength = SplineComponent->GetSplineLength();
        OutlinerMesh.NumberOfSplineControlPoints = SplineComponent->GetNumberOfSplinePoints();

        InputOutlinerMeshArray.Add( OutlinerMesh );
    }
}

FReply
UHoudiniAssetInput::OnExpandInputTransform( int32 AtIndex )
{
    if ( TransformUIExpanded.IsValidIndex( AtIndex ) )
    {
        TransformUIExpanded[ AtIndex ] = !TransformUIExpanded[ AtIndex ];
        OnParamStateChanged();
    }

    return FReply::Handled();
}

TOptional< float >
UHoudiniAssetInput::GetPositionX( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetLocation().X;
}

TOptional< float >
UHoudiniAssetInput::GetPositionY( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetLocation().Y;
}

TOptional< float >
UHoudiniAssetInput::GetPositionZ( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetLocation().Z;
}

void 
UHoudiniAssetInput::SetPositionX( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Position = InputTransforms[ AtIndex ].GetLocation();
    if ( Position.X == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Position.X = Value;
    InputTransforms[ AtIndex ].SetLocation( Position );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void 
UHoudiniAssetInput::SetPositionY( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Position = InputTransforms[ AtIndex ].GetLocation();
    if ( Position.Y == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Position.Y = Value;
    InputTransforms[ AtIndex ].SetLocation( Position );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void 
UHoudiniAssetInput::SetPositionZ( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Position = InputTransforms[ AtIndex ].GetLocation();
    if ( Position.Z == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Position.Z = Value;
    InputTransforms[ AtIndex ].SetLocation( Position );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

TOptional< float >
UHoudiniAssetInput::GetRotationRoll( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.Rotator().Roll;
}

TOptional< float >
UHoudiniAssetInput::GetRotationPitch( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.Rotator().Pitch;
}

TOptional< float >
UHoudiniAssetInput::GetRotationYaw( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.Rotator().Yaw;
}

void
UHoudiniAssetInput::SetRotationRoll( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FRotator Rotator = InputTransforms[ AtIndex ].Rotator();    
    if ( FMath::IsNearlyEqual( Rotator.Roll, Value, SMALL_NUMBER ) )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );
    
    Modify();

    Rotator.Roll = Value;
    InputTransforms[ AtIndex ].SetRotation( Rotator.Quaternion() );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void
UHoudiniAssetInput::SetRotationPitch( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FRotator Rotator = InputTransforms[ AtIndex ].Rotator();    
    if ( FMath::IsNearlyEqual( Rotator.Pitch, Value, SMALL_NUMBER ) )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this);

    Modify();

    Rotator.Pitch = Value;
    InputTransforms[ AtIndex ].SetRotation( Rotator.Quaternion() );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void
UHoudiniAssetInput::SetRotationYaw( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FRotator Rotator = InputTransforms[ AtIndex ].Rotator();    
    if ( FMath::IsNearlyEqual( Rotator.Yaw, Value, SMALL_NUMBER ) )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Rotator.Yaw = Value;
    InputTransforms[ AtIndex ].SetRotation( Rotator.Quaternion() );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

/** Returns the input's transform scale values **/
TOptional< float > 
UHoudiniAssetInput::GetScaleX( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetScale3D().X;
}

TOptional< float >
UHoudiniAssetInput::GetScaleY( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetScale3D().Y;
}

TOptional< float >
UHoudiniAssetInput::GetScaleZ( int32 AtIndex ) const
{
    FTransform transform = FTransform::Identity;
    if ( InputTransforms.IsValidIndex( AtIndex ) )
        transform = InputTransforms[ AtIndex ];

    return transform.GetScale3D().Z;
}

void 
UHoudiniAssetInput::SetScaleX( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Scale = InputTransforms[ AtIndex ].GetScale3D();
    if ( Scale.X == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Scale.X = Value;
    InputTransforms[ AtIndex ].SetScale3D( Scale );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void
UHoudiniAssetInput::SetScaleY( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Scale = InputTransforms[ AtIndex ].GetScale3D();
    if ( Scale.Y == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();
    
    Scale.Y = Value;
    InputTransforms[ AtIndex ].SetScale3D( Scale );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

void
UHoudiniAssetInput::SetScaleZ( float Value, int32 AtIndex )
{
    if ( !InputTransforms.IsValidIndex( AtIndex ) )
        return;

    FVector Scale = InputTransforms[ AtIndex ].GetScale3D();
    if ( Scale.Z == Value )
        return;

    FScopedTransaction Transaction(
        TEXT( HOUDINI_MODULE_RUNTIME ),
        LOCTEXT( "HoudiniInputChange", "Houdini Input Change" ),
        this );

    Modify();

    Scale.Z = Value;
    InputTransforms[ AtIndex ].SetScale3D( Scale );

    MarkChanged( true );
    bStaticMeshChanged = true;
}

bool
UHoudiniAssetInput::AddInputObject( UObject* ObjectToAdd )
{
    if ( !ObjectToAdd || ObjectToAdd->IsPendingKill() )
        return false;

    // Fix for the bug due to the first (but null) geometry input mesh
    int32 IndexToAdd = InputObjects.Num();
    if ( IndexToAdd == 1 && ( InputObjects[ 0 ] == nullptr ) )
        IndexToAdd = 0;

    if ( UStaticMesh* StaticMesh = Cast< UStaticMesh >( ObjectToAdd ) )
    {
        ForceSetInputObject( ObjectToAdd, IndexToAdd, true );
        return true;
    }
    else if ( AActor* WorldActor = Cast< AActor >( ObjectToAdd ) )
    {
        ForceSetInputObject( ObjectToAdd, IndexToAdd, true );
        return true;
    }

    //if ( InputAssetComponent )
    //    InputAssetComponent->bEditorPropertiesNeedFullUpdate = true;

    return false;
}

#endif

ALandscapeProxy*
UHoudiniAssetInput::GetLandscapeInput()
{
    if (!InputLandscapeProxy || InputLandscapeProxy->IsPendingKill())
        return nullptr;

    return InputLandscapeProxy->GetLandscapeActor();
}

bool
UHoudiniAssetInput::HasLODs() const
{
    switch ( ChoiceIndex )
    {
        case EHoudiniAssetInputType::GeometryInput:
        {
            if ( !InputObjects.Num() )
                return false;

            for ( int32 Idx = 0; Idx < InputObjects.Num(); Idx++ )
            {
                UStaticMesh* SM = Cast<UStaticMesh>( InputObjects[ Idx ] );
                if ( !SM || SM->IsPendingKill() )
                    continue;

                if ( SM->GetNumLODs() > 1 )
                    return true;
            }
        }
        break;

        case EHoudiniAssetInputType::WorldInput:
        {
            if ( !InputOutlinerMeshArray.Num() )
                return false;

            for ( int32 Idx = 0; Idx < InputOutlinerMeshArray.Num(); Idx++ )
            {
                UStaticMesh* SM = InputOutlinerMeshArray[ Idx ].StaticMesh;
                if ( !SM || SM->IsPendingKill() )
                    continue;

                if ( SM->GetNumLODs() > 1 )
                    return true;
            }
        }
        break;
    }

    return false;
}

bool
UHoudiniAssetInput::HasSockets() const
{
    switch ( ChoiceIndex )
    {
        case EHoudiniAssetInputType::GeometryInput:
        {
            if ( !InputObjects.Num() )
                return false;

            for ( int32 Idx = 0; Idx < InputObjects.Num(); Idx++ )
            {
                UStaticMesh* SM = Cast<UStaticMesh>( InputObjects[ Idx ] );
                if ( !SM )
                    continue;

                if ( SM->Sockets.Num() > 0 )
                    return true;
            }
        }
        break;

        case EHoudiniAssetInputType::WorldInput:
        {
            if ( !InputOutlinerMeshArray.Num() )
                return false;

            for ( int32 Idx = 0; Idx < InputOutlinerMeshArray.Num(); Idx++ )
            {
                UStaticMesh* SM = InputOutlinerMeshArray[ Idx ].StaticMesh;
                if ( !SM )
                    continue;

                if ( SM->Sockets.Num() > 1 )
                    return true;
            }
        }
        break;
    }

    return false;
}

bool
UHoudiniAssetInput::IsLandscapeUpdateNeededOnTransformChange() const
{
    if ( GetChoiceIndex() != EHoudiniAssetInputType::LandscapeInput )
        return false;

    if ( !bLandscapeAutoSelectComponent || !bLandscapeExportSelectionOnly )
        return false;

    return true;
}

bool
UHoudiniAssetInput::SetDefaultAssetFromHDA()
{
#if WITH_EDITOR
    // We just handle geo inputs
    if (EHoudiniAssetInputType::GeometryInput != ChoiceIndex)
        return false;

    // There is a default slot, don't add if slot is already filled 
    if (InputObjects.Num() > 1)
        return false;

    // Make sure we're linked to a valid parameter
    if (ParmId < 0)
        return false;

    // Get our ParmInfo
    HAPI_ParmInfo FoundParamInfo;
    FHoudiniApi::ParmInfo_Init(&FoundParamInfo);
    if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetParmInfo(
        FHoudiniEngine::Get().GetSession(),
        NodeId, ParmId, &FoundParamInfo) )
    {
        return false;
    }
    
    // Get our string value
    HAPI_StringHandle StringHandle;
    if (FHoudiniApi::GetParmStringValues(
        FHoudiniEngine::Get().GetSession(), NodeId, false,
        &StringHandle, FoundParamInfo.stringValuesIndex, 1) == HAPI_RESULT_SUCCESS)
    {
        FString OutValue;
        FHoudiniEngineString HoudiniEngineString(StringHandle);
        if (HoudiniEngineString.ToFString(OutValue))
        {
            // Set default object on the HDA instance - will override the parameter string
            // and apply the object input local-path thing for the HDA cook.
            if (OutValue.Len() > 0)
            {
                UObject * pObject = LoadObject<UObject>(nullptr, *OutValue);
                if (pObject)
                {
                    return AddInputObject(pObject);
                }
            }
        }
    }
    
#endif //WITH EDITOR
    return false;
}

#undef LOCTEXT_NAMESPACE