/*
* 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.
*
* Produced by:
*      Mykola Konyk
*      Side Effects Software Inc
*      123 Front Street West, Suite 1401
*      Toronto, Ontario
*      Canada   M5J 2M2
*      416-504-9876
*
*/

#include "HoudiniLandscapeUtils.h"

#include "HoudiniApi.h"
#include "HoudiniEngineRuntimePrivatePCH.h"
#include "HoudiniRuntimeSettings.h"
#include "HoudiniEngineUtils.h"
#include "HoudiniEngine.h"
#include "HoudiniEngineString.h"
#include "HoudiniCookHandler.h"
#include "HoudiniAsset.h"
#include "HoudiniAssetActor.h"
#include "HoudiniAssetComponent.h"

#include "LandscapeInfo.h"
#include "LandscapeComponent.h"
#include "LandscapeEdit.h"
#include "LandscapeLayerInfoObject.h"
#include "LandscapeStreamingProxy.h"
#include "LightMap.h"
#include "Engine/MapBuildDataRegistry.h"

#if WITH_EDITOR
    #include "FileHelpers.h"
    #include "EngineUtils.h"
    #include "LandscapeEditorModule.h"
    #include "LandscapeFileFormatInterface.h"
#endif

void
FHoudiniLandscapeUtils::GetHeightfieldsInArray(
    const TArray< FHoudiniGeoPartObject >& InArray,
    TArray< const FHoudiniGeoPartObject* >& FoundHeightfields )
{
    FoundHeightfields.Empty();

    // First, we need to extract proper height data from FoundVolumes
    for ( TArray< FHoudiniGeoPartObject >::TConstIterator Iter( InArray ); Iter; ++Iter )
    {
        const FHoudiniGeoPartObject & HoudiniGeoPartObject = *Iter;
        if ( !HoudiniGeoPartObject.IsVolume() )
            continue;

        // Retrieve node id from geo part.
        //HAPI_NodeId NodeId = HoudiniGeoPartObject.HapiGeoGetNodeId( AssetId );
        HAPI_NodeId NodeId = HoudiniGeoPartObject.HapiGeoGetNodeId();
        if ( NodeId == -1 )
            continue;

        // Retrieve the VolumeInfo
        HAPI_VolumeInfo CurrentVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentVolumeInfo);
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeInfo(
            FHoudiniEngine::Get().GetSession(),
            NodeId, HoudiniGeoPartObject.PartId,
            &CurrentVolumeInfo ) )
            continue;

        // We're only interested in heightfields
        FString CurrentVolumeName;
        FHoudiniEngineString( CurrentVolumeInfo.nameSH ).ToFString( CurrentVolumeName );
        if ( !CurrentVolumeName.Contains( "height" ) )
            continue;

        // We're only handling single values for now
        if ( CurrentVolumeInfo.tupleSize != 1 )
            continue;

        // Terrains always have a ZSize of 1.
        if ( CurrentVolumeInfo.zLength != 1 )
            continue;

        // Values should be float
        if ( CurrentVolumeInfo.storage != HAPI_STORAGETYPE_FLOAT )
            continue;

        FoundHeightfields.Add( &HoudiniGeoPartObject );
    }
}

void
FHoudiniLandscapeUtils::GetHeightfieldsLayersInArray(
    const TArray< FHoudiniGeoPartObject >& InArray,
    const FHoudiniGeoPartObject& Heightfield,
    TArray< const FHoudiniGeoPartObject* >& FoundLayers )
{
    FoundLayers.Empty();

    // We need the parent heightfield's node ID and tile attribute
    HAPI_NodeId HeightFieldNodeId = Heightfield.HapiGeoGetNodeId();

    // We need the tile attribute if the height has it
    bool bParentHeightfieldHasTile = false;
    int32 HeightFieldTile = -1;
    {
        HAPI_AttributeInfo AttribInfoTile;
        FHoudiniApi::AttributeInfo_Init(&AttribInfoTile);
        TArray< int32 > TileValues;

        FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
            Heightfield, "tile",
            AttribInfoTile, TileValues );

        if ( AttribInfoTile.exists && AttribInfoTile.owner == HAPI_ATTROWNER_PRIM && TileValues.Num() > 0 )
        {
            HeightFieldTile = TileValues[ 0 ];
            bParentHeightfieldHasTile = true;
        }
    }

    // Look for all the layers/masks corresponding to the current heightfield
    for ( TArray< FHoudiniGeoPartObject >::TConstIterator IterLayers( InArray ); IterLayers; ++IterLayers )
    {
        const FHoudiniGeoPartObject & HoudiniGeoPartObject = *IterLayers;
        if ( !HoudiniGeoPartObject.IsVolume() )
            continue;

        // Retrieve node id from geo part.
        HAPI_NodeId NodeId = HoudiniGeoPartObject.HapiGeoGetNodeId();
        if ( NodeId == -1 )
            continue;

        // It needs to be from the same node as the parent heightfield...
        if ( NodeId != HeightFieldNodeId )
            continue;

        // If the parent had a tile info, retrieve the tile attribute for the current layer
        if ( bParentHeightfieldHasTile )
        {
            int32 CurrentTile = -1;

            HAPI_AttributeInfo AttribInfoTile;
            FHoudiniApi::AttributeInfo_Init(&AttribInfoTile);
            TArray<int32> TileValues;
            FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
                HoudiniGeoPartObject, "tile",
                AttribInfoTile, TileValues );

            if ( AttribInfoTile.exists && AttribInfoTile.owner == HAPI_ATTROWNER_PRIM && TileValues.Num() > 0 )
            {
                CurrentTile = TileValues[ 0 ];
            }

            // Does this layer come from the same tile as the height?
            if ( ( CurrentTile != HeightFieldTile ) || ( CurrentTile == -1 ) )
                continue;
        }

        // Retrieve the VolumeInfo
        HAPI_VolumeInfo CurrentVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentVolumeInfo);
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeInfo(
            FHoudiniEngine::Get().GetSession(),
            NodeId, HoudiniGeoPartObject.PartId,
            &CurrentVolumeInfo ) )
            continue;

        // We're interesting in anything but height data
        FString CurrentVolumeName;
        FHoudiniEngineString( CurrentVolumeInfo.nameSH ).ToFString( CurrentVolumeName );
        if ( CurrentVolumeName.Contains( "height" ) )
            continue;

        // We're only handling single values for now
        if ( CurrentVolumeInfo.tupleSize != 1 )
            continue;

        // Terrains always have a ZSize of 1.
        if ( CurrentVolumeInfo.zLength != 1 )
            continue;

        // Values should be float
        if ( CurrentVolumeInfo.storage != HAPI_STORAGETYPE_FLOAT )
            continue;

        FoundLayers.Add( &HoudiniGeoPartObject );
    }
}

void
FHoudiniLandscapeUtils::CalcHeightfieldsArrayGlobalZMinZMax(
    const TArray< FHoudiniGeoPartObject > & InHeightfieldArray,
    TMap<FString, float>& GlobalMinimums,
    TMap<FString, float>& GlobalMaximums )
{
    GlobalMinimums.Empty();
    GlobalMaximums.Empty();

    for (TArray< FHoudiniGeoPartObject >::TConstIterator CurrentHeightfield(InHeightfieldArray); CurrentHeightfield; ++CurrentHeightfield)
    {
        // Get the current Heightfield GeoPartObject
        if (!CurrentHeightfield)
            continue;

        if (!CurrentHeightfield->IsVolume())
            continue;

        // Retrieve node id from geo part.
        HAPI_NodeId NodeId = CurrentHeightfield->HapiGeoGetNodeId();
        if (NodeId == -1)
            continue;

        // Retrieve the VolumeInfo
        HAPI_VolumeInfo CurrentVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentVolumeInfo);
        if (HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeInfo(
            FHoudiniEngine::Get().GetSession(),
            NodeId, CurrentHeightfield->PartId,
            &CurrentVolumeInfo))
            continue;

        // Unreal's Z values are Y in Houdini
        float ymin, ymax;
        if (HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeBounds(FHoudiniEngine::Get().GetSession(),
            NodeId, CurrentHeightfield->PartId,
            nullptr, &ymin, nullptr,
            nullptr, &ymax, nullptr,
            nullptr, nullptr, nullptr))
            continue;

        // Retrieve the volume name.
        FString VolumeName;
        FHoudiniEngineString HoudiniEngineStringPartName(CurrentVolumeInfo.nameSH);
        HoudiniEngineStringPartName.ToFString(VolumeName);

        // Read the global min value for this volume
        if ( !GlobalMinimums.Contains(VolumeName) )
        {
            GlobalMinimums.Add(VolumeName, ymin);
        }
        else
        {
            // Update the min if necessary
            if ( ymin < GlobalMinimums[VolumeName] )
                GlobalMinimums[VolumeName] = ymin;
        }

        // Read the global max value for this volume
        float fCurrentVolumeGlobalMax = -MAX_FLT;
        if (!GlobalMaximums.Contains(VolumeName))
        {
            GlobalMaximums.Add(VolumeName, ymax);
        }
        else
        {
            // Update the max if necessary
            if (ymax > GlobalMaximums[VolumeName])
                GlobalMaximums[VolumeName] = ymax;
        }
    }
}

void
FHoudiniLandscapeUtils::CalcHeightfieldsArrayGlobalZMinZMax(
    const TArray< const FHoudiniGeoPartObject* > & InHeightfieldArray,
    float& fGlobalMin, float& fGlobalMax )
{
    // Initialize the global values
    fGlobalMin = MAX_FLT;
    fGlobalMax = -MAX_FLT;

    for ( TArray< const FHoudiniGeoPartObject* >::TConstIterator IterHeighfields( InHeightfieldArray ); IterHeighfields; ++IterHeighfields )
    {
        // Get the current Heightfield GeoPartObject
        const FHoudiniGeoPartObject* CurrentHeightfield = *IterHeighfields;
        if ( !CurrentHeightfield )
            continue;

        if ( !CurrentHeightfield->IsVolume() )
            continue;

        // Retrieve node id from geo part.
        HAPI_NodeId NodeId = CurrentHeightfield->HapiGeoGetNodeId();
        if ( NodeId == -1 )
            continue;

        // Retrieve the VolumeInfo
        HAPI_VolumeInfo CurrentVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentVolumeInfo);
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeInfo(
            FHoudiniEngine::Get().GetSession(),
            NodeId, CurrentHeightfield->PartId,
            &CurrentVolumeInfo ) )
            continue;

        // Unreal's Z values are Y in Houdini
        float ymin, ymax;
        if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetVolumeBounds( FHoudiniEngine::Get().GetSession(),
            NodeId, CurrentHeightfield->PartId,
            nullptr, &ymin, nullptr,
            nullptr, &ymax, nullptr,
            nullptr, nullptr, nullptr ) )
            continue;

        if ( ymin < fGlobalMin )
            fGlobalMin = ymin;

        if ( ymax > fGlobalMax )
            fGlobalMax = ymax;
    }

    // Set Min/Max to zero if we couldn't set the values properly
    if ( fGlobalMin > fGlobalMax )
    {
        fGlobalMin = 0.0f;
        fGlobalMax = 0.0f;
    }
}

bool FHoudiniLandscapeUtils::GetHeightfieldData(
    const FHoudiniGeoPartObject& Heightfield,
    TArray<float>& FloatValues,
    HAPI_VolumeInfo& VolumeInfo,
    float& FloatMin, float& FloatMax )
{
    FloatValues.Empty();
    FloatMin = 0.0f;
    FloatMax = 0.0f;

    if ( !Heightfield.IsVolume() )
        return false;

    // Retrieve node id from geo part.
    HAPI_NodeId NodeId = Heightfield.HapiGeoGetNodeId();
    if ( NodeId == -1 )
        return false;

    // Retrieve the VolumeInfo
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::GetVolumeInfo(
        FHoudiniEngine::Get().GetSession(),
        NodeId, Heightfield.PartId,
        &VolumeInfo ), false );

    // We're only handling single values for now
    if ( VolumeInfo.tupleSize != 1 )
        return false;

    // Terrains always have a ZSize of 1.
    if ( VolumeInfo.zLength != 1 )
        return false;

    // Values must be float
    if ( VolumeInfo.storage != HAPI_STORAGETYPE_FLOAT )
        return false;

    if ( ( VolumeInfo.xLength < 2 ) || ( VolumeInfo.yLength < 2 ) )
        return false;

    int32 SizeInPoints = VolumeInfo.xLength *  VolumeInfo.yLength;
    int32 TotalSize = SizeInPoints * VolumeInfo.tupleSize;

    //--------------------------------------------------------------------------------------------------
    // 1. Reading and converting the Height values from HAPI
    //--------------------------------------------------------------------------------------------------    
    FloatValues.SetNumUninitialized( TotalSize );

    // Get all the heightfield data
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::GetHeightFieldData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, Heightfield.PartId,
        FloatValues.GetData(),
        0, SizeInPoints ), false );

    // We will need the min and max value for the conversion to uint16
    FloatMin = FloatValues[0];
    FloatMax = FloatMin;
    for ( int32 n = 0; n < FloatValues.Num(); n++ )
    {
        if ( FloatValues[ n ] > FloatMax )
            FloatMax = FloatValues[ n ];
        else if ( FloatValues[ n ] < FloatMin )
            FloatMin = FloatValues[ n ];
    }

    return true;
}

bool
FHoudiniLandscapeUtils::ConvertHeightfieldDataToLandscapeData(
    const TArray< float >& HeightfieldFloatValues,
    const HAPI_VolumeInfo& HeightfieldVolumeInfo,
    const int32& FinalXSize, const int32& FinalYSize,
    float FloatMin, float FloatMax,
    TArray< uint16 >& IntHeightData,
    FTransform& LandscapeTransform,
    const bool& NoResize )
{
    IntHeightData.Empty();
    LandscapeTransform.SetIdentity();
    // HF sizes needs an X/Y swap
    int32 HoudiniXSize = HeightfieldVolumeInfo.yLength;
    int32 HoudiniYSize = HeightfieldVolumeInfo.xLength;
    int32 SizeInPoints = HoudiniXSize * HoudiniYSize;
    if ( ( HoudiniXSize < 2 ) || ( HoudiniYSize < 2 ) )
        return false;

    // Test for potential special cases...
    // Just print a warning for now
    if ( HeightfieldVolumeInfo.minX != 0 )
        HOUDINI_LOG_WARNING( TEXT( "Converting Landscape: heightfield's min X is not zero." ) );

    if ( HeightfieldVolumeInfo.minY != 0 )
        HOUDINI_LOG_WARNING( TEXT( "Converting Landscape: heightfield's min Y is not zero." ) );

    //--------------------------------------------------------------------------------------------------
    // 1. Convert values to uint16 using doubles to get the maximum precision during the conversion
    //--------------------------------------------------------------------------------------------------

    // Extract the HF's current transform
    FTransform CurrentVolumeTransform;
    {
        HAPI_Transform HapiTransform = HeightfieldVolumeInfo.transform;
        FQuat ObjectRotation(
            HapiTransform.rotationQuaternion[0], HapiTransform.rotationQuaternion[1],
            HapiTransform.rotationQuaternion[2], -HapiTransform.rotationQuaternion[3]);
        Swap(ObjectRotation.Y, ObjectRotation.Z);

        FVector ObjectTranslation(HapiTransform.position[0], HapiTransform.position[1], HapiTransform.position[2]);
        ObjectTranslation *= 100.0f;
        Swap(ObjectTranslation[2], ObjectTranslation[1]);

        FVector ObjectScale3D(HapiTransform.scale[0], HapiTransform.scale[1], HapiTransform.scale[2]);

        CurrentVolumeTransform.SetComponents(ObjectRotation, ObjectTranslation, ObjectScale3D);
    }

    // The ZRange in Houdini (in m)
    double MeterZRange = (double) ( FloatMax - FloatMin );

    // The corresponding unreal digit range (as unreal uses uint16, max is 65535)
    // We may want to not use the full range in order to be able to sculpt the landscape past the min/max values after.
    const double dUINT16_MAX = (double)UINT16_MAX;
    double DigitZRange = 49152.0;
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if ( HoudiniRuntimeSettings && HoudiniRuntimeSettings->MarshallingLandscapesUseFullResolution )
        DigitZRange = dUINT16_MAX - 1.0;

    // If we  are not using the full range, we need to center the digit values so the terrain can be edited up and down
    double DigitCenterOffset = FMath::FloorToDouble( ( dUINT16_MAX - DigitZRange ) / 2.0 );

    // The factor used to convert from Houdini's ZRange to the desired digit range
    double ZSpacing = ( MeterZRange != 0.0 ) ? ( DigitZRange / MeterZRange ) : 0.0;

    // Changes these values if the user wants to loose a lot of precision
    // just to keep the same transform as the landscape input
    bool bUseDefaultUE4Scaling = false;
    if (HoudiniRuntimeSettings && HoudiniRuntimeSettings->MarshallingLandscapesUseDefaultUnrealScaling)
        bUseDefaultUE4Scaling = HoudiniRuntimeSettings->MarshallingLandscapesUseDefaultUnrealScaling;

    if ( bUseDefaultUE4Scaling )
    {
        //Check that our values are compatible with UE4's default scale values
        if (FloatMin < -256.0f || FloatMin > 256.0f || FloatMax < -256.0f || FloatMax > 256.0f)
        {
            // Warn the user that the landscape conversion will have issues 
            // invite him to change that setting
            HOUDINI_LOG_WARNING(
                TEXT("The heightfield's min and max height values are too large for being used with the \"Use Default UE4 scaling\" option.\n \
                      The generated Heightfield will likely be incorrectly converted to landscape unless you disable that option in the project settings and recook the asset."));
        }

        DigitZRange = dUINT16_MAX - 1.0;
        DigitCenterOffset = 0;

        // Default unreal landscape scaling is -256m:256m at Scale = 100
        // We need to apply the scale back to
        FloatMin = -256.0f * CurrentVolumeTransform.GetScale3D().Z * 2.0f;
        FloatMax = 256.0f * CurrentVolumeTransform.GetScale3D().Z * 2.0f;
        MeterZRange = (double)(FloatMax - FloatMin);

        ZSpacing = ((double)DigitZRange) / MeterZRange;
    }

    // Converting the data from Houdini to Unreal
    // For correct orientation in unreal, the point matrix has to be transposed.
    IntHeightData.SetNumUninitialized( SizeInPoints );

    int32 nUnreal = 0;
    for (int32 nY = 0; nY < HoudiniYSize; nY++)
    {
        for (int32 nX = 0; nX < HoudiniXSize; nX++)
        {
            // Copying values X then Y in Unreal but reading them Y then X in Houdini due to swapped X/Y
            int32 nHoudini = nY + nX * HoudiniYSize;

            // Get the double values in [0 - ZRange]
            double DoubleValue = (double)HeightfieldFloatValues[nHoudini] - (double)FloatMin;

            // Then convert it to [0 - DesiredRange] and center it 
            DoubleValue = DoubleValue * ZSpacing + DigitCenterOffset;
            IntHeightData[nUnreal++] = FMath::RoundToInt(DoubleValue);
        }
    }

    //--------------------------------------------------------------------------------------------------
    // 2. Resample / Pad the int data so that if fits unreal size requirements
    //--------------------------------------------------------------------------------------------------

    // UE has specific size requirements for landscape,
    // so we might need to pad/resample the heightfield data
    FVector LandscapeResizeFactor = FVector::OneVector;
    FVector LandscapePositionOffsetInPixels = FVector::ZeroVector;
    if (!NoResize)
    {
        // Try to resize the data
        if ( !FHoudiniLandscapeUtils::ResizeHeightDataForLandscape(
            IntHeightData,
            HoudiniXSize, HoudiniYSize, FinalXSize, FinalYSize,
            LandscapeResizeFactor, LandscapePositionOffsetInPixels))
            return false;
    }

    //--------------------------------------------------------------------------------------------------
    // 3. Calculating the proper transform for the landscape to be sized and positionned properly
    //--------------------------------------------------------------------------------------------------

    // Scale:
    // Calculating the equivalent scale to match Houdini's Terrain Size in Unreal
    FVector LandscapeScale;

    // Unreal has a X/Y resolution of 1m per point while Houdini is dependant on the heighfield's grid spacing
    LandscapeScale.X = CurrentVolumeTransform.GetScale3D().X * 2.0f;
    LandscapeScale.Y = CurrentVolumeTransform.GetScale3D().Y * 2.0f;

    // Calculating the Z Scale so that the Z values in Unreal are the same as in Houdini
    // Unreal has a default Z range is 512m for a scale of a 100%
    LandscapeScale.Z = (float)( (double)( dUINT16_MAX / DigitZRange ) * MeterZRange / 512.0 );
    if ( bUseDefaultUE4Scaling )
        LandscapeScale.Z = CurrentVolumeTransform.GetScale3D().Z * 2.0f;
    LandscapeScale *= 100.f;

    // If the data was resized and not expanded, we need to modify the landscape's scale
    LandscapeScale *= LandscapeResizeFactor;

    // Don't allow a zero scale, as this results in divide by 0 operations in FMatrix::InverseFast in the landscape component.
    if (FMath::IsNearlyZero(LandscapeScale.Z))
        LandscapeScale.Z = 1.0f;

    // We'll use the position from Houdini, but we will need to offset the Z Position to center the 
    // values properly as the data has been offset by the conversion to uint16
    FVector LandscapePosition = CurrentVolumeTransform.GetLocation();
    //LandscapePosition.Z = 0.0f;

    // We need to calculate the position offset so that Houdini and Unreal have the same Zero position
    // In Unreal, zero has a height value of 32768.
    // These values are then divided by 128 internally, and then multiplied by the Landscape's Z scale
    // ( DIGIT - 32768 ) / 128 * ZScale = ZOffset

    // We need the Digit (Unreal) value of Houdini's zero for the scale calculation
    // ( float and int32 are used for this because 0 might be out of the landscape Z range!
    // when using the full range, this would cause an overflow for a uint16!! )
    float HoudiniZeroValueInDigit = (float)FMath::RoundToInt((0.0 - (double)FloatMin) * ZSpacing + DigitCenterOffset);
    float ZOffset = -( HoudiniZeroValueInDigit - 32768.0f ) / 128.0f * LandscapeScale.Z;

    LandscapePosition.Z += ZOffset;

    // If we have padded the data when resizing the landscape, we need to offset the position because of
    // the added values on the topLeft Corner of the Landscape
    if ( LandscapePositionOffsetInPixels != FVector::ZeroVector )
    {
        FVector LandscapeOffset = LandscapePositionOffsetInPixels * LandscapeScale;
        LandscapeOffset.Z = 0.0f;

        LandscapePosition += LandscapeOffset;
    }

    // Landscape rotation
    //FRotator LandscapeRotation( 0.0, -90.0, 0.0 );
    //Landscape->SetActorRelativeRotation( LandscapeRotation );

    // We can now set the Landscape position
    LandscapeTransform.SetLocation( LandscapePosition );
    LandscapeTransform.SetScale3D( LandscapeScale );

    return true;
}

bool FHoudiniLandscapeUtils::ConvertHeightfieldLayerToLandscapeLayer(
    const TArray<float>& FloatLayerData,
    const int32& HoudiniXSize, const int32& HoudiniYSize,
    const float& LayerMin, const float& LayerMax,
    const int32& LandscapeXSize, const int32& LandscapeYSize,
    TArray<uint8>& LayerData, const bool& NoResize )
{
    // Convert the float data to uint8
    LayerData.SetNumUninitialized( HoudiniXSize * HoudiniYSize );

    // Calculating the factor used to convert from Houdini's ZRange to [0 255]
    double LayerZRange = ( LayerMax - LayerMin );
    double LayerZSpacing = ( LayerZRange != 0.0 ) ? ( 255.0 / (double)( LayerZRange ) ) : 0.0;

    int32 nUnrealIndex = 0;
    for ( int32 nY = 0; nY < HoudiniYSize; nY++ )
    {
        for ( int32 nX = 0; nX < HoudiniXSize; nX++ )
        {
            // Copying values X then Y in Unreal but reading them Y then X in Houdini due to swapped X/Y
            int32 nHoudini = nY + nX * HoudiniYSize;

            // Get the double values in [0 - ZRange]
            double DoubleValue = (double)FMath::Clamp(FloatLayerData[ nHoudini ], LayerMin, LayerMax) - (double)LayerMin;

            // Then convert it to [0 - 255]
            DoubleValue *= LayerZSpacing;

            LayerData[ nUnrealIndex++ ] = FMath::RoundToInt( DoubleValue );
        }
    }

    // Finally, resize the data to fit with the new landscape size if needed
    if ( NoResize )
        return true;

    return FHoudiniLandscapeUtils::ResizeLayerDataForLandscape(
        LayerData, HoudiniXSize, HoudiniYSize,
        LandscapeXSize, LandscapeYSize );
}

bool
FHoudiniLandscapeUtils::GetNonWeightBlendedLayerNames( const FHoudiniGeoPartObject& HeightfieldGeoPartObject, TArray<FString>& NonWeightBlendedLayerNames )
{
    // See if we can find the NonWeightBlendedLayer prim attribute on the heightfield
    HAPI_NodeId HeightfieldNodeId = HeightfieldGeoPartObject.HapiGeoGetNodeId();

    HAPI_PartInfo PartInfo;
    FHoudiniApi::PartInfo_Init(&PartInfo);
    if ( !HeightfieldGeoPartObject.HapiPartGetInfo( PartInfo ) )
        return false;

    HAPI_PartId PartId = HeightfieldGeoPartObject.GetPartId();

    // Get All attribute names for that part
    int32 nAttribCount = PartInfo.attributeCounts[ HAPI_ATTROWNER_PRIM ];

    TArray<HAPI_StringHandle> AttribNameSHArray;
    AttribNameSHArray.SetNum( nAttribCount );

    if ( HAPI_RESULT_SUCCESS != FHoudiniApi::GetAttributeNames(
        FHoudiniEngine::Get().GetSession(),
        HeightfieldNodeId, PartInfo.id, HAPI_ATTROWNER_PRIM,
        AttribNameSHArray.GetData(), nAttribCount ) )
        return false;

    // Looking for all the attributes that starts with unreal_landscape_layer_nonweightblended
    for ( int32 Idx = 0; Idx < AttribNameSHArray.Num(); ++Idx )
    {
        FString HapiString = TEXT("");
        FHoudiniEngineString HoudiniEngineString( AttribNameSHArray[ Idx ] );
        HoudiniEngineString.ToFString( HapiString );

        if ( !HapiString.StartsWith( "unreal_landscape_layer_nonweightblended", ESearchCase::IgnoreCase ) )
            continue;

        // Get the Attribute Info
        HAPI_AttributeInfo AttribInfo;
        FHoudiniApi::AttributeInfo_Init(&AttribInfo);
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::GetAttributeInfo(
            FHoudiniEngine::Get().GetSession(),
            HeightfieldNodeId, PartId, TCHAR_TO_UTF8( *HapiString ),
            HAPI_ATTROWNER_PRIM, &AttribInfo ), false );

        if ( AttribInfo.storage != HAPI_STORAGETYPE_STRING )
            break;

        // Initialize a string handle array
        TArray< HAPI_StringHandle > HapiSHArray;
        HapiSHArray.SetNumZeroed( AttribInfo.count * AttribInfo.tupleSize );

        // Get the string handle(s)
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::GetAttributeStringData(
            FHoudiniEngine::Get().GetSession(),
            HeightfieldNodeId, PartId, TCHAR_TO_UTF8( *HapiString ), &AttribInfo,
            HapiSHArray.GetData(), 0, AttribInfo.count ), false );

        // Convert them to FString
        for ( int32 IdxSH = 0; IdxSH < HapiSHArray.Num(); IdxSH++ )
        {
            FString CurrentString;
            FHoudiniEngineString HEngineString( HapiSHArray[ IdxSH ] );
            HEngineString.ToFString( CurrentString );

            TArray<FString> Tokens;
            CurrentString.ParseIntoArray( Tokens, TEXT(" "), true );

            for( int32 n = 0; n < Tokens.Num(); n++ )
                NonWeightBlendedLayerNames.Add( Tokens[ n ] );
        }

        // We found the attribute, exit
        break;
    }

    return true;
}

//-------------------------------------------------------------------------------------------------------------------
// From LandscapeEditorUtils.h
//
//    Helpers function for FHoudiniEngineUtils::ResizeHeightDataForLandscape
//-------------------------------------------------------------------------------------------------------------------
template<typename T>
void ExpandData( T* OutData, const T* InData,
    int32 OldMinX, int32 OldMinY, int32 OldMaxX, int32 OldMaxY,
    int32 NewMinX, int32 NewMinY, int32 NewMaxX, int32 NewMaxY )
{
    const int32 OldWidth = OldMaxX - OldMinX + 1;
    const int32 OldHeight = OldMaxY - OldMinY + 1;
    const int32 NewWidth = NewMaxX - NewMinX + 1;
    const int32 NewHeight = NewMaxY - NewMinY + 1;
    const int32 OffsetX = NewMinX - OldMinX;
    const int32 OffsetY = NewMinY - OldMinY;

    for ( int32 Y = 0; Y < NewHeight; ++Y )
    {
        const int32 OldY = FMath::Clamp<int32>( Y + OffsetY, 0, OldHeight - 1 );

        // Pad anything to the left
        const T PadLeft = InData[ OldY * OldWidth + 0 ];
        for ( int32 X = 0; X < -OffsetX; ++X )
        {
            OutData[ Y * NewWidth + X ] = PadLeft;
        }

        // Copy one row of the old data
        {
            const int32 X = FMath::Max( 0, -OffsetX );
            const int32 OldX = FMath::Clamp<int32>( X + OffsetX, 0, OldWidth - 1 );
            FMemory::Memcpy( &OutData[ Y * NewWidth + X ], &InData[ OldY * OldWidth + OldX ], FMath::Min<int32>( OldWidth, NewWidth ) * sizeof( T ) );
        }

        const T PadRight = InData[ OldY * OldWidth + OldWidth - 1 ];
        for ( int32 X = -OffsetX + OldWidth; X < NewWidth; ++X )
        {
            OutData[ Y * NewWidth + X ] = PadRight;
        }
    }
}

template<typename T>
TArray<T> ExpandData(const TArray<T>& Data,
    int32 OldMinX, int32 OldMinY, int32 OldMaxX, int32 OldMaxY,
    int32 NewMinX, int32 NewMinY, int32 NewMaxX, int32 NewMaxY,
    int32* PadOffsetX = nullptr, int32* PadOffsetY = nullptr )
{
    const int32 NewWidth = NewMaxX - NewMinX + 1;
    const int32 NewHeight = NewMaxY - NewMinY + 1;

    TArray<T> Result;
    Result.Empty( NewWidth * NewHeight );
    Result.AddUninitialized( NewWidth * NewHeight );

    ExpandData( Result.GetData(), Data.GetData(),
        OldMinX, OldMinY, OldMaxX, OldMaxY,
        NewMinX, NewMinY, NewMaxX, NewMaxY );

    // Return the padding so we can offset the terrain position after
    if ( PadOffsetX )
        *PadOffsetX = NewMinX;

    if ( PadOffsetY )
        *PadOffsetY = NewMinY;

    return Result;
}

template<typename T>
TArray<T> ResampleData( const TArray<T>& Data, int32 OldWidth, int32 OldHeight, int32 NewWidth, int32 NewHeight )
{
    TArray<T> Result;
    Result.Empty( NewWidth * NewHeight );
    Result.AddUninitialized( NewWidth * NewHeight );

    const float XScale = (float)( OldWidth - 1 ) / ( NewWidth - 1 );
    const float YScale = (float)( OldHeight - 1 ) / ( NewHeight - 1 );
    for ( int32 Y = 0; Y < NewHeight; ++Y )
    {
        for ( int32 X = 0; X < NewWidth; ++X )
        {
            const float OldY = Y * YScale;
            const float OldX = X * XScale;
            const int32 X0 = FMath::FloorToInt( OldX );
            const int32 X1 = FMath::Min( FMath::FloorToInt( OldX ) + 1, OldWidth - 1 );
            const int32 Y0 = FMath::FloorToInt( OldY );
            const int32 Y1 = FMath::Min( FMath::FloorToInt( OldY ) + 1, OldHeight - 1 );
            const T& Original00 = Data[ Y0 * OldWidth + X0 ];
            const T& Original10 = Data[ Y0 * OldWidth + X1 ];
            const T& Original01 = Data[ Y1 * OldWidth + X0 ];
            const T& Original11 = Data[ Y1 * OldWidth + X1 ];
            Result[ Y * NewWidth + X ] = FMath::BiLerp( Original00, Original10, Original01, Original11, FMath::Fractional( OldX ), FMath::Fractional( OldY ) );
        }
    }

    return Result;
}

//-------------------------------------------------------------------------------------------------------------------
bool
FHoudiniLandscapeUtils::CalcLandscapeSizeFromHeightfieldSize(
    const int32& SizeX, const int32& SizeY,
    int32& NewSizeX, int32& NewSizeY,
    int32& NumberOfSectionsPerComponent,
    int32& NumberOfQuadsPerSection )
{
    if ( (SizeX < 2) || (SizeY < 2) )
        return false;

    NumberOfSectionsPerComponent = 1;
    NumberOfQuadsPerSection = 1;
    NewSizeX = -1;
    NewSizeY = -1;

    // Unreal's default sizes
    int32 SectionSizes[] = { 7, 15, 31, 63, 127, 255 };
    int32 NumSections[] = { 1, 2 };

    // Component count used to calculate the final size of the landscape
    int32 ComponentsCountX = 1;
    int32 ComponentsCountY = 1;

    // Lambda for clamping the number of component in X/Y
    auto ClampLandscapeSize = [&]()
    {
        // Max size is either whole components below 8192 verts, or 32 components
        ComponentsCountX = FMath::Clamp(ComponentsCountX, 1, FMath::Min(32, FMath::FloorToInt(8191 / (NumberOfSectionsPerComponent * NumberOfQuadsPerSection))));
        ComponentsCountY = FMath::Clamp(ComponentsCountY, 1, FMath::Min(32, FMath::FloorToInt(8191 / (NumberOfSectionsPerComponent * NumberOfQuadsPerSection))));
    };

    // Try to find a section size and number of sections that exactly matches the dimensions of the heightfield
    bool bFoundMatch = false;
    for (int32 SectionSizesIdx = UE_ARRAY_COUNT(SectionSizes) - 1; SectionSizesIdx >= 0; SectionSizesIdx--)
    {
        for (int32 NumSectionsIdx = UE_ARRAY_COUNT(NumSections) - 1; NumSectionsIdx >= 0; NumSectionsIdx--)
        {
            int32 ss = SectionSizes[SectionSizesIdx];
            int32 ns = NumSections[NumSectionsIdx];

            if (((SizeX - 1) % (ss * ns)) == 0 && ((SizeX - 1) / (ss * ns)) <= 32 &&
                ((SizeY - 1) % (ss * ns)) == 0 && ((SizeY - 1) / (ss * ns)) <= 32)
            {
                bFoundMatch = true;
                NumberOfQuadsPerSection = ss;
                NumberOfSectionsPerComponent = ns;
                ComponentsCountX = (SizeX - 1) / (ss * ns);
                ComponentsCountY = (SizeY - 1) / (ss * ns);
                ClampLandscapeSize();
                break;
            }
        }
        if (bFoundMatch)
        {
            break;
        }
    }

    if (!bFoundMatch)
    {
        // if there was no exact match, try increasing the section size until we encompass the whole heightmap
        const int32 CurrentSectionSize = NumberOfQuadsPerSection;
        const int32 CurrentNumSections = NumberOfSectionsPerComponent;
        for (int32 SectionSizesIdx = 0; SectionSizesIdx < UE_ARRAY_COUNT(SectionSizes); SectionSizesIdx++)
        {
            if (SectionSizes[SectionSizesIdx] < CurrentSectionSize)
            {
                continue;
            }

            const int32 ComponentsX = FMath::DivideAndRoundUp((SizeX - 1), SectionSizes[SectionSizesIdx] * CurrentNumSections);
            const int32 ComponentsY = FMath::DivideAndRoundUp((SizeY - 1), SectionSizes[SectionSizesIdx] * CurrentNumSections);
            if (ComponentsX <= 32 && ComponentsY <= 32)
            {
                bFoundMatch = true;
                NumberOfQuadsPerSection = SectionSizes[SectionSizesIdx];
                ComponentsCountX = ComponentsX;
                ComponentsCountY = ComponentsY;
                ClampLandscapeSize();
                break;
            }
        }
    }

    if (!bFoundMatch)
    {
        // if the heightmap is very large, fall back to using the largest values we support
        const int32 MaxSectionSize = SectionSizes[UE_ARRAY_COUNT(SectionSizes) - 1];
        const int32 MaxNumSubSections = NumSections[UE_ARRAY_COUNT(NumSections) - 1];
        const int32 ComponentsX = FMath::DivideAndRoundUp((SizeX - 1), MaxSectionSize * MaxNumSubSections);
        const int32 ComponentsY = FMath::DivideAndRoundUp((SizeY - 1), MaxSectionSize * MaxNumSubSections);

        bFoundMatch = true;
        NumberOfQuadsPerSection = MaxSectionSize;
        NumberOfSectionsPerComponent = MaxNumSubSections;
        ComponentsCountX = ComponentsX;
        ComponentsCountY = ComponentsY;
        ClampLandscapeSize();
    }

    if (!bFoundMatch)
    {
        // Using default size just to not crash..
        NewSizeX = 512;
        NewSizeY = 512;
        NumberOfSectionsPerComponent = 1;
        NumberOfQuadsPerSection = 511;
        ComponentsCountX = 1;
        ComponentsCountY = 1;
    }
    else
    {
        // Calculating the desired size
        int32 QuadsPerComponent = NumberOfSectionsPerComponent * NumberOfQuadsPerSection;

        NewSizeX = ComponentsCountX * QuadsPerComponent + 1;
        NewSizeY = ComponentsCountY * QuadsPerComponent + 1;
    }

    return bFoundMatch;
}

//-------------------------------------------------------------------------------------------------------------------
bool
FHoudiniLandscapeUtils::ResizeHeightDataForLandscape(
    TArray<uint16>& HeightData,
    const int32& SizeX, const int32& SizeY,
    const int32& NewSizeX, const int32& NewSizeY,
    FVector& LandscapeResizeFactor,
    FVector& LandscapePositionOffset )
{
    LandscapeResizeFactor = FVector::OneVector;
    LandscapePositionOffset = FVector::ZeroVector;

    if ( HeightData.Num() <= 4 )
        return false;

    if ( ( SizeX < 2 ) || ( SizeY < 2 ) )
        return false;

    // No need to resize anything
    if ( SizeX == NewSizeX && SizeY == NewSizeY )
        return true;

    // Do we need to resize/expand the data to the new size?
    bool bForceResample = false;
    bool bResample = bForceResample ? true : ( ( NewSizeX <= SizeX ) && ( NewSizeY <= SizeY ) );

    TArray<uint16> NewData;
    if ( !bResample )
    {
        // Expanding the data by padding
        NewData.SetNumUninitialized( NewSizeX * NewSizeY );

        const int32 OffsetX = (int32)( NewSizeX - SizeX ) / 2;
        const int32 OffsetY = (int32)( NewSizeY - SizeY ) / 2;

        // Store the offset in pixel due to the padding
        int32 PadOffsetX = 0;
        int32 PadOffsetY = 0;

        // Expanding the Data
        NewData = ExpandData(
            HeightData, 0, 0, SizeX - 1, SizeY - 1,
            -OffsetX, -OffsetY, NewSizeX - OffsetX - 1, NewSizeY - OffsetY - 1,
            &PadOffsetX, &PadOffsetY );

        // We will need to offset the landscape position due to the value added by the padding
        LandscapePositionOffset.X = (float)PadOffsetX;
        LandscapePositionOffset.Y = (float)PadOffsetY;

        // Notify the user that the data was padded
        HOUDINI_LOG_WARNING(
            TEXT("Landscape data was padded from ( %d x %d ) to ( %d x %d )."),
            SizeX, SizeY, NewSizeX, NewSizeY );
    }
    else
    {
        // Resampling the data
        NewData.SetNumUninitialized( NewSizeX * NewSizeY );
        NewData = ResampleData( HeightData, SizeX, SizeY, NewSizeX, NewSizeY );

        // The landscape has been resized, we'll need to take that into account when sizing it
        LandscapeResizeFactor.X = (float)SizeX / (float)NewSizeX;
        LandscapeResizeFactor.Y = (float)SizeY / (float)NewSizeY;
        LandscapeResizeFactor.Z = 1.0f;

        // Notify the user if the heightfield data was resized
        HOUDINI_LOG_WARNING(
            TEXT("Landscape data was resized from ( %d x %d ) to ( %d x %d )."),
            SizeX, SizeY, NewSizeX, NewSizeY );
    }

    // Replaces Old data with the new one
    HeightData = NewData;

    return true;
}

bool
FHoudiniLandscapeUtils::ResizeLayerDataForLandscape(
    TArray< uint8 >& LayerData,
    const int32& SizeX, const int32& SizeY,
    const int32& NewSizeX, const int32& NewSizeY )
{
    if ( ( NewSizeX == SizeX ) && ( NewSizeY == SizeY ) )
        return true; 

    bool bForceResample = false;
    bool bResample = bForceResample ? true : ( ( NewSizeX <= SizeX ) && ( NewSizeY <= SizeY ) );

    TArray<uint8> NewData;
    if (!bResample)
    {
        NewData.SetNumUninitialized( NewSizeX * NewSizeY );

        const int32 OffsetX = (int32)( NewSizeX - SizeX ) / 2;
        const int32 OffsetY = (int32)( NewSizeY - SizeY ) / 2;

        // Expanding the Data
        NewData = ExpandData(
            LayerData,
            0, 0, SizeX - 1, SizeY - 1,
            -OffsetX, -OffsetY, NewSizeX - OffsetX - 1, NewSizeY - OffsetY - 1 );
    }
    else
    {
        // Resampling the data
        NewData.SetNumUninitialized( NewSizeX * NewSizeY );
        NewData = ResampleData( LayerData, SizeX, SizeY, NewSizeX, NewSizeY );
    }

    LayerData = NewData;

    return true;
}

#if WITH_EDITOR
bool
FHoudiniLandscapeUtils::CreateHeightfieldFromLandscape(
    ALandscapeProxy* LandscapeProxy, HAPI_NodeId& CreatedHeightfieldNodeId )
{
    if ( !LandscapeProxy )
        return false;

    // Export the whole landscape and its layer as a single heightfield

    //--------------------------------------------------------------------------------------------------
    // 1. Extracting the height data
    //--------------------------------------------------------------------------------------------------
    TArray<uint16> HeightData;
    int32 XSize, YSize;
    FVector Min, Max;
    if ( !GetLandscapeData( LandscapeProxy, HeightData, XSize, YSize, Min, Max ) )
        return false;

    //--------------------------------------------------------------------------------------------------
    // 2. Convert the height uint16 data to float
    //--------------------------------------------------------------------------------------------------
    TArray<float> HeightfieldFloatValues;
    HAPI_VolumeInfo HeightfieldVolumeInfo;
    FHoudiniApi::VolumeInfo_Init(&HeightfieldVolumeInfo);
    FTransform LandscapeTransform = LandscapeProxy->ActorToWorld();
    FVector CenterOffset = FVector::ZeroVector;
    if ( !ConvertLandscapeDataToHeightfieldData(
        HeightData, XSize, YSize, Min, Max, LandscapeTransform,
        HeightfieldFloatValues, HeightfieldVolumeInfo, CenterOffset ) )
        return false;

    //--------------------------------------------------------------------------------------------------
    // 3. Create the Heightfield Input Node
    //-------------------------------------------------------------------------------------------------- 
    HAPI_NodeId HeightFieldId = -1;
    HAPI_NodeId HeightId = -1;
    HAPI_NodeId MaskId = -1;
    HAPI_NodeId MergeId = -1;
    if ( !CreateHeightfieldInputNode( -1, LandscapeProxy->GetName(), XSize, YSize, HeightFieldId, HeightId, MaskId, MergeId ) )
        return false;

    //--------------------------------------------------------------------------------------------------
    // 4. Set the HeightfieldData in Houdini
    //--------------------------------------------------------------------------------------------------    
    // Set the Height volume's data
    HAPI_PartId PartId = 0;
    if ( !SetHeighfieldData( HeightId, PartId, HeightfieldFloatValues, HeightfieldVolumeInfo, TEXT("height") ) )
        return false;

    // Add the materials used
    UMaterialInterface* LandscapeMat = LandscapeProxy->GetLandscapeMaterial();
    UMaterialInterface* LandscapeHoleMat = LandscapeProxy->GetLandscapeHoleMaterial();
    AddLandscapeMaterialAttributesToVolume( HeightId, PartId, LandscapeMat, LandscapeHoleMat );

    // Add the landscape's actor tags as prim attributes if we have any    
    FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(HeightId, PartId, LandscapeProxy->Tags, true);

    // Commit the height volume
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CommitGeo(
        FHoudiniEngine::Get().GetSession(), HeightId ), false );

    //--------------------------------------------------------------------------------------------------
    // 5. Extract and convert all the layers
    //--------------------------------------------------------------------------------------------------
    ULandscapeInfo* LandscapeInfo = LandscapeProxy->GetLandscapeInfo();
    if ( !LandscapeInfo )
        return false;

    bool MaskInitialized = false;
    int32 MergeInputIndex = 2;
    int32 NumLayers = LandscapeInfo->Layers.Num();
    for ( int32 n = 0; n < NumLayers; n++ )
    {
        // 1. Extract the uint8 values from the layer
        TArray<uint8> CurrentLayerIntData;
        FLinearColor LayerUsageDebugColor;
        FString LayerName;
        if ( !GetLandscapeLayerData( LandscapeInfo, n, CurrentLayerIntData, LayerUsageDebugColor, LayerName ) )
            continue;

        // 2. Convert unreal uint8 values to floats
        // If the layer came from Houdini, additional info might have been stored in the DebugColor to convert the data back to float
        HAPI_VolumeInfo CurrentLayerVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentLayerVolumeInfo);
        TArray < float > CurrentLayerFloatData;
        if ( !ConvertLandscapeLayerDataToHeightfieldData(
            CurrentLayerIntData, XSize, YSize, LayerUsageDebugColor,
            CurrentLayerFloatData, CurrentLayerVolumeInfo ) )
            continue;

        // We reuse the height layer's transform
        CurrentLayerVolumeInfo.transform = HeightfieldVolumeInfo.transform;

        // 3. See if we need to create an input volume, or can reuse the HF's default mask volume
        bool IsMask = false;
        if ( LayerName.Equals( TEXT("mask"), ESearchCase::IgnoreCase ) )
            IsMask = true;

        HAPI_NodeId LayerVolumeNodeId = -1;
        if ( !IsMask )
        {
            // Current layer is not mask, so we need to create a new input volume
            std::string LayerNameStr;
            FHoudiniEngineUtils::ConvertUnrealString(LayerName, LayerNameStr);

            FHoudiniApi::CreateHeightfieldInputVolumeNode(
                FHoudiniEngine::Get().GetSession(),
                HeightFieldId, &LayerVolumeNodeId, LayerNameStr.c_str(), XSize, YSize, 1.0f );
        }
        else
        {
            // Current Layer is mask, so we simply reuse the mask volume node created by default by the heightfield node
            LayerVolumeNodeId = MaskId;
        }

        // Check if we have a valid id for the input volume.
        if ( !FHoudiniEngineUtils::IsHoudiniNodeValid( LayerVolumeNodeId ) )
            continue;

        // 4. Set the layer/mask heighfield data in Houdini
        HAPI_PartId CurrentPartId = 0;
        if ( !SetHeighfieldData( LayerVolumeNodeId, PartId, CurrentLayerFloatData, CurrentLayerVolumeInfo, LayerName ) )
            continue;

        // Also add the material attributes to the layer volumes
        AddLandscapeMaterialAttributesToVolume(LayerVolumeNodeId, PartId, LandscapeMat, LandscapeHoleMat);

        // Add the landscape's actor tags as prim attributes if we have any    
        FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(LayerVolumeNodeId, PartId, LandscapeProxy->Tags, true);

        // Commit the volume's geo
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CommitGeo(
            FHoudiniEngine::Get().GetSession(), LayerVolumeNodeId ), false);

        if ( !IsMask )
        {
            // We had to create a new volume for this layer, so we need to connect it to the HF's merge node
            HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::ConnectNodeInput(
                FHoudiniEngine::Get().GetSession(),
                MergeId, MergeInputIndex, LayerVolumeNodeId, 0 ), false);

            MergeInputIndex++;
        }
        else
        {
            MaskInitialized = true;
        }
    }

    // We need to have a mask layer as it is required for proper heightfield functionalities
    // Setting the volume info on the mask is needed for the HF to have proper transform in H!
    // If we didn't create a mask volume before, send a default one now
    if (!MaskInitialized)
    {
        MaskInitialized = InitDefaultHeightfieldMask( HeightfieldVolumeInfo, MaskId );

        // Add the materials used
        AddLandscapeMaterialAttributesToVolume( MaskId, PartId, LandscapeMat, LandscapeHoleMat );

        // Add the landscape's actor tags as prim attributes if we have any    
        FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(MaskId, PartId, LandscapeProxy->Tags, true);

        // Commit the mask volume's geo
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CommitGeo(
            FHoudiniEngine::Get().GetSession(), MaskId ), false );
    }

    HAPI_TransformEuler HAPIObjectTransform;
    FHoudiniApi::TransformEuler_Init(&HAPIObjectTransform);
    //FMemory::Memzero< HAPI_TransformEuler >( HAPIObjectTransform );
    LandscapeTransform.SetScale3D(FVector::OneVector);    
    FHoudiniEngineUtils::TranslateUnrealTransform( LandscapeTransform, HAPIObjectTransform );
    HAPIObjectTransform.position[1] = 0.0f;

    HAPI_NodeId ParentObjNodeId = FHoudiniEngineUtils::HapiGetParentNodeId( HeightFieldId );
    FHoudiniApi::SetObjectTransform(FHoudiniEngine::Get().GetSession(), ParentObjNodeId, &HAPIObjectTransform);

    // Since HF are centered but landscape aren't, we need to set the HF's center parameter
    FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 0, CenterOffset.X);
    FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 1, 0.0);
    FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 2, CenterOffset.Y);

    // Finally, cook the Heightfield node
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CookNode(
        FHoudiniEngine::Get().GetSession(), HeightFieldId, nullptr), false );

    CreatedHeightfieldNodeId = HeightFieldId;

    return true;
}

bool
FHoudiniLandscapeUtils::CreateHeightfieldFromLandscapeComponentArray(
    ALandscapeProxy* LandscapeProxy,
    TSet< ULandscapeComponent * >& LandscapeComponentArray, 
    HAPI_NodeId& CreatedHeightfieldNodeId )
{
    if ( LandscapeComponentArray.Num() <= 0 )
        return false;

    //--------------------------------------------------------------------------------------------------
    //  Each selected component will be exported as tiled volumes in a single heightfield
    //--------------------------------------------------------------------------------------------------
    FTransform LandscapeTransform = LandscapeProxy->GetTransform();

    //
    HAPI_NodeId HeightfieldNodeId = -1;
    HAPI_NodeId HeightfieldeMergeId = -1;

    int32 MergeInputIndex = 0;
    bool bAllComponentCreated = true;
    for (int32 ComponentIdx = 0; ComponentIdx < LandscapeProxy->LandscapeComponents.Num(); ComponentIdx++)
    {
        ULandscapeComponent * CurrentComponent = LandscapeProxy->LandscapeComponents[ ComponentIdx ];
        if ( !CurrentComponent )
            continue;

        if ( !LandscapeComponentArray.Contains( CurrentComponent ) )
            continue;

        if ( !CreateHeightfieldFromLandscapeComponent( CurrentComponent, ComponentIdx, HeightfieldNodeId, HeightfieldeMergeId, MergeInputIndex ) )
            bAllComponentCreated = false;
    }

    // Check that we have a valid id for the input Heightfield.
    if ( FHoudiniEngineUtils::IsHoudiniNodeValid( HeightfieldNodeId ) )
        CreatedHeightfieldNodeId = HeightfieldNodeId;

    // Set the HF's parent OBJ's tranform to the Landscape's transform
    HAPI_TransformEuler HAPIObjectTransform;
    FHoudiniApi::TransformEuler_Init(&HAPIObjectTransform);
    //FMemory::Memzero< HAPI_TransformEuler >( HAPIObjectTransform );
    LandscapeTransform.SetScale3D( FVector::OneVector );
    FHoudiniEngineUtils::TranslateUnrealTransform( LandscapeTransform, HAPIObjectTransform );
    HAPIObjectTransform.position[ 1 ] = 0.0f;

    HAPI_NodeId ParentObjNodeId = FHoudiniEngineUtils::HapiGetParentNodeId( HeightfieldNodeId );
    FHoudiniApi::SetObjectTransform( FHoudiniEngine::Get().GetSession(), ParentObjNodeId, &HAPIObjectTransform );

    return bAllComponentCreated;
}


bool
FHoudiniLandscapeUtils::CreateHeightfieldFromLandscapeComponent(
    ULandscapeComponent * LandscapeComponent,
    const int32& ComponentIndex,
    HAPI_NodeId& HeightFieldId,
    HAPI_NodeId& MergeId,
    int32& MergeInputIndex )
{
    if ( !LandscapeComponent )
        return false;

    //--------------------------------------------------------------------------------------------------
    // 1. Extract the height data
    //--------------------------------------------------------------------------------------------------
    int32 MinX = MAX_int32;
    int32 MinY = MAX_int32;
    int32 MaxX = -MAX_int32;
    int32 MaxY = -MAX_int32;
    LandscapeComponent->GetComponentExtent( MinX, MinY, MaxX, MaxY );
    
    ULandscapeInfo* LandscapeInfo = LandscapeComponent->GetLandscapeInfo();
    if ( !LandscapeInfo )
        return false;

    TArray<uint16> HeightData;
    int32 XSize, YSize;
    if ( !GetLandscapeData( LandscapeInfo, MinX, MinY, MaxX, MaxY, HeightData, XSize, YSize ) )
        return false;

    FVector Origin = LandscapeComponent->Bounds.Origin;
    FVector Extents = LandscapeComponent->Bounds.BoxExtent;
    FVector Min = Origin - Extents;
    FVector Max = Origin + Extents;

    //--------------------------------------------------------------------------------------------------
    // 2. Convert the landscape's height uint16 data to float
    //--------------------------------------------------------------------------------------------------
    TArray<float> HeightfieldFloatValues;
    HAPI_VolumeInfo HeightfieldVolumeInfo;
    FHoudiniApi::VolumeInfo_Init(&HeightfieldVolumeInfo);
    FTransform LandscapeComponentTransform = LandscapeComponent->GetComponentTransform();

    FVector CenterOffset = FVector::ZeroVector;
    if ( !ConvertLandscapeDataToHeightfieldData(
        HeightData, XSize, YSize, Min, Max, LandscapeComponentTransform,
        HeightfieldFloatValues, HeightfieldVolumeInfo,
        CenterOffset ) )
        return false;

    // We need to modify the Volume's position to the Component's position relative to the Landscape's position
    FVector RelativePosition = LandscapeComponent->GetRelativeTransform().GetLocation();
    HeightfieldVolumeInfo.transform.position[1] = RelativePosition.X;
    HeightfieldVolumeInfo.transform.position[0] = RelativePosition.Y;
    HeightfieldVolumeInfo.transform.position[2] = 0.0f;

    //--------------------------------------------------------------------------------------------------
    // 3. Create the Heightfield Input Node
    //--------------------------------------------------------------------------------------------------
    HAPI_NodeId HeightId = -1;
    HAPI_NodeId MaskId = -1;
    bool CreatedHeightfieldNode = false;
    if ( HeightFieldId < 0 || MergeId < 0 )
    {
        // We haven't created the HF input node yet, do it now
        if (!CreateHeightfieldInputNode(-1, TEXT("LandscapeComponents"), XSize, YSize, HeightFieldId, HeightId, MaskId, MergeId))
            return false;

        MergeInputIndex = 2;
        CreatedHeightfieldNode = true;
    }
    else
    {
        // Heightfield node was previously created, create additionnal height and a mask volumes for it
        FHoudiniApi::CreateHeightfieldInputVolumeNode(
            FHoudiniEngine::Get().GetSession(),
            HeightFieldId, &HeightId, "height", XSize, YSize, 1.0f );

        FHoudiniApi::CreateHeightfieldInputVolumeNode(
            FHoudiniEngine::Get().GetSession(),
            HeightFieldId, &MaskId, "mask", XSize, YSize, 1.0f );

        // Connect the two newly created volumes to the HF's merge node
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::ConnectNodeInput(
            FHoudiniEngine::Get().GetSession(),
            MergeId, MergeInputIndex++, HeightId, 0 ), false );

        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::ConnectNodeInput(
            FHoudiniEngine::Get().GetSession(),
            MergeId, MergeInputIndex++, MaskId, 0 ), false );
    }


    //--------------------------------------------------------------------------------------------------
    // 4. Set the HeightfieldData in Houdini
    //--------------------------------------------------------------------------------------------------    
    // Set the Height volume's data
    HAPI_PartId PartId = 0;
    if (!SetHeighfieldData( HeightId, PartId, HeightfieldFloatValues, HeightfieldVolumeInfo, TEXT("height") ) )
        return false;

    // Add the materials used
    UMaterialInterface* LandscapeMat = LandscapeComponent->GetLandscapeMaterial();
    UMaterialInterface* LandscapeHoleMat = LandscapeComponent->GetLandscapeHoleMaterial();
    AddLandscapeMaterialAttributesToVolume(HeightId, PartId, LandscapeMat, LandscapeHoleMat);

    // Add the tile attribute
    AddLandscapeTileAttribute(HeightId, PartId, ComponentIndex);

    // Add the landscape component extent attribute
    AddLandscapeComponentExtentAttributes( HeightId, PartId, MinX, MaxX, MinY, MaxY );

    // Add the component's tag as prim attributes if we have any
    FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(HeightId, PartId, LandscapeComponent->ComponentTags, true);

    // Commit the height volume
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::CommitGeo(
        FHoudiniEngine::Get().GetSession(), HeightId), false);

    //--------------------------------------------------------------------------------------------------
    // 4. Extract and convert all the layers to HF masks
    //--------------------------------------------------------------------------------------------------
    bool MaskInitialized = false;
    int32 NumLayers = LandscapeInfo->Layers.Num();
    for ( int32 n = 0; n < NumLayers; n++ )
    {
        // 1. Extract the uint8 values from the layer
        TArray<uint8> CurrentLayerIntData;
        FLinearColor LayerUsageDebugColor;
        FString LayerName;
        if ( !GetLandscapeLayerData(LandscapeInfo, n, MinX, MinY, MaxX, MaxY, CurrentLayerIntData, LayerUsageDebugColor, LayerName) )
            continue;

        // 2. Convert unreal uint8 to float
        // If the layer came from Houdini, additional info might have been stored in the DebugColor
        HAPI_VolumeInfo CurrentLayerVolumeInfo;
        FHoudiniApi::VolumeInfo_Init(&CurrentLayerVolumeInfo);
        TArray < float > CurrentLayerFloatData;
        if ( !ConvertLandscapeLayerDataToHeightfieldData(
            CurrentLayerIntData, XSize, YSize, LayerUsageDebugColor,
            CurrentLayerFloatData, CurrentLayerVolumeInfo ) )
            continue;

        // We reuse the transform used for the height volume
        CurrentLayerVolumeInfo.transform = HeightfieldVolumeInfo.transform;

        // 3. See if we need to create an input volume, or if we can reuse the HF's default mask volume
        bool IsMask = false;
        if ( LayerName.Equals( TEXT("mask"), ESearchCase::IgnoreCase ) )
            IsMask = true;

        HAPI_NodeId LayerVolumeNodeId = -1;
        if ( !IsMask )
        {
            // Current layer is not mask, so we need to create a new input volume
            std::string LayerNameStr;
            FHoudiniEngineUtils::ConvertUnrealString( LayerName, LayerNameStr );

            FHoudiniApi::CreateHeightfieldInputVolumeNode(
                FHoudiniEngine::Get().GetSession(),
                HeightFieldId, &LayerVolumeNodeId, LayerNameStr.c_str(), XSize, YSize, 1.0f );
        }
        else
        {
            // Current Layer is mask, so we simply reuse the mask volume node created by default by the heightfield node
            LayerVolumeNodeId = MaskId;
        }

        // Check if we have a valid id for the input volume.
        if ( !FHoudiniEngineUtils::IsHoudiniNodeValid( LayerVolumeNodeId ) )
            continue;

        // 4. Set the layer/mask heighfield data in Houdini
        HAPI_PartId CurrentPartId = 0;
        if ( !SetHeighfieldData( LayerVolumeNodeId, PartId, CurrentLayerFloatData, CurrentLayerVolumeInfo, LayerName ) )
            continue;

        // Add the materials used
        AddLandscapeMaterialAttributesToVolume( LayerVolumeNodeId, PartId, LandscapeMat, LandscapeHoleMat );

        // Add the tile attribute
        AddLandscapeTileAttribute( LayerVolumeNodeId, PartId, ComponentIndex );

        // Add the landscape component extent attribute
        AddLandscapeComponentExtentAttributes( LayerVolumeNodeId, PartId, MinX, MaxX, MinY, MaxY );

        // Add the component's tag as prim attributes if we have any
        FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(LayerVolumeNodeId, PartId, LandscapeComponent->ComponentTags, true);

        // Commit the volume's geo
        HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CommitGeo(
            FHoudiniEngine::Get().GetSession(), LayerVolumeNodeId ), false);

        if ( !IsMask )
        {
            // We had to create a new volume for this layer, so we need to connect it to the HF's merge node
            HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::ConnectNodeInput(
                FHoudiniEngine::Get().GetSession(),
                MergeId, MergeInputIndex, LayerVolumeNodeId, 0 ), false);

            MergeInputIndex++;
        }
        else
        {
            MaskInitialized = true;
        }
    }

    // We need to have a mask layer as it is required for proper heightfield functionalities
    // Setting the volume info on the mask is needed for the HF to have proper transform in H!
    // If we didn't create a mask volume before, send a default one now
    if (!MaskInitialized)
    {
        MaskInitialized = InitDefaultHeightfieldMask( HeightfieldVolumeInfo, MaskId );

        // Add the materials used
        AddLandscapeMaterialAttributesToVolume( MaskId, PartId, LandscapeMat, LandscapeHoleMat );

        // Add the tile attribute
        AddLandscapeTileAttribute( MaskId, PartId, ComponentIndex );

        // Add the landscape component extent attribute
        AddLandscapeComponentExtentAttributes( MaskId, PartId, MinX, MaxX, MinY, MaxY );

        // Add the component's tag as prim attributes if we have any
        FHoudiniEngineUtils::CreateGroupOrAttributeFromTags(MaskId, PartId, LandscapeComponent->ComponentTags, true);

        // Commit the mask volume's geo
        HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::CommitGeo(
            FHoudiniEngine::Get().GetSession(), MaskId), false);
    }

    if ( CreatedHeightfieldNode )
    {
        // Since HF are centered but landscape arent, we need to set the HF's center parameter
        // Do it only once after creating the Heightfield node
        FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 0, CenterOffset.X);
        FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 1, 0.0);
        FHoudiniApi::SetParmFloatValue(FHoudiniEngine::Get().GetSession(), HeightFieldId, "t", 2, CenterOffset.Y);
    }    

    // Finally, cook the Heightfield node
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::CookNode(
        FHoudiniEngine::Get().GetSession(), HeightFieldId, nullptr), false);

    return true;
}

bool
FHoudiniLandscapeUtils::GetLandscapeData(
    ALandscape* Landscape,
    TArray<uint16>& HeightData,
    int32& XSize, int32& YSize,
    FVector& Min, FVector& Max )
{
    if ( !Landscape )
        return false;

    ULandscapeInfo* LandscapeInfo = Landscape->GetLandscapeInfo();
    if ( !LandscapeInfo )
        return false;

    // Get the landscape extents to get its size
    int32 MinX = MAX_int32;
    int32 MinY = MAX_int32;
    int32 MaxX = -MAX_int32;
    int32 MaxY = -MAX_int32;

    if (!LandscapeInfo->GetLandscapeExtent(MinX, MinY, MaxX, MaxY))
        return false;

    if ( !GetLandscapeData( LandscapeInfo, MinX, MinY, MaxX, MaxY, HeightData, XSize, YSize ) )
        return false;

    // Get the landscape Min/Max values
    // Do not use Landscape->GetActorBounds() here as instanced geo
    // (due to grass layers for example) can cause it to return incorrect bounds!
    FVector Origin, Extent;
    GetLandscapeActorBounds(Landscape, Origin, Extent);

    // Get the landscape Min/Max values
    Min = Origin - Extent;
    Max = Origin + Extent;

    return true;
}

bool
FHoudiniLandscapeUtils::GetLandscapeData(
    ALandscapeProxy* LandscapeProxy,
    TArray<uint16>& HeightData,
    int32& XSize, int32& YSize,
    FVector& Min, FVector& Max)
{
    if (!LandscapeProxy)
        return false;

    ULandscapeInfo* LandscapeInfo = LandscapeProxy->GetLandscapeInfo();
    if (!LandscapeInfo)
        return false;

    // Get the landscape extents to get its size
    int32 MinX = MAX_int32;
    int32 MinY = MAX_int32;
    int32 MaxX = -MAX_int32;
    int32 MaxY = -MAX_int32;

    // To handle streaming proxies correctly, get the extents via all the components,
    // not by calling GetLandscapeExtent or we'll end up sending ALL the streaming proxies.
    for (const ULandscapeComponent* Comp : LandscapeProxy->LandscapeComponents)
    {
        Comp->GetComponentExtent(MinX, MinY, MaxX, MaxY);
    }

    if (!GetLandscapeData(LandscapeInfo, MinX, MinY, MaxX, MaxY, HeightData, XSize, YSize))
        return false;

    // Get the landscape Min/Max values
    // Do not use Landscape->GetActorBounds() here as instanced geo
    // (due to grass layers for example) can cause it to return incorrect bounds!
    FVector Origin, Extent;
    GetLandscapeProxyBounds(LandscapeProxy, Origin, Extent);

    // Get the landscape Min/Max values
    Min = Origin - Extent;
    Max = Origin + Extent;

    return true;
}


void
FHoudiniLandscapeUtils::GetLandscapeActorBounds(
    ALandscape* Landscape, FVector& Origin, FVector& Extents )
{
    // Iterate only on the landscape components
    FBox Bounds(ForceInit);
    for (const UActorComponent* ActorComponent : Landscape->GetComponents())
    {
        const ULandscapeComponent* LandscapeComp = Cast<const ULandscapeComponent>(ActorComponent);
        if ( LandscapeComp && LandscapeComp->IsRegistered() )
            Bounds += LandscapeComp->Bounds.GetBox();
    }

    // Convert the bounds to origin/offset vectors
    Bounds.GetCenterAndExtents(Origin, Extents);
}

void
FHoudiniLandscapeUtils::GetLandscapeProxyBounds(
    ALandscapeProxy* LandscapeProxy, FVector& Origin, FVector& Extents)
{
    // Iterate only on the landscape components
    FBox Bounds(ForceInit);
    for (const UActorComponent* ActorComponent : LandscapeProxy->GetComponents())
    {
        const ULandscapeComponent* LandscapeComp = Cast<const ULandscapeComponent>(ActorComponent);
        if (LandscapeComp && LandscapeComp->IsRegistered())
            Bounds += LandscapeComp->Bounds.GetBox();
    }

    // Convert the bounds to origin/offset vectors
    Bounds.GetCenterAndExtents(Origin, Extents);
}

bool
FHoudiniLandscapeUtils::GetLandscapeData(
    ULandscapeInfo* LandscapeInfo,
    const int32& MinX, const int32& MinY,
    const int32& MaxX, const int32& MaxY,
    TArray<uint16>& HeightData,
    int32& XSize, int32& YSize )
{
    if ( !LandscapeInfo )
        return false;

    // Get the X/Y size in points
    XSize = ( MaxX - MinX + 1 );
    YSize = ( MaxY - MinY + 1 );

    if ( ( XSize < 2 ) || ( YSize < 2 ) )
        return false;

    // Extracting the uint16 values from the landscape
    FLandscapeEditDataInterface LandscapeEdit( LandscapeInfo );
    HeightData.AddZeroed( XSize * YSize );
    LandscapeEdit.GetHeightDataFast( MinX, MinY, MaxX, MaxY, HeightData.GetData(), 0 );

    return true;
}

bool
FHoudiniLandscapeUtils::GetLandscapeLayerData(
    ULandscapeInfo* LandscapeInfo, const int32& LayerIndex,
    TArray<uint8>& LayerData, FLinearColor& LayerUsageDebugColor,
    FString& LayerName )
{
    if ( !LandscapeInfo )
        return false;

    // Get the landscape X/Y Size
    int32 MinX = MAX_int32;
    int32 MinY = MAX_int32;
    int32 MaxX = -MAX_int32;
    int32 MaxY = -MAX_int32;
    if ( !LandscapeInfo->GetLandscapeExtent( MinX, MinY, MaxX, MaxY ) )
        return false;

    if ( !GetLandscapeLayerData(
        LandscapeInfo, LayerIndex,
        MinX, MinY, MaxX, MaxY,
        LayerData, LayerUsageDebugColor, LayerName ) )
        return false;

    return true;
}

bool
FHoudiniLandscapeUtils::GetLandscapeLayerData(
    ULandscapeInfo* LandscapeInfo,
    const int32& LayerIndex,
    const int32& MinX, const int32& MinY,
    const int32& MaxX, const int32& MaxY,
    TArray<uint8>& LayerData,
    FLinearColor& LayerUsageDebugColor,
    FString& LayerName )
{
    if ( !LandscapeInfo )
        return false;

    if ( !LandscapeInfo->Layers.IsValidIndex( LayerIndex ) )
        return false;

    FLandscapeInfoLayerSettings LayersSetting = LandscapeInfo->Layers[ LayerIndex ];
    ULandscapeLayerInfoObject* LayerInfo = LayersSetting.LayerInfoObj;
    if (!LayerInfo)
        return false;

    // Calc the X/Y size in points
    int32 XSize = (MaxX - MinX + 1);
    int32 YSize = (MaxY - MinY + 1);
    if ( (XSize < 2) || (YSize < 2) )
        return false;

    // extracting the uint8 values from the layer
    FLandscapeEditDataInterface LandscapeEdit(LandscapeInfo);
    LayerData.AddZeroed(XSize * YSize);
    LandscapeEdit.GetWeightDataFast(LayerInfo, MinX, MinY, MaxX, MaxY, LayerData.GetData(), 0);

    LayerUsageDebugColor = LayerInfo->LayerUsageDebugColor;

    LayerName = LayersSetting.GetLayerName().ToString();

    return true;
}
#endif

bool
FHoudiniLandscapeUtils::ConvertLandscapeDataToHeightfieldData(
    const TArray<uint16>& IntHeightData,
    const int32& XSize, const int32& YSize,
    FVector Min, FVector Max, 
    const FTransform& LandscapeTransform,
    TArray<float>& HeightfieldFloatValues,
    HAPI_VolumeInfo& HeightfieldVolumeInfo,
    FVector& CenterOffset)
{
    HeightfieldFloatValues.Empty();

    int32 HoudiniXSize = YSize;
    int32 HoudiniYSize = XSize;
    int32 SizeInPoints = HoudiniXSize * HoudiniYSize;
    if ( (HoudiniXSize < 2) || (HoudiniYSize < 2) )
        return false;

    if ( IntHeightData.Num() != SizeInPoints )
        return false;

    // Use default unreal scaling for marshalling landscapes
    // A lot of precision will be lost in order to keep the same transform as the landscape input
    bool bUseDefaultUE4Scaling = false;
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if (HoudiniRuntimeSettings && HoudiniRuntimeSettings->MarshallingLandscapesUseDefaultUnrealScaling)
        bUseDefaultUE4Scaling = HoudiniRuntimeSettings->MarshallingLandscapesUseDefaultUnrealScaling;

    //--------------------------------------------------------------------------------------------------
    // 1. Convert values to float
    //--------------------------------------------------------------------------------------------------


    // Convert the min/max values from cm to meters
    Min /= 100.0;
    Max /= 100.0;

    // Unreal's landscape uses 16bits precision and range from -256m to 256m with the default scale of 100.0
    // To convert the uint16 values to float "metric" values, offset the int by 32768 to center it,
    // then scale it

    // Spacing used to convert from uint16 to meters
    double ZSpacing = 512.0 / ((double)UINT16_MAX);
    ZSpacing *= ( (double)LandscapeTransform.GetScale3D().Z / 100.0 );

    // Center value in meters (Landscape ranges from [-255:257] meters at default scale
    double ZCenterOffset = 32767;
    double ZPositionOffset = LandscapeTransform.GetLocation().Z / 100.0f;
    // Convert the Int data to Float
    HeightfieldFloatValues.SetNumUninitialized( SizeInPoints );

    for ( int32 nY = 0; nY < HoudiniYSize; nY++ )
    {
        for ( int32 nX = 0; nX < HoudiniXSize; nX++ )
        {
            // We need to invert X/Y when reading the value from Unreal
            int32 nHoudini = nX + nY * HoudiniXSize;
            int32 nUnreal = nY + nX * XSize;

            // Convert the int values to meter
            // Unreal's digit value have a zero value of 32768
            double DoubleValue = ((double)IntHeightData[nUnreal] - ZCenterOffset) * ZSpacing + ZPositionOffset;
            HeightfieldFloatValues[nHoudini] = (float)DoubleValue;
        }
    }

    //--------------------------------------------------------------------------------------------------
    // 2. Convert the Unreal Transform to a HAPI_transform
    //--------------------------------------------------------------------------------------------------
    HAPI_Transform HapiTransform;
    FHoudiniApi::Transform_Init(&HapiTransform);
    //FMemory::Memzero< HAPI_Transform >( HapiTransform );
    {
        FQuat Rotation = LandscapeTransform.GetRotation();
        if ( Rotation != FQuat::Identity )
        {
            //Swap(ObjectRotation.Y, ObjectRotation.Z);
            HapiTransform.rotationQuaternion[0] = Rotation.X;
            HapiTransform.rotationQuaternion[1] = Rotation.Z;
            HapiTransform.rotationQuaternion[2] = Rotation.Y;
            HapiTransform.rotationQuaternion[3] = -Rotation.W;
        }
        else
        {
            HapiTransform.rotationQuaternion[0] = 0;
            HapiTransform.rotationQuaternion[1] = 0;
            HapiTransform.rotationQuaternion[2] = 0;
            HapiTransform.rotationQuaternion[3] = 1;
        }

        // Heightfield are centered, landscapes are not
        CenterOffset = (Max - Min) * 0.5f;

        // Unreal XYZ becomes Houdini YXZ (since heightfields are also rotated due the ZX transform) 
        //FVector Position = LandscapeTransform.GetLocation() / 100.0f;
        HapiTransform.position[ 1 ] = 0.0f;//Position.X + CenterOffset.X;
        HapiTransform.position[ 0 ] = 0.0f;//Position.Y + CenterOffset.Y;
        HapiTransform.position[ 2 ] = 0.0f;

        FVector Scale = LandscapeTransform.GetScale3D() / 100.0f;
        HapiTransform.scale[ 0 ] = Scale.X * 0.5f * HoudiniXSize;
        HapiTransform.scale[ 1 ] = Scale.Y * 0.5f * HoudiniYSize;
        HapiTransform.scale[ 2 ] = 0.5f;
        if ( bUseDefaultUE4Scaling )
            HapiTransform.scale[2] *= Scale.Z;

        HapiTransform.shear[ 0 ] = 0.0f;
        HapiTransform.shear[ 1 ] = 0.0f;
        HapiTransform.shear[ 2 ] = 0.0f;
    }

    //--------------------------------------------------------------------------------------------------
    // 3. Fill the volume info
    //--------------------------------------------------------------------------------------------------
    HeightfieldVolumeInfo.xLength = HoudiniXSize;
    HeightfieldVolumeInfo.yLength = HoudiniYSize;
    HeightfieldVolumeInfo.zLength = 1;

    HeightfieldVolumeInfo.minX = 0;
    HeightfieldVolumeInfo.minY = 0;
    HeightfieldVolumeInfo.minZ = 0;
    
    HeightfieldVolumeInfo.transform = HapiTransform;
    
    HeightfieldVolumeInfo.type = HAPI_VOLUMETYPE_HOUDINI;
    HeightfieldVolumeInfo.storage = HAPI_STORAGETYPE_FLOAT;
    HeightfieldVolumeInfo.tupleSize = 1;
    HeightfieldVolumeInfo.tileSize = 1;
    
    HeightfieldVolumeInfo.hasTaper = false;
    HeightfieldVolumeInfo.xTaper = 0.0;
    HeightfieldVolumeInfo.yTaper = 0.0;

    return true;
}

// Converts Unreal uint16 values to Houdini Float
bool
FHoudiniLandscapeUtils::ConvertLandscapeLayerDataToHeightfieldData(
    const TArray<uint8>& IntHeightData,
    const int32& XSize, const int32& YSize,
    const FLinearColor& LayerUsageDebugColor,
    TArray<float>& LayerFloatValues,
    HAPI_VolumeInfo& LayerVolumeInfo)
{
    LayerFloatValues.Empty();

    int32 HoudiniXSize = YSize;
    int32 HoudiniYSize = XSize;
    int32 SizeInPoints = HoudiniXSize * HoudiniYSize;
    if ( ( HoudiniXSize < 2 ) || ( HoudiniYSize < 2 ) )
        return false;

    if ( IntHeightData.Num() != SizeInPoints )
        return false;

    //--------------------------------------------------------------------------------------------------
    // 1. Convert values to float
    //--------------------------------------------------------------------------------------------------

    // We need the ZMin / ZMax unt8 values
    uint8 IntMin = IntHeightData[ 0 ];
    uint8 IntMax = IntMin;

    for ( int n = 0; n < IntHeightData.Num(); n++ )
    {
        if ( IntHeightData[ n ] < IntMin )
            IntMin = IntHeightData[ n ];
        if ( IntHeightData[ n ] > IntMax )
            IntMax = IntHeightData[ n ];
    }

    // The range in Digits
    double DigitRange = (double)IntMax - (double)IntMin;

    // By default, the values will be converted to [0, 1]
    float LayerMin = 0.0f;
    float LayerMax = 1.0f;
    float LayerSpacing = 1.0f / DigitRange;

    // If this layer came from Houdini, its alpha value should be PI
    // So we can extract the additionnal infos stored its debug usage color
    if ( LayerUsageDebugColor.A == PI )
    {
        LayerMin = LayerUsageDebugColor.R;
        LayerMax = LayerUsageDebugColor.G;
        LayerSpacing = LayerUsageDebugColor.B;
    }

    LayerSpacing = ( LayerMax - LayerMin ) / DigitRange;

    // Convert the Int data to Float
    LayerFloatValues.SetNumUninitialized( SizeInPoints );

    for ( int32 nY = 0; nY < HoudiniYSize; nY++ )
    {
        for ( int32 nX = 0; nX < HoudiniXSize; nX++ )
        {
            // We need to invert X/Y when reading the value from Unreal
            int32 nHoudini = nX + nY * HoudiniXSize;
            int32 nUnreal = nY + nX * XSize;

            // Convert the int values to meter
            // Unreal's digit value have a zero value of 32768
            double DoubleValue = ( (double)IntHeightData[ nUnreal ] - (double)IntMin ) * LayerSpacing + LayerMin;
            LayerFloatValues[ nHoudini ] = (float)DoubleValue;
        }
    }

    // Verifying the converted ZMin / ZMax
    float FloatMin = LayerFloatValues[ 0 ];
    float FloatMax = FloatMin;
    for ( int32 n = 0; n < LayerFloatValues.Num(); n++ )
    {
        if ( LayerFloatValues[ n ] < FloatMin )
            FloatMin = LayerFloatValues[ n ];
        if ( LayerFloatValues[ n ] > FloatMax )
            FloatMax = LayerFloatValues[ n ];
    }

    //--------------------------------------------------------------------------------------------------
    // 2. Fill the volume info
    //--------------------------------------------------------------------------------------------------
    LayerVolumeInfo.xLength = HoudiniXSize;
    LayerVolumeInfo.yLength = HoudiniYSize;
    LayerVolumeInfo.zLength = 1;

    LayerVolumeInfo.minX = 0;
    LayerVolumeInfo.minY = 0;
    LayerVolumeInfo.minZ = 0;

    LayerVolumeInfo.type = HAPI_VOLUMETYPE_HOUDINI;
    LayerVolumeInfo.storage = HAPI_STORAGETYPE_FLOAT;
    LayerVolumeInfo.tupleSize = 1;
    LayerVolumeInfo.tileSize = 1;

    LayerVolumeInfo.hasTaper = false;
    LayerVolumeInfo.xTaper = 0.0;
    LayerVolumeInfo.yTaper = 0.0;

    // The layer transform will have to be copied from the main heightfield's transform
    return true;
}

bool
FHoudiniLandscapeUtils::SetHeighfieldData(
    const HAPI_NodeId& VolumeNodeId,
    const HAPI_PartId& PartId,
    TArray<float>& FloatValues,
    const HAPI_VolumeInfo& VolumeInfo,
    const FString& HeightfieldName )
{
    // Cook the node to get proper infos on it
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::CookNode(
        FHoudiniEngine::Get().GetSession(), VolumeNodeId, nullptr ), false );

    // Read the geo/part/volume info from the volume node
    HAPI_GeoInfo GeoInfo;
    FHoudiniApi::GeoInfo_Init(&GeoInfo);
    //FMemory::Memset< HAPI_GeoInfo >(GeoInfo, 0);
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetGeoInfo(
        FHoudiniEngine::Get().GetSession(),
        VolumeNodeId, &GeoInfo), false);

    HAPI_PartInfo PartInfo;
    FHoudiniApi::PartInfo_Init(&PartInfo);
    //FMemory::Memset< HAPI_PartInfo >(PartInfo, 0);
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetPartInfo(
        FHoudiniEngine::Get().GetSession(),
        GeoInfo.nodeId, PartId, &PartInfo), false);

    // Update the volume infos
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetVolumeInfo(
        FHoudiniEngine::Get().GetSession(),
        VolumeNodeId, PartInfo.id, &VolumeInfo), false );

    // Volume name
    std::string NameStr;
    FHoudiniEngineUtils::ConvertUnrealString( HeightfieldName, NameStr );

    // Set the Heighfield data on the volume
    float * HeightData = FloatValues.GetData();
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetHeightFieldData(
        FHoudiniEngine::Get().GetSession(),
        GeoInfo.nodeId, PartInfo.id, NameStr.c_str(), HeightData, 0, FloatValues.Num() ), false );

    return true;
}

bool
FHoudiniLandscapeUtils::CreateHeightfieldInputNode(
    const HAPI_NodeId& ParentNodeId, const FString& NodeName, const int32& XSize, const int32& YSize,
    HAPI_NodeId& HeightfieldNodeId, HAPI_NodeId& HeightNodeId, HAPI_NodeId& MaskNodeId, HAPI_NodeId& MergeNodeId )
{
    // Make sure the Heightfield node doesnt already exists
    if (HeightfieldNodeId != -1)
        return false;

    // Convert the node's name
    std::string NameStr;
    FHoudiniEngineUtils::ConvertUnrealString(NodeName, NameStr);

    // Create the heigthfield node via HAPI
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::CreateHeightfieldInputNode(
        FHoudiniEngine::Get().GetSession(),
        ParentNodeId, NameStr.c_str(), XSize, YSize, 1.0f,
        &HeightfieldNodeId, &HeightNodeId, &MaskNodeId, &MergeNodeId ), false);

    // Cook it
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::CookNode(
        FHoudiniEngine::Get().GetSession(), HeightfieldNodeId, nullptr), false);

    return true;
}

bool
FHoudiniLandscapeUtils::DestroyLandscapeAssetNode( HAPI_NodeId& ConnectedAssetId, TArray<HAPI_NodeId>& CreatedInputAssetIds )
{
    HAPI_AssetInfo NodeAssetInfo;
    FHoudiniApi::AssetInfo_Init(&NodeAssetInfo);
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetAssetInfo(
        FHoudiniEngine::Get().GetSession(), ConnectedAssetId, &NodeAssetInfo ), false );

    FHoudiniEngineString AssetOpName( NodeAssetInfo.fullOpNameSH );
    FString OpName;
    if ( !AssetOpName.ToFString( OpName ) )
        return false;

    if ( !OpName.Contains(TEXT("xform")))
    {
        // Not a transform node, so not a Heightfield
        // We just need to destroy the landscape asset node
        return FHoudiniEngineUtils::DestroyHoudiniAsset( ConnectedAssetId );
    }

    // The landscape was marshalled as a heightfield, so we need to destroy and disconnect
    // the volvis nodes, all the merge node's input (each merge input is a volume for one 
    // of the layer/mask of the landscape )

    // Query the volvis node id
    // The volvis node is the fist input of the xform node
    HAPI_NodeId VolvisNodeId = -1;
    FHoudiniApi::QueryNodeInput(
        FHoudiniEngine::Get().GetSession(),
        ConnectedAssetId, 0, &VolvisNodeId );

    // First, destroy the merge node and its inputs
    // The merge node is in the first input of the volvis node
    HAPI_NodeId MergeNodeId = -1;
    FHoudiniApi::QueryNodeInput(
            FHoudiniEngine::Get().GetSession(),
            VolvisNodeId, 0, &MergeNodeId );

    if ( MergeNodeId != -1 )
    {
        // Get the merge node info
        HAPI_NodeInfo NodeInfo;
        FHoudiniApi::NodeInfo_Init(&NodeInfo);
        HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::GetNodeInfo(
            FHoudiniEngine::Get().GetSession(), MergeNodeId, &NodeInfo ), false );

        for ( int32 n = 0; n < NodeInfo.inputCount; n++ )
        {
            // Get the Input node ID from the host ID
            HAPI_NodeId InputNodeId = -1;
            if ( HAPI_RESULT_SUCCESS != FHoudiniApi::QueryNodeInput(
                FHoudiniEngine::Get().GetSession(),
                MergeNodeId, n, &InputNodeId ) )
                break;

            if ( InputNodeId == -1 )
                break;

            // Disconnect and Destroy that input
            FHoudiniEngineUtils::HapiDisconnectAsset( MergeNodeId, n );
            FHoudiniEngineUtils::DestroyHoudiniAsset( InputNodeId );
        }
    }

    // Second step, destroy all the volumes GEO assets
    for ( HAPI_NodeId AssetNodeId : CreatedInputAssetIds )
    {
        FHoudiniEngineUtils::DestroyHoudiniAsset( AssetNodeId );
    }
    CreatedInputAssetIds.Empty();

    // Finally disconnect and destroy the xform, volvis and merge nodes, then destroy them
    FHoudiniEngineUtils::HapiDisconnectAsset( ConnectedAssetId, 0 );
    FHoudiniEngineUtils::HapiDisconnectAsset( VolvisNodeId, 0 );
    FHoudiniEngineUtils::DestroyHoudiniAsset( MergeNodeId );
    FHoudiniEngineUtils::DestroyHoudiniAsset( VolvisNodeId );

    return FHoudiniEngineUtils::DestroyHoudiniAsset( ConnectedAssetId );
}

FColor
FHoudiniLandscapeUtils::PickVertexColorFromTextureMip(
    const uint8 * MipBytes, FVector2D & UVCoord, int32 MipWidth, int32 MipHeight )
{
    check( MipBytes );

    FColor ResultColor( 0, 0, 0, 255 );

    if ( UVCoord.X >= 0.0f && UVCoord.X < 1.0f && UVCoord.Y >= 0.0f && UVCoord.Y < 1.0f )
    {
        const int32 X = MipWidth * UVCoord.X;
        const int32 Y = MipHeight * UVCoord.Y;

        const int32 Index = ( ( Y * MipWidth ) + X ) * 4;

        ResultColor.B = MipBytes[ Index + 0 ];
        ResultColor.G = MipBytes[ Index + 1 ];
        ResultColor.R = MipBytes[ Index + 2 ];
        ResultColor.A = MipBytes[ Index + 3 ];
    }

    return ResultColor;
}

#if WITH_EDITOR
bool 
FHoudiniLandscapeUtils::ExtractLandscapeData(
    ALandscapeProxy * LandscapeProxy, TSet<ULandscapeComponent *>& SelectedComponents,
    const bool& bExportLighting, const bool& bExportTileUVs, const bool& bExportNormalizedUVs,
    TArray<FVector>& LandscapePositionArray,
    TArray<FVector>& LandscapeNormalArray,
    TArray<FVector>& LandscapeUVArray, 
    TArray<FIntPoint>& LandscapeComponentVertexIndicesArray, 
    TArray<const char *>& LandscapeComponentNameArray,
    TArray<FLinearColor>& LandscapeLightmapValues )
{
    if ( !LandscapeProxy )
        return false;

    if ( SelectedComponents.Num() < 1 )
        return false;

    // Get runtime settings.
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();

    float GeneratedGeometryScaleFactor = HAPI_UNREAL_SCALE_FACTOR_POSITION;
    EHoudiniRuntimeSettingsAxisImport ImportAxis = HRSAI_Unreal;

    if ( HoudiniRuntimeSettings )
    {
        GeneratedGeometryScaleFactor = HoudiniRuntimeSettings->GeneratedGeometryScaleFactor;
        ImportAxis = HoudiniRuntimeSettings->ImportAxis;
    }

    // Calc all the needed sizes
    int32 ComponentSizeQuads = ( ( LandscapeProxy->ComponentSizeQuads + 1 ) >> LandscapeProxy->ExportLOD ) - 1;
    float ScaleFactor = (float)LandscapeProxy->ComponentSizeQuads / (float)ComponentSizeQuads;

    int32 NumComponents = SelectedComponents.Num();
    bool bExportOnlySelected = NumComponents != LandscapeProxy->LandscapeComponents.Num();

    int32 VertexCountPerComponent = FMath::Square( ComponentSizeQuads + 1 );
    int32 VertexCount = NumComponents * VertexCountPerComponent;
    if ( !VertexCount )
        return false;

    // Initialize the data arrays    
    LandscapePositionArray.SetNumUninitialized( VertexCount );
    LandscapeNormalArray.SetNumUninitialized( VertexCount );
    LandscapeUVArray.SetNumUninitialized( VertexCount );
    LandscapeComponentNameArray.SetNumUninitialized( VertexCount );
    LandscapeComponentVertexIndicesArray.SetNumUninitialized( VertexCount );    
    if ( bExportLighting )
        LandscapeLightmapValues.SetNumUninitialized( VertexCount );

    //-----------------------------------------------------------------------------------------------------------------
    // EXTRACT THE LANDSCAPE DATA
    //-----------------------------------------------------------------------------------------------------------------
    FIntPoint IntPointMax = FIntPoint::ZeroValue;

    int32 AllPositionsIdx = 0;
    for ( int32 ComponentIdx = 0; ComponentIdx < LandscapeProxy->LandscapeComponents.Num(); ComponentIdx++ )
    {
        ULandscapeComponent * LandscapeComponent = LandscapeProxy->LandscapeComponents[ ComponentIdx ];
        if ( bExportOnlySelected && !SelectedComponents.Contains( LandscapeComponent ) )
            continue;

        TArray64< uint8 > LightmapMipData;
        int32 LightmapMipSizeX = 0;
        int32 LightmapMipSizeY = 0;

        // See if we need to export lighting information.
        if ( bExportLighting )
        {
            const FMeshMapBuildData* MapBuildData = LandscapeComponent->GetMeshMapBuildData();
            FLightMap2D* LightMap2D = MapBuildData && MapBuildData->LightMap ? MapBuildData->LightMap->GetLightMap2D() : nullptr;
            if ( LightMap2D && LightMap2D->IsValid( 0 ) )
            {
                UTexture2D * TextureLightmap = LightMap2D->GetTexture( 0 );
                if ( TextureLightmap )
                {
                    if ( TextureLightmap->Source.GetMipData(LightmapMipData, 0, 0, 0, nullptr))
                    {
                        LightmapMipSizeX = TextureLightmap->Source.GetSizeX();
                        LightmapMipSizeY = TextureLightmap->Source.GetSizeY();
                    }
                    else
                    {
                        LightmapMipData.Empty();
                    }
                }
            }
        }

        // Construct landscape component data interface to access raw data.
        FLandscapeComponentDataInterface CDI( LandscapeComponent, LandscapeProxy->ExportLOD );

        // Get name of this landscape component.
        char * LandscapeComponentNameStr = FHoudiniEngineUtils::ExtractRawName( LandscapeComponent->GetName() );

        for ( int32 VertexIdx = 0; VertexIdx < VertexCountPerComponent; VertexIdx++ )
        {
            int32 VertX = 0;
            int32 VertY = 0;
            CDI.VertexIndexToXY( VertexIdx, VertX, VertY );

            // Get position.
            FVector PositionVector = CDI.GetWorldVertex( VertX, VertY );

            // Get normal / tangent / binormal.
            FVector Normal = FVector::ZeroVector;
            FVector TangentX = FVector::ZeroVector;
            FVector TangentY = FVector::ZeroVector;
            CDI.GetLocalTangentVectors( VertX, VertY, TangentX, TangentY, Normal );

            // Export UVs.
            FVector TextureUV = FVector::ZeroVector;
            if ( bExportTileUVs )
            {
                // We want to export uvs per tile.
                TextureUV = FVector( VertX, VertY, 0.0f );

                // If we need to normalize UV space.
                if ( bExportNormalizedUVs )
                    TextureUV /= ComponentSizeQuads;
            }
            else
            {
                // We want to export global uvs (default).
                FIntPoint IntPoint = LandscapeComponent->GetSectionBase();
                TextureUV = FVector( VertX * ScaleFactor + IntPoint.X, VertY * ScaleFactor + IntPoint.Y, 0.0f );

                // Keep track of max offset.
                IntPointMax = IntPointMax.ComponentMax( IntPoint );
            }

            if ( bExportLighting )
            {
                FLinearColor VertexLightmapColor( 0.0f, 0.0f, 0.0f, 1.0f );
                if ( LightmapMipData.Num() > 0 )
                {
                    FVector2D UVCoord( VertX, VertY );
                    UVCoord /= ( ComponentSizeQuads + 1 );

                    FColor LightmapColorRaw = PickVertexColorFromTextureMip(
                        LightmapMipData.GetData(), UVCoord, LightmapMipSizeX, LightmapMipSizeY );

                    VertexLightmapColor = LightmapColorRaw.ReinterpretAsLinear();
                }

                LandscapeLightmapValues[ AllPositionsIdx ] = VertexLightmapColor;
            }

            // Retrieve component transform.
            const FTransform & ComponentTransform = LandscapeComponent->GetComponentTransform();

            // Retrieve component scale.
            const FVector & ScaleVector = ComponentTransform.GetScale3D();

            // Perform normalization.
            Normal /= ScaleVector;
            Normal.Normalize();

            TangentX /= ScaleVector;
            TangentX.Normalize();

            TangentY /= ScaleVector;
            TangentY.Normalize();

            // Perform position scaling.
            FVector PositionTransformed = PositionVector / GeneratedGeometryScaleFactor;
            if ( ImportAxis == HRSAI_Unreal )
            {
                LandscapePositionArray[ AllPositionsIdx ].X = PositionTransformed.X;
                LandscapePositionArray[ AllPositionsIdx ].Y = PositionTransformed.Z;
                LandscapePositionArray[ AllPositionsIdx ].Z = PositionTransformed.Y;

                Swap( Normal.Y, Normal.Z );
            }
            else if ( ImportAxis == HRSAI_Houdini )
            {
                LandscapePositionArray[ AllPositionsIdx ].X = PositionTransformed.X;
                LandscapePositionArray[ AllPositionsIdx ].Y = PositionTransformed.Y;
                LandscapePositionArray[ AllPositionsIdx ].Z = PositionTransformed.Z;
            }
            else
            {
                // Not a valid enum value.
                check( 0 );
            }

            // Store landscape component name for this point.
            LandscapeComponentNameArray[ AllPositionsIdx ] = LandscapeComponentNameStr;

            // Store vertex index (x,y) for this point.
            LandscapeComponentVertexIndicesArray[ AllPositionsIdx ].X = VertX;
            LandscapeComponentVertexIndicesArray[ AllPositionsIdx ].Y = VertY;

            // Store point normal.
            LandscapeNormalArray[ AllPositionsIdx ] = Normal;

            // Store uv.
            LandscapeUVArray[ AllPositionsIdx ] = TextureUV;

            AllPositionsIdx++;
        }
    }

    // If we need to normalize UV space and we are doing global UVs.
    if ( !bExportTileUVs && bExportNormalizedUVs )
    {
        IntPointMax += FIntPoint( ComponentSizeQuads, ComponentSizeQuads );
        IntPointMax = IntPointMax.ComponentMax( FIntPoint( 1, 1 ) );

        for ( int32 UVIdx = 0; UVIdx < VertexCount; ++UVIdx )
        {
            FVector & PositionUV = LandscapeUVArray[ UVIdx ];
            PositionUV.X /= IntPointMax.X;
            PositionUV.Y /= IntPointMax.Y;
        }
    }

    return true;
}
#endif

bool FHoudiniLandscapeUtils::AddLandscapePositionAttribute( const HAPI_NodeId& NodeId, const TArray< FVector >& LandscapePositionArray )
{
    int32 VertexCount = LandscapePositionArray.Num();
    if ( VertexCount < 3 )
        return false;

    // Create point attribute info containing positions.    
    HAPI_AttributeInfo AttributeInfoPointPosition;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointPosition);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointPosition );
    AttributeInfoPointPosition.count = VertexCount;
    AttributeInfoPointPosition.tupleSize = 3;
    AttributeInfoPointPosition.exists = true;
    AttributeInfoPointPosition.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointPosition.storage = HAPI_STORAGETYPE_FLOAT;
    AttributeInfoPointPosition.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        HAPI_UNREAL_ATTRIB_POSITION, &AttributeInfoPointPosition ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeFloatData(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        HAPI_UNREAL_ATTRIB_POSITION, &AttributeInfoPointPosition,
        (const float *)LandscapePositionArray.GetData(),
        0, AttributeInfoPointPosition.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeNormalAttribute( const HAPI_NodeId& NodeId, const TArray<FVector>& LandscapeNormalArray )
{
    int32 VertexCount = LandscapeNormalArray.Num();
    if ( VertexCount < 3 )
        return false;

    HAPI_AttributeInfo AttributeInfoPointNormal;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointNormal);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointNormal );
    AttributeInfoPointNormal.count = VertexCount;
    AttributeInfoPointNormal.tupleSize = 3;
    AttributeInfoPointNormal.exists = true;
    AttributeInfoPointNormal.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointNormal.storage = HAPI_STORAGETYPE_FLOAT;
    AttributeInfoPointNormal.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, HAPI_UNREAL_ATTRIB_NORMAL, &AttributeInfoPointNormal ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeFloatData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, HAPI_UNREAL_ATTRIB_NORMAL, &AttributeInfoPointNormal,
        (const float *)LandscapeNormalArray.GetData(), 0, AttributeInfoPointNormal.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeUVAttribute( const HAPI_NodeId& NodeId, const TArray<FVector>& LandscapeUVArray )
{
    int32 VertexCount = LandscapeUVArray.Num();
    if ( VertexCount < 3 )
        return false;

    HAPI_AttributeInfo AttributeInfoPointUV;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointUV);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointUV );
    AttributeInfoPointUV.count = VertexCount;
    AttributeInfoPointUV.tupleSize = 3;
    AttributeInfoPointUV.exists = true;
    AttributeInfoPointUV.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointUV.storage = HAPI_STORAGETYPE_FLOAT;
    AttributeInfoPointUV.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, HAPI_UNREAL_ATTRIB_UV, &AttributeInfoPointUV ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeFloatData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, HAPI_UNREAL_ATTRIB_UV, &AttributeInfoPointUV,
        (const float *)LandscapeUVArray.GetData(), 0, AttributeInfoPointUV.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeComponentVertexIndicesAttribute( const HAPI_NodeId& NodeId, const TArray<FIntPoint>& LandscapeComponentVertexIndicesArray )
{
    int32 VertexCount = LandscapeComponentVertexIndicesArray.Num();
    if ( VertexCount < 3 )
        return false;

    HAPI_AttributeInfo AttributeInfoPointLandscapeComponentVertexIndices;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointLandscapeComponentVertexIndices);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointLandscapeComponentVertexIndices );
    AttributeInfoPointLandscapeComponentVertexIndices.count = VertexCount;
    AttributeInfoPointLandscapeComponentVertexIndices.tupleSize = 2;
    AttributeInfoPointLandscapeComponentVertexIndices.exists = true;
    AttributeInfoPointLandscapeComponentVertexIndices.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointLandscapeComponentVertexIndices.storage = HAPI_STORAGETYPE_INT;
    AttributeInfoPointLandscapeComponentVertexIndices.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, HAPI_UNREAL_ATTRIB_LANDSCAPE_VERTEX_INDEX,
        &AttributeInfoPointLandscapeComponentVertexIndices ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, HAPI_UNREAL_ATTRIB_LANDSCAPE_VERTEX_INDEX,
        &AttributeInfoPointLandscapeComponentVertexIndices,
        (const int * )LandscapeComponentVertexIndicesArray.GetData(), 0,
        AttributeInfoPointLandscapeComponentVertexIndices.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeComponentNameAttribute( const HAPI_NodeId& NodeId, const TArray<const char *>& LandscapeComponentNameArray )
{
    int32 VertexCount = LandscapeComponentNameArray.Num();
    if ( VertexCount < 3 )
        return false;

    // Create point attribute containing landscape component name.
    HAPI_AttributeInfo AttributeInfoPointLandscapeComponentNames;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointLandscapeComponentNames);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointLandscapeComponentNames );
    AttributeInfoPointLandscapeComponentNames.count = VertexCount;
    AttributeInfoPointLandscapeComponentNames.tupleSize = 1;
    AttributeInfoPointLandscapeComponentNames.exists = true;
    AttributeInfoPointLandscapeComponentNames.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointLandscapeComponentNames.storage = HAPI_STORAGETYPE_STRING;
    AttributeInfoPointLandscapeComponentNames.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        HAPI_UNREAL_ATTRIB_LANDSCAPE_TILE_NAME,
        &AttributeInfoPointLandscapeComponentNames), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeStringData(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        HAPI_UNREAL_ATTRIB_LANDSCAPE_TILE_NAME,
        &AttributeInfoPointLandscapeComponentNames,
        (const char **)LandscapeComponentNameArray.GetData(),
        0, AttributeInfoPointLandscapeComponentNames.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeLightmapColorAttribute( const HAPI_NodeId& NodeId, const TArray<FLinearColor>& LandscapeLightmapValues )
{
    int32 VertexCount = LandscapeLightmapValues.Num();

    HAPI_AttributeInfo AttributeInfoPointLightmapColor;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoPointLightmapColor);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPointLightmapColor );
    AttributeInfoPointLightmapColor.count = VertexCount;
    AttributeInfoPointLightmapColor.tupleSize = 4;
    AttributeInfoPointLightmapColor.exists = true;
    AttributeInfoPointLightmapColor.owner = HAPI_ATTROWNER_POINT;
    AttributeInfoPointLightmapColor.storage = HAPI_STORAGETYPE_FLOAT;
    AttributeInfoPointLightmapColor.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, HAPI_UNREAL_ATTRIB_LIGHTMAP_COLOR, &AttributeInfoPointLightmapColor ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeFloatData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, HAPI_UNREAL_ATTRIB_LIGHTMAP_COLOR, &AttributeInfoPointLightmapColor,
        (const float *)LandscapeLightmapValues.GetData(), 0,
        AttributeInfoPointLightmapColor.count ), false );

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeMeshIndicesAndMaterialsAttribute( 
    const HAPI_NodeId& NodeId, const bool& bExportMaterials,
    const int32& ComponentSizeQuads, const int32& QuadCount,
    ALandscapeProxy * LandscapeProxy,
    const TSet< ULandscapeComponent * >& SelectedComponents )
{
    if ( !LandscapeProxy )
        return false;

    // Compute number of necessary indices.
    int32 IndexCount = QuadCount * 4;
    if ( IndexCount < 0 )
        return false;

    int32 VertexCountPerComponent = FMath::Square( ComponentSizeQuads + 1 );

    // Get runtime settings.
    EHoudiniRuntimeSettingsAxisImport ImportAxis = HRSAI_Unreal;
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if ( HoudiniRuntimeSettings )
        ImportAxis = HoudiniRuntimeSettings->ImportAxis;

    // Array holding indices data.
    TArray< int32 > LandscapeIndices;
    LandscapeIndices.SetNumUninitialized( IndexCount );

    // Allocate space for face names.
    // The LandscapeMaterial and HoleMaterial per point
    TArray< const char * > FaceMaterials;
    TArray< const char * > FaceHoleMaterials;
    FaceMaterials.SetNumUninitialized( QuadCount );
    FaceHoleMaterials.SetNumUninitialized( QuadCount );

    int32 VertIdx = 0;
    int32 QuadIdx = 0;

    char * MaterialRawStr = nullptr;
    char * MaterialHoleRawStr = nullptr;

    const int32 QuadComponentCount = ComponentSizeQuads + 1;
    for ( int32 ComponentIdx = 0; ComponentIdx < LandscapeProxy->LandscapeComponents.Num(); ComponentIdx++ )
    {
        ULandscapeComponent * LandscapeComponent = LandscapeProxy->LandscapeComponents[ ComponentIdx ];
        if ( !SelectedComponents.Contains( LandscapeComponent ) )
            continue;

        if ( bExportMaterials )
        {
            // If component has an override material, we need to get the raw name (if exporting materials).
            if ( LandscapeComponent->OverrideMaterial )
            {
                MaterialRawStr = FHoudiniEngineUtils::ExtractRawName(LandscapeComponent->OverrideMaterial->GetName());
            }

            // If component has an override hole material, we need to get the raw name (if exporting materials).
            if ( LandscapeComponent->OverrideHoleMaterial )
            {
                MaterialHoleRawStr = FHoudiniEngineUtils::ExtractRawName(LandscapeComponent->OverrideHoleMaterial->GetName());
            }
        }

        int32 BaseVertIndex = ComponentIdx * VertexCountPerComponent;
        for ( int32 YIdx = 0; YIdx < ComponentSizeQuads; YIdx++ )
        {
            for ( int32 XIdx = 0; XIdx < ComponentSizeQuads; XIdx++ )
            {
                if ( ImportAxis == HRSAI_Unreal )
                {
                    LandscapeIndices[ VertIdx + 0 ] = BaseVertIndex + ( XIdx + 0 ) + ( YIdx + 0 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 1 ] = BaseVertIndex + ( XIdx + 1 ) + ( YIdx + 0 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 2 ] = BaseVertIndex + ( XIdx + 1 ) + ( YIdx + 1 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 3 ] = BaseVertIndex + ( XIdx + 0 ) + ( YIdx + 1 ) * QuadComponentCount;
                }
                else if (ImportAxis == HRSAI_Houdini)
                {
                    LandscapeIndices[ VertIdx + 0 ] = BaseVertIndex + ( XIdx + 0 ) + ( YIdx + 0 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 1 ] = BaseVertIndex + ( XIdx + 0 ) + ( YIdx + 1 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 2 ] = BaseVertIndex + ( XIdx + 1 ) + ( YIdx + 1 ) * QuadComponentCount;
                    LandscapeIndices[ VertIdx + 3 ] = BaseVertIndex + ( XIdx + 1 ) + ( YIdx + 0 ) * QuadComponentCount;
                }
                else
                {
                   // Not a valid enum value.
                    check( 0 );
                }

                // Store override materials (if exporting materials).
                if ( bExportMaterials )
                {
                    FaceMaterials[ QuadIdx ] = MaterialRawStr;
                    FaceHoleMaterials[ QuadIdx ] = MaterialHoleRawStr;
                }

                VertIdx += 4;
                QuadIdx++;
            }
        }
    }

    // We can now set vertex list.
    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetVertexList(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, LandscapeIndices.GetData(), 0, LandscapeIndices.Num() ), false );

    // We need to generate array of face counts.
    TArray< int32 > LandscapeFaces;
    LandscapeFaces.Init( 4, QuadCount );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetFaceCounts(
        FHoudiniEngine::Get().GetSession(), NodeId,
        0, LandscapeFaces.GetData(), 0, LandscapeFaces.Num() ), false );

    if ( bExportMaterials )
    {
        if ( !FaceMaterials.Contains( nullptr ) )
        {
            // Get name of attribute used for marshalling materials.
            std::string MarshallingAttributeMaterialName = HAPI_UNREAL_ATTRIB_MATERIAL;
            if ( HoudiniRuntimeSettings && !HoudiniRuntimeSettings->MarshallingAttributeMaterial.IsEmpty() )
            {
                FHoudiniEngineUtils::ConvertUnrealString(
                    HoudiniRuntimeSettings->MarshallingAttributeMaterial,
                    MarshallingAttributeMaterialName );
            }

            // Marshall in override primitive material names.
            HAPI_AttributeInfo AttributeInfoPrimitiveMaterial;
            FHoudiniApi::AttributeInfo_Init(&AttributeInfoPrimitiveMaterial);
            //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPrimitiveMaterial );
            AttributeInfoPrimitiveMaterial.count = FaceMaterials.Num();
            AttributeInfoPrimitiveMaterial.tupleSize = 1;
            AttributeInfoPrimitiveMaterial.exists = true;
            AttributeInfoPrimitiveMaterial.owner = HAPI_ATTROWNER_PRIM;
            AttributeInfoPrimitiveMaterial.storage = HAPI_STORAGETYPE_STRING;
            AttributeInfoPrimitiveMaterial.originalOwner = HAPI_ATTROWNER_INVALID;

            HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
                FHoudiniEngine::Get().GetSession(), NodeId, 0,
                MarshallingAttributeMaterialName.c_str(), &AttributeInfoPrimitiveMaterial ), false );

            HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeStringData(
                FHoudiniEngine::Get().GetSession(), NodeId, 0,
                MarshallingAttributeMaterialName.c_str(), &AttributeInfoPrimitiveMaterial,
                (const char **)FaceMaterials.GetData(), 0, AttributeInfoPrimitiveMaterial.count ), false );
        }

        if ( !FaceHoleMaterials.Contains( nullptr ) )
        {
            // Get name of attribute used for marshalling hole materials.
            std::string MarshallingAttributeMaterialHoleName = HAPI_UNREAL_ATTRIB_MATERIAL_HOLE;
            if ( HoudiniRuntimeSettings && !HoudiniRuntimeSettings->MarshallingAttributeMaterialHole.IsEmpty() )
            {
                FHoudiniEngineUtils::ConvertUnrealString(
                    HoudiniRuntimeSettings->MarshallingAttributeMaterialHole,
                    MarshallingAttributeMaterialHoleName );
            }

            // Marshall in override primitive material hole names.
            HAPI_AttributeInfo AttributeInfoPrimitiveMaterialHole;
            FHoudiniApi::AttributeInfo_Init(&AttributeInfoPrimitiveMaterialHole);
            //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoPrimitiveMaterialHole );
            AttributeInfoPrimitiveMaterialHole.count = FaceHoleMaterials.Num();
            AttributeInfoPrimitiveMaterialHole.tupleSize = 1;
            AttributeInfoPrimitiveMaterialHole.exists = true;
            AttributeInfoPrimitiveMaterialHole.owner = HAPI_ATTROWNER_PRIM;
            AttributeInfoPrimitiveMaterialHole.storage = HAPI_STORAGETYPE_STRING;
            AttributeInfoPrimitiveMaterialHole.originalOwner = HAPI_ATTROWNER_INVALID;

            HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
                FHoudiniEngine::Get().GetSession(),
                NodeId, 0, MarshallingAttributeMaterialHoleName.c_str(),
                &AttributeInfoPrimitiveMaterialHole ), false );

            HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeStringData(
                FHoudiniEngine::Get().GetSession(),
                NodeId, 0, MarshallingAttributeMaterialHoleName.c_str(),
                &AttributeInfoPrimitiveMaterialHole, (const char **) FaceHoleMaterials.GetData(), 0,
                AttributeInfoPrimitiveMaterialHole.count ), false );
        }
    }

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeTileAttribute(
    const HAPI_NodeId& NodeId, const HAPI_PartId& PartId, const int32& TileIdx )
{
    HAPI_AttributeInfo AttributeInfoTileIndex;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoTileIndex);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoTileIndex );
    AttributeInfoTileIndex.count = 1;
    AttributeInfoTileIndex.tupleSize = 1;
    AttributeInfoTileIndex.exists = true;
    AttributeInfoTileIndex.owner = HAPI_ATTROWNER_PRIM;
    AttributeInfoTileIndex.storage = HAPI_STORAGETYPE_INT;
    AttributeInfoTileIndex.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId,
        PartId, "tile", &AttributeInfoTileIndex ), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "tile", &AttributeInfoTileIndex,
        (const int *)&TileIdx, 0, AttributeInfoTileIndex.count ), false );

    return true;
}

// Add the landscape component extent attribute
bool FHoudiniLandscapeUtils::AddLandscapeComponentExtentAttributes(
    const HAPI_NodeId& NodeId, const HAPI_PartId& PartId,
    const int32& MinX, const int32& MaxX,
    const int32& MinY, const int32& MaxY )
{
    // Create an AttributeInfo
    HAPI_AttributeInfo AttributeInfo;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfo);
    //FMemory::Memzero< HAPI_AttributeInfo >(AttributeInfo);
    AttributeInfo.count = 1;
    AttributeInfo.tupleSize = 1;
    AttributeInfo.exists = true;
    AttributeInfo.owner = HAPI_ATTROWNER_PRIM;
    AttributeInfo.storage = HAPI_STORAGETYPE_INT;
    AttributeInfo.originalOwner = HAPI_ATTROWNER_INVALID;

    // Add the landscape_component_min_X primitive attribute
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(),
        NodeId,    PartId,    "landscape_component_min_X", &AttributeInfo ), false);

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_min_X", &AttributeInfo,
        (const int *)&MinX, 0, AttributeInfo.count), false);

    // Add the landscape_component_max_X primitive attribute
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_max_X", &AttributeInfo), false);

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_max_X", &AttributeInfo,
        (const int *)&MaxX, 0, AttributeInfo.count), false);

    // Add the landscape_component_min_Y primitive attribute
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_min_Y", &AttributeInfo), false);

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_min_Y", &AttributeInfo,
        (const int *)&MinY, 0, AttributeInfo.count), false);

    // Add the landscape_component_max_Y primitive attribute
    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_max_Y", &AttributeInfo), false);

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetAttributeIntData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, PartId, "landscape_component_max_Y", &AttributeInfo,
        (const int *)&MaxY, 0, AttributeInfo.count), false);

    return true;
}

// Read the landscape component extent attribute from a heightfield
bool FHoudiniLandscapeUtils::GetLandscapeComponentExtentAttributes(
    const FHoudiniGeoPartObject& HoudiniGeoPartObject,
    int32& MinX, int32& MaxX,
    int32& MinY, int32& MaxY )
{
    // If we dont have minX, we likely dont have the others too
    if ( !FHoudiniEngineUtils::HapiCheckAttributeExists(
        HoudiniGeoPartObject, "landscape_component_min_X", HAPI_ATTROWNER_PRIM) )
        return false;

    // Create an AttributeInfo
    HAPI_AttributeInfo AttributeInfo;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfo);
    //FMemory::Memzero< HAPI_AttributeInfo >(AttributeInfo);

    // Get MinX
    TArray<int32> IntData;
    if ( !FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
        HoudiniGeoPartObject, "landscape_component_min_X", AttributeInfo, IntData, 1, HAPI_ATTROWNER_PRIM ) )
        return false;

    if ( IntData.Num() > 0 )
        MinX = IntData[0];

    // Get MaxX
    if (!FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
        HoudiniGeoPartObject, "landscape_component_max_X", AttributeInfo, IntData, 1, HAPI_ATTROWNER_PRIM))
        return false;

    if (IntData.Num() > 0)
        MaxX = IntData[0];

    // Get MinY
    if (!FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
        HoudiniGeoPartObject, "landscape_component_min_Y", AttributeInfo, IntData, 1, HAPI_ATTROWNER_PRIM))
        return false;

    if (IntData.Num() > 0)
        MinY = IntData[0];

    // Get MaxX
    if (!FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
        HoudiniGeoPartObject, "landscape_component_max_Y", AttributeInfo, IntData, 1, HAPI_ATTROWNER_PRIM))
        return false;

    if (IntData.Num() > 0)
        MaxY = IntData[0];

    return true;
}

#if WITH_EDITOR
bool
FHoudiniLandscapeUtils::CreateAllLandscapes( 
    FHoudiniCookParams& HoudiniCookParams,
    const TArray< FHoudiniGeoPartObject > & FoundVolumes, 
    TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >& Landscapes,
    TMap< FHoudiniGeoPartObject, TWeakObjectPtr<ALandscapeProxy> >& NewLandscapes,
    TArray<ALandscapeProxy *>& InputLandscapeToUpdate,
    float ForcedZMin , float ForcedZMax )
{
    // Get runtime settings.
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if ( HoudiniRuntimeSettings && HoudiniRuntimeSettings->MarshallingLandscapesForceMinMaxValues )
    {
        ForcedZMin = HoudiniRuntimeSettings->MarshallingLandscapesForcedMinValue;
        ForcedZMax = HoudiniRuntimeSettings->MarshallingLandscapesForcedMaxValue;
    }

    // First, we need to extract proper height data from FoundVolumes
    TArray< const FHoudiniGeoPartObject* > FoundHeightfields;
    FHoudiniLandscapeUtils::GetHeightfieldsInArray( FoundVolumes, FoundHeightfields );

    // If we have multiple heightfields, we want to convert them using the same Z range
    // Either that range has been specified/forced by the user, or we'll have to calculate it from all the height volumes.
    float fGlobalMin = ForcedZMin, fGlobalMax = ForcedZMax;
    if ( FoundHeightfields.Num() > 1 && ( fGlobalMin == 0.0f && fGlobalMax == 0.0f ) )
        FHoudiniLandscapeUtils::CalcHeightfieldsArrayGlobalZMinZMax( FoundHeightfields, fGlobalMin, fGlobalMax );

    // We want to be doing a similar things for the mask/layer volumes
    TMap<FString, float> GlobalMinimums;
    TMap<FString, float> GlobalMaximums;
    if ( FoundVolumes.Num() > 1 )
        FHoudiniLandscapeUtils::CalcHeightfieldsArrayGlobalZMinZMax( FoundVolumes, GlobalMinimums, GlobalMaximums );

    // Try to create a Landscape for each HeightData found
    NewLandscapes.Empty();
    for (TArray< const FHoudiniGeoPartObject* >::TConstIterator IterHeighfields(FoundHeightfields); IterHeighfields; ++IterHeighfields)
    {
        // Get the current Heightfield GeoPartObject
        const FHoudiniGeoPartObject* CurrentHeightfield = *IterHeighfields;
        if (!CurrentHeightfield)
            continue;

        // Look for the unreal_landscape_streaming_proxy attribute on the height volume
        bool bCreateLandscapeStreamingProxy = false;
        TArray<int32> IntData;
        HAPI_AttributeInfo AttributeInfo;
        FHoudiniApi::AttributeInfo_Init(&AttributeInfo);
        //FMemory::Memzero< HAPI_AttributeInfo >(AttributeInfo);
        if (FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
            CurrentHeightfield->AssetId, CurrentHeightfield->ObjectId,
            CurrentHeightfield->GeoId, CurrentHeightfield->PartId,
            "unreal_landscape_streaming_proxy", AttributeInfo, IntData, 1))
        {
            if (IntData.Num() > 0 && IntData[0] != 0)
                bCreateLandscapeStreamingProxy = true;
        }

        // Try to find the landscape previously created from that HGPO
        ALandscapeProxy * FoundLandscape = nullptr;
        if (TWeakObjectPtr<ALandscapeProxy>* FoundLandscapePtr = Landscapes.Find(*CurrentHeightfield))
        {
            FoundLandscape = FoundLandscapePtr->Get();
            if (!FoundLandscape || !FoundLandscape->IsValidLowLevel())
                FoundLandscape = nullptr;
        }

        bool bLandscapeNeedsToBeUpdated = true;
        if (!CurrentHeightfield->bHasGeoChanged)
        {
            // The Geo has not changed, do we need to recreate the landscape?
            if (FoundLandscape)
            {
                // Check that all layers/mask have not changed too
                TArray< const FHoudiniGeoPartObject* > FoundLayers;
                FHoudiniLandscapeUtils::GetHeightfieldsLayersInArray(FoundVolumes, *CurrentHeightfield, FoundLayers);

                bool bLayersHaveChanged = false;
                for (int32 n = 0; n < FoundLayers.Num(); n++)
                {
                    if (FoundLayers[n] && FoundLayers[n]->bHasGeoChanged)
                    {
                        bLayersHaveChanged = true;
                        break;
                    }
                }

                if (!bLayersHaveChanged)
                {
                    // Height and layers/masks have not changed, there is no need to reimport the landscape
                    bLandscapeNeedsToBeUpdated = false;
                }

                // Force update/recreation if the actor is not of the desired type
                if ( (!FoundLandscape->IsA(ALandscapeStreamingProxy::StaticClass()) && bCreateLandscapeStreamingProxy)
                    || (FoundLandscape->IsA(ALandscapeStreamingProxy::StaticClass()) && !bCreateLandscapeStreamingProxy) )
                    bLandscapeNeedsToBeUpdated = true;
            }
        }

        // Height and mask volumes have not changed
        // No need to update the Landscape
        if (!bLandscapeNeedsToBeUpdated)
        {
            // We can add the landscape to the map and remove it from the old one to avoid its destruction
            NewLandscapes.Add(*CurrentHeightfield, FoundLandscape);
            Landscapes.Remove(*CurrentHeightfield);
            continue;
        }
            
        HAPI_NodeId HeightFieldNodeId = CurrentHeightfield->HapiGeoGetNodeId();

        // We need to see if the current heightfield has an unreal_material or unreal_hole_material assigned to it
        UMaterialInterface* LandscapeMaterial = nullptr;
        UMaterialInterface* LandscapeHoleMaterial = nullptr;
        FHoudiniLandscapeUtils::GetHeightFieldLandscapeMaterials(*CurrentHeightfield, LandscapeMaterial, LandscapeHoleMaterial);

        // Extract the Float Data from the Heightfield
        TArray< float > FloatValues;
        HAPI_VolumeInfo VolumeInfo;
        float FloatMin, FloatMax;
        if (!FHoudiniLandscapeUtils::GetHeightfieldData(*CurrentHeightfield, FloatValues, VolumeInfo, FloatMin, FloatMax))
            continue;

        // Do we need to convert the heightfields using the same global Min/Max
        if (fGlobalMin != fGlobalMax)
        {
            FloatMin = fGlobalMin;
            FloatMax = fGlobalMax;
        }

        // See if we need to create a new Landscape Actor for this heightfield:
        // Either we haven't created one yet, or it's size has changed
        int32 HoudiniXSize = VolumeInfo.yLength;
        int32 HoudiniYSize = VolumeInfo.xLength;
        int32 UnrealXSize = -1;
        int32 UnrealYSize = -1;
        int32 NumSectionPerLandscapeComponent = -1;
        int32 NumQuadsPerLandscapeSection = -1;
        if (!FHoudiniLandscapeUtils::CalcLandscapeSizeFromHeightfieldSize(
            HoudiniXSize, HoudiniYSize,
            UnrealXSize, UnrealYSize,
            NumSectionPerLandscapeComponent,
            NumQuadsPerLandscapeSection))
            continue;

        // See if the Heightfield has component extent attributes
        // This would mean that we'd need to update parts of the landscape only 
        bool UpdateLandscapeComponent = false;
        int32 MinX, MaxX, MinY, MaxY;
        bool HasComponentExtent = GetLandscapeComponentExtentAttributes(
            *CurrentHeightfield, MinX, MaxX, MinY, MaxY);

        // Try to see if we have an input landscape that matches the size of the current HGPO
        bool UpdatingInputLandscape = false;
        for (int nIdx = 0; nIdx < InputLandscapeToUpdate.Num(); nIdx++)
        {
            ALandscapeProxy* CurrentInputLandscape = InputLandscapeToUpdate[nIdx];
            if (!CurrentInputLandscape)
                continue;

            ULandscapeInfo* CurrentInfo = CurrentInputLandscape->GetLandscapeInfo();
            if (!CurrentInfo)
                continue;

            int32 InputMinX = 0;
            int32 InputMinY = 0;
            int32 InputMaxX = 0;
            int32 InputMaxY = 0;
            CurrentInfo->GetLandscapeExtent(InputMinX, InputMinY, InputMaxX, InputMaxY);

            // If the full size matches, we'll update that input landscape
            bool SizeMatch = false;
            if ((InputMaxX - InputMinX + 1) == UnrealXSize && (InputMaxY - InputMinY + 1) == UnrealYSize)
                SizeMatch = true;

            /*
            // If not, see if we could update that landscape's components instead of the full landscape
            if ( !SizeMatch && HasComponentExtent )
            {
                if ( (MinX >= InputMinX) && (MinX <= InputMaxX)
                    && (MinY >= InputMinY) && (MinY <= InputMaxY)
                    && (MaxX >= InputMinX) && (MaxX <= InputMaxX)
                    && (MaxY >= InputMinY) && (MaxY <= InputMaxY) )
                {
                    // Try to update this landscape component data
                    SizeMatch = true;
                    UpdateLandscapeComponent = true;
                }
            }
            */

            // HF and landscape don't match, try another one
            if ( !SizeMatch )
                continue;

            // Replace FoundLandscape by that input landscape
            FoundLandscape = CurrentInputLandscape;

            // If we're not updating part of that landscape via components, 
            // Remove that landscape from the input array so we dont try to update it twice
            if ( !UpdateLandscapeComponent )
                InputLandscapeToUpdate.RemoveAt(nIdx);

            UpdatingInputLandscape = true;
        }

        // See if we need to create a new Landscape Actor for this heightfield
        // Either we haven't created one yet, or it's size has changed
        bool bLandscapeNeedsRecreate = true;
        if ( UpdatingInputLandscape )
        {
            // No need to create a new landscape as we're modifying the input one
            bLandscapeNeedsRecreate = false;
        }
        else if ( FoundLandscape && !FoundLandscape->IsPendingKill() )
        {
            // See if we can reuse the previous landscape
            ULandscapeInfo* PreviousInfo = FoundLandscape->GetLandscapeInfo();
            if ( PreviousInfo )
            {
                int32 PrevMinX = 0;
                int32 PrevMinY = 0;
                int32 PrevMaxX = 0;
                int32 PrevMaxY = 0;
                PreviousInfo->GetLandscapeExtent(PrevMinX, PrevMinY, PrevMaxX, PrevMaxY);

                bool SizeMatch = false;
                if ( (PrevMaxX - PrevMinX + 1) == UnrealXSize
                    && (PrevMaxY - PrevMinY + 1) == UnrealYSize )
                    SizeMatch = true;

                /*
                // If not, see if we could update that landscape's component
                if (!SizeMatch && HasComponentExtent)
                {
                    if ((MinX >= PrevMinX) && (MinX <= PrevMaxX)
                        && (MinY >= PrevMinY) && (MinY <= PrevMaxY)
                        && (MaxX >= PrevMinX) && (MaxX <= PrevMaxX)
                        && (MaxY >= PrevMinY) && (MaxY <= PrevMaxY))
                    {
                        // Try to update this landscape component data
                        SizeMatch = true;
                        UpdateLandscapeComponent = true;
                    }
                }
                */
                if ( SizeMatch )
                {
                    // We can reuse the existing actor
                    bLandscapeNeedsRecreate = false;
                }
            }
        }

        if (!bLandscapeNeedsRecreate)
        {
            // Force update/recreation if the actor is not of the desired type
            if ((!FoundLandscape->IsA(ALandscapeStreamingProxy::StaticClass()) && bCreateLandscapeStreamingProxy)
                || (FoundLandscape->IsA(ALandscapeStreamingProxy::StaticClass()) && !bCreateLandscapeStreamingProxy))
                bLandscapeNeedsRecreate = true;
        }

        if ( bLandscapeNeedsRecreate )
        {
            // We need to create a new Landscape Actor
            // Either we didnt create one before, or we cannot reuse the old one (size has changed)

            // Convert the height data from Houdini's heightfield to Unreal's Landscape
            TArray< uint16 > IntHeightData;
            FTransform LandscapeTransform;
            if (!FHoudiniLandscapeUtils::ConvertHeightfieldDataToLandscapeData(
                FloatValues, VolumeInfo,
                UnrealXSize, UnrealYSize,
                FloatMin, FloatMax,
                IntHeightData, LandscapeTransform))
                continue;

            // Look for all the layers/masks corresponding to the current heightfield
            TArray< const FHoudiniGeoPartObject* > FoundLayers;
            FHoudiniLandscapeUtils::GetHeightfieldsLayersInArray(FoundVolumes, *CurrentHeightfield, FoundLayers);

            // Extract and convert the Landscape layers
            TArray< FLandscapeImportLayerInfo > ImportLayerInfos;
            if (!FHoudiniLandscapeUtils::CreateLandscapeLayers(HoudiniCookParams, FoundLayers, *CurrentHeightfield,
                UnrealXSize, UnrealYSize, GlobalMinimums, GlobalMaximums, ImportLayerInfos))
                continue;

            // Create the actual Landscape
            ALandscapeProxy * CurrentLandscape = CreateLandscape(
                IntHeightData, ImportLayerInfos,
                LandscapeTransform, UnrealXSize, UnrealYSize,
                NumSectionPerLandscapeComponent, NumQuadsPerLandscapeSection,
                LandscapeMaterial, LandscapeHoleMaterial, bCreateLandscapeStreamingProxy );

            if (!CurrentLandscape)
                continue;

            // Update the visibility mask / layer if we have any
            for (auto CurrLayerInfo : ImportLayerInfos)
            {
                if (CurrLayerInfo.LayerInfo && CurrLayerInfo.LayerName.ToString().Equals(TEXT("Visibility"), ESearchCase::IgnoreCase))
                {
                    CurrentLandscape->VisibilityLayer = CurrLayerInfo.LayerInfo;
                    CurrentLandscape->VisibilityLayer->bNoWeightBlend = true;
                    CurrentLandscape->VisibilityLayer->AddToRoot();
                }
            }

            // Add the new landscape to the map
            NewLandscapes.Add(*CurrentHeightfield, CurrentLandscape);
        }
        else
        {
            // We're reusing an existing landscape Actor
            // Only update the height / layer data that has changed

            // Update the materials if they have changed
            if ( FoundLandscape->GetLandscapeMaterial() != LandscapeMaterial )
                FoundLandscape->LandscapeMaterial = LandscapeMaterial;

            if ( FoundLandscape->GetLandscapeHoleMaterial() != LandscapeHoleMaterial )
                FoundLandscape->LandscapeHoleMaterial = LandscapeHoleMaterial;

            // Update the previous landscape's height data
            // Decide if we need to create a new Landscape or if we can reuse the previous one
            ULandscapeInfo* PreviousInfo = FoundLandscape->GetLandscapeInfo();
            if ( !PreviousInfo )
                continue;

            FLandscapeEditDataInterface LandscapeEdit(PreviousInfo);

            // Update the height data only if it's marked as changed
            if ( CurrentHeightfield->bHasGeoChanged )
            {
                // Convert the height data from Houdini's heightfield to Unreal's Landscape
                TArray< uint16 > IntHeightData;
                FTransform LandscapeTransform;
                if ( !FHoudiniLandscapeUtils::ConvertHeightfieldDataToLandscapeData(
                    FloatValues, VolumeInfo,
                    UnrealXSize, UnrealYSize,
                    FloatMin, FloatMax,
                    IntHeightData, LandscapeTransform,
                    UpdateLandscapeComponent ) )
                    continue;

                if ( !UpdateLandscapeComponent )
                    LandscapeEdit.SetHeightData(0, 0, UnrealXSize - 1, UnrealYSize - 1, IntHeightData.GetData(), 0, true);
                else
                    LandscapeEdit.SetHeightData(MinX, MinY, MaxX, MaxY, IntHeightData.GetData(), 0, true);

                // Set the landscape Transform
                if ( !UpdateLandscapeComponent )
                    FoundLandscape->SetActorRelativeTransform(LandscapeTransform);
            }

            // Look for all the layers/masks corresponding to the current heightfield
            TArray< const FHoudiniGeoPartObject* > FoundLayers;
            FHoudiniLandscapeUtils::GetHeightfieldsLayersInArray(FoundVolumes, *CurrentHeightfield, FoundLayers);

            // Get the names of all the non weight blended layers
            TArray< FString > NonWeightBlendedLayerNames;
            FHoudiniLandscapeUtils::GetNonWeightBlendedLayerNames(*CurrentHeightfield, NonWeightBlendedLayerNames);

            for ( auto LayerGeoPartObject : FoundLayers )
            {
                if (!LayerGeoPartObject)
                    continue;

                if (!LayerGeoPartObject->IsValid())
                    continue;

                if (LayerGeoPartObject->AssetId == -1)
                    continue;

                if ( !LayerGeoPartObject->bHasGeoChanged )
                    continue;

                // Extract the layer's float data from the HF
                TArray< float > FloatLayerData;
                HAPI_VolumeInfo LayerVolumeInfo;
                FHoudiniApi::VolumeInfo_Init(&LayerVolumeInfo);

                float LayerMin = 0;
                float LayerMax = 0;
                if (!FHoudiniLandscapeUtils::GetHeightfieldData(*LayerGeoPartObject, FloatLayerData, LayerVolumeInfo, LayerMin, LayerMax))
                    continue;

                // No need to create flat layers as Unreal will remove them afterwards..
                if (LayerMin == LayerMax)
                    continue;

                // Get the layer's name
                FString LayerString;
                FHoudiniEngineString(LayerVolumeInfo.nameSH).ToFString(LayerString);

                // Check if that landscape layer has been marked as unit (range in [0-1]
                if ( IsUnitLandscapeLayer( *LayerGeoPartObject ) )
                {
                    LayerMin = 0.0f;
                    LayerMax = 1.0f;
                }
                else
                {
                    // Do we want to convert the layer's value using the global Min/Max
                    if (GlobalMaximums.Contains(LayerString))
                        LayerMax = GlobalMaximums[LayerString];

                    if (GlobalMinimums.Contains(LayerString))
                        LayerMin = GlobalMinimums[LayerString];
                }

                // Find the ImportLayerInfo and LayerInfo objects
                ObjectTools::SanitizeObjectName(LayerString);
                FName LayerName(*LayerString);
                FLandscapeImportLayerInfo currentLayerInfo(LayerName);

                UPackage * Package = nullptr;
                currentLayerInfo.LayerInfo = FHoudiniLandscapeUtils::CreateLandscapeLayerInfoObject(HoudiniCookParams, LayerString.GetCharArray().GetData(), Package, LayerGeoPartObject->GetPartId());
                if (!currentLayerInfo.LayerInfo || !Package)
                    continue;

                // Convert the float data to uint8
                if ( !FHoudiniLandscapeUtils::ConvertHeightfieldLayerToLandscapeLayer(
                    FloatLayerData, LayerVolumeInfo.yLength, LayerVolumeInfo.xLength,
                    LayerMin, LayerMax,
                    UnrealXSize, UnrealYSize,
                    currentLayerInfo.LayerData,
                    UpdateLandscapeComponent ) )
                    continue;

                // Store the data used to convert the Houdini float values to int in the DebugColor
                // This is the only way we'll be able to reconvert those values back to their houdini equivalent afterwards...
                // R = Min, G = Max, B = Spacing, A = ?
                currentLayerInfo.LayerInfo->LayerUsageDebugColor.R = LayerMin;
                currentLayerInfo.LayerInfo->LayerUsageDebugColor.G = LayerMax;
                currentLayerInfo.LayerInfo->LayerUsageDebugColor.B = (LayerMax - LayerMin) / 255.0f;
                currentLayerInfo.LayerInfo->LayerUsageDebugColor.A = PI;

                // Updated non weight blended layers (visibility is by default non weight blended)
                if (NonWeightBlendedLayerNames.Contains(LayerString) || LayerString.Equals(TEXT("visibility"), ESearchCase::IgnoreCase))
                    currentLayerInfo.LayerInfo->bNoWeightBlend = true;
                else
                    currentLayerInfo.LayerInfo->bNoWeightBlend = false;

                // Update the layer on the heightfield
                if ( !UpdateLandscapeComponent )
                    LandscapeEdit.SetAlphaData( currentLayerInfo.LayerInfo, 0, 0, UnrealXSize - 1, UnrealYSize - 1, currentLayerInfo.LayerData.GetData(), 0 );
                else
                    LandscapeEdit.SetAlphaData( currentLayerInfo.LayerInfo, MinX, MinY, MaxX, MaxY, currentLayerInfo.LayerData.GetData(), 0 );

                if ( currentLayerInfo.LayerInfo && currentLayerInfo.LayerName.ToString().Equals( TEXT("Visibility"), ESearchCase::IgnoreCase ) )
                {
                    FoundLandscape->VisibilityLayer = currentLayerInfo.LayerInfo;
                    FoundLandscape->VisibilityLayer->bNoWeightBlend = true;
                    FoundLandscape->VisibilityLayer->AddToRoot();
                }
            }

            // Update the materials if they have changed
            if (FoundLandscape->GetLandscapeMaterial() != LandscapeMaterial)
                FoundLandscape->LandscapeMaterial = LandscapeMaterial;

            if (FoundLandscape->GetLandscapeHoleMaterial() != LandscapeHoleMaterial)
                FoundLandscape->LandscapeHoleMaterial = LandscapeHoleMaterial;

            //FoundLandscape->RecreateCollisionComponents();

            //PreviousInfo->UpdateLayerInfoMap();
            //PreviousInfo->RecreateCollisionComponents();
            //PreviousInfo->UpdateAllAddCollisions();

            // We can add the landscape to the new map
            NewLandscapes.Add(*CurrentHeightfield, FoundLandscape);
        }
    }

    for (auto Iter : NewLandscapes)
    {
        FHoudiniGeoPartObject HGPO = Iter.Key;

        TWeakObjectPtr<ALandscapeProxy> Landscape = Iter.Value;
        if (!Landscape.IsValid())
            continue;

		// Update the landscape's collisions
		Landscape->RecreateCollisionComponents();

		// Handle the HF's tags
		// See if we have unreal_tag_ attribute
		TArray<FName> Tags;
		if (!FHoudiniEngineUtils::GetUnrealTagAttributes(HGPO, Tags))
			continue;

        Landscape->Tags = Tags;
    }

    return true;
}

ALandscapeProxy *
FHoudiniLandscapeUtils::CreateLandscape(
    const TArray< uint16 >& IntHeightData,
    const TArray< FLandscapeImportLayerInfo >& ImportLayerInfos,
    const FTransform& LandscapeTransform,
    const int32& XSize, const int32& YSize, 
    const int32& NumSectionPerLandscapeComponent, const int32& NumQuadsPerLandscapeSection,
    UMaterialInterface* LandscapeMaterial, UMaterialInterface* LandscapeHoleMaterial,
    const bool& CreateLandscapeStreamingProxy )
{
    if ( ( XSize < 2 ) || ( YSize < 2 ) )
        return nullptr;

    if ( IntHeightData.Num() != ( XSize * YSize ) )
        return nullptr;

    if ( !GEditor )
        return nullptr;
    
    // Get the world we'll spawn the landscape in
    UWorld* MyWorld = nullptr;
    {
        // We want to create the landscape in the landscape editor mode's world
        FWorldContext& EditorWorldContext = GEditor->GetEditorWorldContext();
        MyWorld = EditorWorldContext.World();
    }

    if ( !MyWorld )
        return nullptr;

    // We need to create the landscape now and assign it a new GUID so we can create the LayerInfos
    ALandscapeProxy* LandscapeProxy = nullptr;
    if ( CreateLandscapeStreamingProxy )
        LandscapeProxy = MyWorld->SpawnActor<ALandscapeStreamingProxy>();
    else
        LandscapeProxy = MyWorld->SpawnActor<ALandscape>();

    if (!LandscapeProxy)
        return nullptr;

    // Create a new GUID
    FGuid currentGUID = FGuid::NewGuid();
    LandscapeProxy->SetLandscapeGuid( currentGUID );

    // Set the landscape Transform
    LandscapeProxy->SetActorTransform( LandscapeTransform );

    // Autosaving the layers prevents them for being deleted with the Asset
    // Save the packages created for the LayerInfos
    //if ( CreatedLayerInfoPackage.Num() > 0 )
    //    FEditorFileUtils::PromptForCheckoutAndSave( CreatedLayerInfoPackage, true, false );

    // Import the landscape data

    // Deactivate CastStaticShadow on the landscape to avoid "grid shadow" issue
    LandscapeProxy->bCastStaticShadow = false;

    if ( LandscapeMaterial )
        LandscapeProxy->LandscapeMaterial = LandscapeMaterial;

    if ( LandscapeHoleMaterial )
        LandscapeProxy->LandscapeHoleMaterial = LandscapeHoleMaterial;

    // Setting the layer type here.
    ELandscapeImportAlphamapType ImportLayerType = ELandscapeImportAlphamapType::Additive;

	TMap<FGuid, TArray<uint16>> HeightmapDataPerLayers;
	TMap<FGuid, TArray<FLandscapeImportLayerInfo>> MaterialLayerDataPerLayer;
	HeightmapDataPerLayers.Add(FGuid(), IntHeightData);
	MaterialLayerDataPerLayer.Add(FGuid(), ImportLayerInfos);

    // Import the data
    LandscapeProxy->Import(
        currentGUID,
        0, 0, XSize - 1, YSize - 1,
        NumSectionPerLandscapeComponent, NumQuadsPerLandscapeSection,
	HeightmapDataPerLayers, NULL,
	MaterialLayerDataPerLayer, ImportLayerType );

    // Copied straight from UE source code to avoid crash after importing the landscape:
    // automatically calculate a lighting LOD that won't crash lightmass (hopefully)
    // < 2048x2048 -> LOD0,  >=2048x2048 -> LOD1,  >= 4096x4096 -> LOD2,  >= 8192x8192 -> LOD3
    LandscapeProxy->StaticLightingLOD = FMath::DivideAndRoundUp( FMath::CeilLogTwo( ( XSize * YSize ) / ( 2048 * 2048 ) + 1 ), ( uint32 )2 );

    // Register all the landscape components
    LandscapeProxy->RegisterAllComponents();

    /*ALandscape* Landscape = LandscapeProxy->GetLandscapeActor();
    if (!Landscape)
        return nullptr;*/

    return LandscapeProxy;
}

void FHoudiniLandscapeUtils::GetHeightFieldLandscapeMaterials(
    const FHoudiniGeoPartObject& Heightfield,
    UMaterialInterface*& LandscapeMaterial,
    UMaterialInterface*& LandscapeHoleMaterial )
{
    LandscapeMaterial = nullptr;
    LandscapeHoleMaterial = nullptr;

    if ( !Heightfield.IsVolume() )
        return;

    std::string MarshallingAttributeNameMaterial = HAPI_UNREAL_ATTRIB_MATERIAL;
    std::string MarshallingAttributeNameMaterialInstance = HAPI_UNREAL_ATTRIB_MATERIAL_INSTANCE; 
    std::string MarshallingAttributeNameMaterialHole = HAPI_UNREAL_ATTRIB_MATERIAL_HOLE;
    std::string MarshallingAttributeNameMaterialHoleInstance = HAPI_UNREAL_ATTRIB_MATERIAL_HOLE_INSTANCE;

    // Get runtime settings.
    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
    if ( HoudiniRuntimeSettings )
    {
        if ( !HoudiniRuntimeSettings->MarshallingAttributeMaterial.IsEmpty() )
            FHoudiniEngineUtils::ConvertUnrealString(
                HoudiniRuntimeSettings->MarshallingAttributeMaterial,
                MarshallingAttributeNameMaterial);

        if ( !HoudiniRuntimeSettings->MarshallingAttributeMaterialHole.IsEmpty() )
            FHoudiniEngineUtils::ConvertUnrealString(
                HoudiniRuntimeSettings->MarshallingAttributeMaterialHole,
                MarshallingAttributeNameMaterialHole );
    }

    TArray< FString > Materials;
    HAPI_AttributeInfo AttribMaterials;
    FHoudiniApi::AttributeInfo_Init(&AttribMaterials);
    //FMemory::Memset< HAPI_AttributeInfo >( AttribMaterials, 0 );

    // First, look for landscape material
    {
        FHoudiniEngineUtils::HapiGetAttributeDataAsString(
            Heightfield, MarshallingAttributeNameMaterial.c_str(),
            AttribMaterials, Materials );

        // If the material attribute was not found, check the material instance attribute.
        if ( !AttribMaterials.exists )
        {
            Materials.Empty();
            FHoudiniEngineUtils::HapiGetAttributeDataAsString(
                Heightfield, MarshallingAttributeNameMaterialInstance.c_str(),
                AttribMaterials, Materials);
        }

        if ( AttribMaterials.exists && AttribMaterials.owner != HAPI_ATTROWNER_PRIM && AttribMaterials.owner != HAPI_ATTROWNER_DETAIL )
        {
            HOUDINI_LOG_WARNING( TEXT( "Landscape:  unreal_material must be a primitive or detail attribute, ignoring attribute." ) );
            AttribMaterials.exists = false;
            Materials.Empty();
        }

        if ( AttribMaterials.exists && Materials.Num() > 0 )
        {
            // Load the material
            LandscapeMaterial = Cast< UMaterialInterface >( StaticLoadObject(
                UMaterialInterface::StaticClass(),
                nullptr, *( Materials[ 0 ] ), nullptr, LOAD_NoWarn, nullptr ) );
        }
    }

    Materials.Empty();
    FHoudiniApi::AttributeInfo_Init(&AttribMaterials);
    //FMemory::Memset< HAPI_AttributeInfo >( AttribMaterials, 0 );
    
    // Then, for the hole_material
    {
        FHoudiniEngineUtils::HapiGetAttributeDataAsString(
            Heightfield, MarshallingAttributeNameMaterialHole.c_str(),
            AttribMaterials, Materials );

        // If the material attribute was not found, check the material instance attribute.
        if (!AttribMaterials.exists)
        {
            Materials.Empty();
            FHoudiniEngineUtils::HapiGetAttributeDataAsString(
                Heightfield, MarshallingAttributeNameMaterialHoleInstance.c_str(),
                AttribMaterials, Materials);
        }

        if ( AttribMaterials.exists && AttribMaterials.owner != HAPI_ATTROWNER_PRIM && AttribMaterials.owner != HAPI_ATTROWNER_DETAIL )
        {
            HOUDINI_LOG_WARNING( TEXT( "Landscape:  unreal_material must be a primitive or detail attribute, ignoring attribute." ) );
            AttribMaterials.exists = false;
            Materials.Empty();
        }

        if ( AttribMaterials.exists && Materials.Num() > 0 )
        {
            // Load the material
            LandscapeHoleMaterial = Cast< UMaterialInterface >( StaticLoadObject(
                UMaterialInterface::StaticClass(),
                nullptr, *( Materials[ 0 ] ), nullptr, LOAD_NoWarn, nullptr ) );
        }
    }
}

bool FHoudiniLandscapeUtils::CreateLandscapeLayers(
    FHoudiniCookParams& HoudiniCookParams,
    const TArray< const FHoudiniGeoPartObject* >& FoundLayers,
    const FHoudiniGeoPartObject& Heightfield,
    const int32& LandscapeXSize, const int32& LandscapeYSize,
    const TMap<FString, float>& GlobalMinimums,
    const TMap<FString, float>& GlobalMaximums,
    TArray<FLandscapeImportLayerInfo>& ImportLayerInfos )
{    
    // Verifying HoudiniCookParams validity
    if ( !HoudiniCookParams.HoudiniAsset || !HoudiniCookParams.CookedTemporaryLandscapeLayers )
        return false;

    ImportLayerInfos.Empty();

    // Get the names of all the non weight blended layers
    TArray< FString > NonWeightBlendedLayerNames;
    FHoudiniLandscapeUtils::GetNonWeightBlendedLayerNames( Heightfield, NonWeightBlendedLayerNames );

    TArray<UPackage*> CreatedLandscapeLayerPackage;

    // Try to create all the layers
    ELandscapeImportAlphamapType ImportLayerType = ELandscapeImportAlphamapType::Additive;
    for ( TArray<const FHoudiniGeoPartObject *>::TConstIterator IterLayers( FoundLayers ); IterLayers; ++IterLayers )
    {
        const FHoudiniGeoPartObject * LayerGeoPartObject = *IterLayers;
        if ( !LayerGeoPartObject )
            continue;

        if ( !LayerGeoPartObject->IsValid() )
            continue;

        if ( LayerGeoPartObject->AssetId == -1 )
            continue;

        TArray< float > FloatLayerData;
        HAPI_VolumeInfo LayerVolumeInfo;
        float LayerMin = 0;
        float LayerMax = 0;
        if ( !FHoudiniLandscapeUtils::GetHeightfieldData( *LayerGeoPartObject, FloatLayerData, LayerVolumeInfo, LayerMin, LayerMax ) )
            continue;

        // No need to create flat layers as Unreal will remove them afterwards..
        if ( LayerMin == LayerMax )
            continue;

        // Get the layer's name
        FString LayerString;
        FHoudiniEngineString(LayerVolumeInfo.nameSH).ToFString(LayerString);

        // Check if that landscape layer has been marked as unit (range in [0-1]
        if ( IsUnitLandscapeLayer( *LayerGeoPartObject ) )
        {
            LayerMin = 0.0f;
            LayerMax = 1.0f;
        }
        else
        {
            // We want to convert the layer using the global Min/Max
            if ( GlobalMaximums.Contains( LayerString ) )
                LayerMax = GlobalMaximums[ LayerString ];

            if ( GlobalMinimums.Contains( LayerString ) )
                LayerMin = GlobalMinimums[ LayerString ];
        }        

        // Creating the ImportLayerInfo and LayerInfo objects
        ObjectTools::SanitizeObjectName( LayerString );
        FName LayerName( *LayerString );
        FLandscapeImportLayerInfo currentLayerInfo( LayerName );

        UPackage * Package = nullptr;
        currentLayerInfo.LayerInfo = FHoudiniLandscapeUtils::CreateLandscapeLayerInfoObject( HoudiniCookParams, LayerString.GetCharArray().GetData(), Package, LayerGeoPartObject->PartId);
        if ( !currentLayerInfo.LayerInfo || !Package )
            continue;

        // Convert the float data to uint8
        // HF masks need their X/Y sizes swapped
        if ( !FHoudiniLandscapeUtils::ConvertHeightfieldLayerToLandscapeLayer(
            FloatLayerData, LayerVolumeInfo.yLength, LayerVolumeInfo.xLength,
            LayerMin, LayerMax,
            LandscapeXSize, LandscapeYSize,
            currentLayerInfo.LayerData ) )
            continue;

        // We will store the data used to convert from Houdini values to int in the DebugColor
        // This is the only way we'll be able to reconvert those values back to their houdini equivalent afterwards...
        // R = Min, G = Max, B = Spacing, A = ?
        currentLayerInfo.LayerInfo->LayerUsageDebugColor.R = LayerMin;
        currentLayerInfo.LayerInfo->LayerUsageDebugColor.G = LayerMax;
        currentLayerInfo.LayerInfo->LayerUsageDebugColor.B = ( LayerMax - LayerMin) / 255.0f;
        currentLayerInfo.LayerInfo->LayerUsageDebugColor.A = PI;

        HoudiniCookParams.CookedTemporaryLandscapeLayers->Add( Package, Heightfield );

        // Visibility are by default non weight blended
        if ( NonWeightBlendedLayerNames.Contains( LayerString )
            || LayerString.Equals(TEXT("visibility"), ESearchCase::IgnoreCase) )
            currentLayerInfo.LayerInfo->bNoWeightBlend = true;
        else
            currentLayerInfo.LayerInfo->bNoWeightBlend = false;

        // Mark the package dirty...
        Package->MarkPackageDirty();

        CreatedLandscapeLayerPackage.Add( Package );

        ImportLayerInfos.Add( currentLayerInfo );
    }

    // Autosaving the layers prevents them for being deleted with the Asset
    // Save the packages created for the LayerInfos
    FEditorFileUtils::PromptForCheckoutAndSave( CreatedLandscapeLayerPackage, true, false );

    return true;
}

ULandscapeLayerInfoObject *
FHoudiniLandscapeUtils::CreateLandscapeLayerInfoObject( FHoudiniCookParams& HoudiniCookParams, const TCHAR* LayerName, UPackage*& Package , HAPI_PartId PartId)
{
    // Verifying HoudiniCookParams validity
    if ( !HoudiniCookParams.HoudiniAsset || HoudiniCookParams.HoudiniAsset->IsPendingKill() )
        return nullptr;

    FString ComponentGUIDString = HoudiniCookParams.PackageGUID.ToString().Left( FHoudiniEngineUtils::PackageGUIDComponentNameLength );

    FString LayerNameString = FString::Printf( TEXT( "%s_%d" ), LayerName, (int32)PartId );
    LayerNameString = UPackageTools::SanitizePackageName( LayerNameString );

    // Create the LandscapeInfoObjectName from the Asset name and the mask name
    FName LayerObjectName = FName( * (HoudiniCookParams.HoudiniAsset->GetName() + ComponentGUIDString + TEXT( "_LayerInfoObject_" ) + LayerNameString ) );

    // Save the package in the temp folder
    FString Path = HoudiniCookParams.TempCookFolder.ToString() + TEXT( "/" );
    FString PackageName = Path + LayerObjectName.ToString();
    PackageName = UPackageTools::SanitizePackageName( PackageName );

    // See if package exists, if it does, reuse it
    bool bCreatedPackage = false;
    Package = FindPackage( nullptr, *PackageName );
    if ( !Package || Package->IsPendingKill() )
    {
        // We need to create a new package
        Package = CreatePackage( nullptr, *PackageName );
        bCreatedPackage = true;
    }

    if ( !Package || Package->IsPendingKill() )
        return nullptr;

    if ( !Package->IsFullyLoaded() )
        Package->FullyLoad();

    ULandscapeLayerInfoObject* LayerInfo = nullptr;
    if ( !bCreatedPackage )
    {
        // See if we can load the layer info instead of creating a new one
        LayerInfo = (ULandscapeLayerInfoObject*)StaticFindObjectFast(ULandscapeLayerInfoObject::StaticClass(), Package, LayerObjectName);
    }

    if ( !LayerInfo || LayerInfo->IsPendingKill() )
    {
        // Create a new LandscapeLayerInfoObject in the package
        LayerInfo = NewObject<ULandscapeLayerInfoObject>(Package, LayerObjectName, RF_Public | RF_Standalone /*| RF_Transactional*/);

        // Notify the asset registry
        FAssetRegistryModule::AssetCreated(LayerInfo);
    }

    if ( LayerInfo && !LayerInfo->IsPendingKill() )
    {
        LayerInfo->LayerName = LayerName;

        // Trigger update of the Layer Info
        LayerInfo->PreEditChange(nullptr);
        LayerInfo->PostEditChange();
        LayerInfo->MarkPackageDirty();

        // Mark the package dirty...
        Package->MarkPackageDirty();
    }

    return LayerInfo;
}

bool FHoudiniLandscapeUtils::AddLandscapeMaterialAttributesToVolume(
    const HAPI_NodeId& VolumeNodeId, const HAPI_PartId& PartId,
    UMaterialInterface* LandscapeMaterial, UMaterialInterface* LandscapeHoleMaterial )
{
    if ( !FHoudiniEngineUtils::IsValidNodeId(VolumeNodeId) )
        return false;

    // LANDSCAPE MATERIAL
    if ( LandscapeMaterial && !LandscapeMaterial->IsPendingKill() )
    {
        // Extract the path name from the material interface
        FString LandscapeMaterialString = LandscapeMaterial->GetPathName();

        // Get name of attribute used for marshalling materials.
        std::string MarshallingAttributeMaterialName = HAPI_UNREAL_ATTRIB_MATERIAL;

        // Marshall in material names.
        HAPI_AttributeInfo AttributeInfoMaterial;
        FHoudiniApi::AttributeInfo_Init(&AttributeInfoMaterial);
        //FMemory::Memzero< HAPI_AttributeInfo >(AttributeInfoMaterial);
        AttributeInfoMaterial.count = 1;
        AttributeInfoMaterial.tupleSize = 1;
        AttributeInfoMaterial.exists = true;
        AttributeInfoMaterial.owner = HAPI_ATTROWNER_PRIM;
        AttributeInfoMaterial.storage = HAPI_STORAGETYPE_STRING;
        AttributeInfoMaterial.originalOwner = HAPI_ATTROWNER_INVALID;

        HAPI_Result Result = FHoudiniApi::AddAttribute(
            FHoudiniEngine::Get().GetSession(), VolumeNodeId, PartId,
            MarshallingAttributeMaterialName.c_str(), &AttributeInfoMaterial);

        if ( HAPI_RESULT_SUCCESS == Result )
        {
            // Convert the FString to cont char *
            std::string LandscapeMatCStr = TCHAR_TO_ANSI(*LandscapeMaterialString);
            const char* LandscapeMatCStrRaw = LandscapeMatCStr.c_str();
            TArray<const char *> LandscapeMatArr;
            LandscapeMatArr.Add( LandscapeMatCStrRaw );

            // Set the attribute's string data
            Result = FHoudiniApi::SetAttributeStringData(
                FHoudiniEngine::Get().GetSession(), VolumeNodeId, PartId,
                MarshallingAttributeMaterialName.c_str(), &AttributeInfoMaterial,
                LandscapeMatArr.GetData(), 0, AttributeInfoMaterial.count);
        }

        if( Result != HAPI_RESULT_SUCCESS )
        {
            // Failed to create the attribute
            HOUDINI_LOG_WARNING(
                TEXT("Failed to upload unreal_material attribute for landscape: %s"),
                *FHoudiniEngineUtils::GetErrorDescription());
        }
    }

    // HOLE MATERIAL
    if ( LandscapeHoleMaterial && !LandscapeHoleMaterial->IsPendingKill() )
    {
        // Extract the path name from the material interface
        FString LandscapeMaterialString = LandscapeHoleMaterial->GetPathName();

        // Get name of attribute used for marshalling materials.
        std::string MarshallingAttributeMaterialName = HAPI_UNREAL_ATTRIB_MATERIAL_HOLE;

        // Marshall in material names.
        HAPI_AttributeInfo AttributeInfoMaterial;
        FHoudiniApi::AttributeInfo_Init(&AttributeInfoMaterial);
        //FMemory::Memzero< HAPI_AttributeInfo >(AttributeInfoMaterial);
        AttributeInfoMaterial.count = 1;
        AttributeInfoMaterial.tupleSize = 1;
        AttributeInfoMaterial.exists = true;
        AttributeInfoMaterial.owner = HAPI_ATTROWNER_PRIM;
        AttributeInfoMaterial.storage = HAPI_STORAGETYPE_STRING;
        AttributeInfoMaterial.originalOwner = HAPI_ATTROWNER_INVALID;

        HAPI_Result Result = FHoudiniApi::AddAttribute(
            FHoudiniEngine::Get().GetSession(), VolumeNodeId, PartId,
            MarshallingAttributeMaterialName.c_str(), &AttributeInfoMaterial);

        if ( Result == HAPI_RESULT_SUCCESS )
        {
            // Convert the FString to cont char *
            std::string LandscapeMatCStr = TCHAR_TO_ANSI(*LandscapeMaterialString);
            const char* LandscapeMatCStrRaw = LandscapeMatCStr.c_str();
            TArray<const char *> LandscapeMatArr;
            LandscapeMatArr.Add(LandscapeMatCStrRaw);

            // Set the attribute's string data
            Result = FHoudiniApi::SetAttributeStringData(
                FHoudiniEngine::Get().GetSession(), VolumeNodeId, PartId,
                MarshallingAttributeMaterialName.c_str(), &AttributeInfoMaterial,
                LandscapeMatArr.GetData(), 0, AttributeInfoMaterial.count);
        }

        if ( Result != HAPI_RESULT_SUCCESS )
        {
            // Failed to create the attribute
            HOUDINI_LOG_WARNING(
                TEXT("Failed to upload unreal_material attribute for landscape: %s"),
                *FHoudiniEngineUtils::GetErrorDescription());
        }
    }

    return true;
}

bool FHoudiniLandscapeUtils::AddLandscapeGlobalMaterialAttribute( const HAPI_NodeId& NodeId, ALandscapeProxy * LandscapeProxy )
{
    if ( !LandscapeProxy )
        return false;

    const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();

    // Get name of attribute used for marshalling materials.
    std::string MarshallingAttributeMaterialName = HAPI_UNREAL_ATTRIB_MATERIAL;
    if ( HoudiniRuntimeSettings && !HoudiniRuntimeSettings->MarshallingAttributeMaterial.IsEmpty() )
    {
        FHoudiniEngineUtils::ConvertUnrealString(
            HoudiniRuntimeSettings->MarshallingAttributeMaterial,
            MarshallingAttributeMaterialName );
    }

    // If there's a global landscape material, we marshall it as detail.
    UMaterialInterface * MaterialInterface = LandscapeProxy->GetLandscapeMaterial();
    const char * MaterialNameStr = "";
    if ( MaterialInterface )
    {
        FString FullMaterialName = MaterialInterface->GetPathName();
        MaterialNameStr = TCHAR_TO_UTF8(*FullMaterialName);
    }

    HAPI_AttributeInfo AttributeInfoDetailMaterial;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoDetailMaterial);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoDetailMaterial );
    AttributeInfoDetailMaterial.count = 1;
    AttributeInfoDetailMaterial.tupleSize = 1;
    AttributeInfoDetailMaterial.exists = true;
    AttributeInfoDetailMaterial.owner = HAPI_ATTROWNER_DETAIL;
    AttributeInfoDetailMaterial.storage = HAPI_STORAGETYPE_STRING;
    AttributeInfoDetailMaterial.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        MarshallingAttributeMaterialName.c_str(), &AttributeInfoDetailMaterial ), false);

    HOUDINI_CHECK_ERROR_RETURN(FHoudiniApi::SetAttributeStringData(
        FHoudiniEngine::Get().GetSession(), NodeId, 0,
        MarshallingAttributeMaterialName.c_str(), &AttributeInfoDetailMaterial,
        (const char**)&MaterialNameStr, 0, AttributeInfoDetailMaterial.count ), false );

    // Get name of attribute used for marshalling hole materials.
    std::string MarshallingAttributeMaterialHoleName = HAPI_UNREAL_ATTRIB_MATERIAL_HOLE;
    if ( HoudiniRuntimeSettings && !HoudiniRuntimeSettings->MarshallingAttributeMaterialHole.IsEmpty() )
    {
        FHoudiniEngineUtils::ConvertUnrealString(
            HoudiniRuntimeSettings->MarshallingAttributeMaterialHole,
            MarshallingAttributeMaterialHoleName );
    }

    // If there's a global landscape hole material, we marshall it as detail.
    UMaterialInterface * HoleMaterialInterface = LandscapeProxy->GetLandscapeHoleMaterial();
    const char * HoleMaterialNameStr = "";
    if ( HoleMaterialInterface )
    {
        FString FullMaterialName = HoleMaterialInterface->GetPathName();
        MaterialNameStr = TCHAR_TO_UTF8( *FullMaterialName );
    }

    HAPI_AttributeInfo AttributeInfoDetailMaterialHole;
    FHoudiniApi::AttributeInfo_Init(&AttributeInfoDetailMaterialHole);
    //FMemory::Memzero< HAPI_AttributeInfo >( AttributeInfoDetailMaterialHole );
    AttributeInfoDetailMaterialHole.count = 1;
    AttributeInfoDetailMaterialHole.tupleSize = 1;
    AttributeInfoDetailMaterialHole.exists = true;
    AttributeInfoDetailMaterialHole.owner = HAPI_ATTROWNER_DETAIL;
    AttributeInfoDetailMaterialHole.storage = HAPI_STORAGETYPE_STRING;
    AttributeInfoDetailMaterialHole.originalOwner = HAPI_ATTROWNER_INVALID;

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::AddAttribute(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, MarshallingAttributeMaterialHoleName.c_str(),
        &AttributeInfoDetailMaterialHole), false );

    HOUDINI_CHECK_ERROR_RETURN( FHoudiniApi::SetAttributeStringData(
        FHoudiniEngine::Get().GetSession(),
        NodeId, 0, MarshallingAttributeMaterialHoleName.c_str(),
        &AttributeInfoDetailMaterialHole, (const char **)&HoleMaterialNameStr, 0,
        AttributeInfoDetailMaterialHole.count ), false );
    
    return true;
}

bool
FHoudiniLandscapeUtils::UpdateOldLandscapeReference(ALandscapeProxy* OldLandscape, ALandscapeProxy*  NewLandscape)
{
    if ( !OldLandscape || !NewLandscape )
        return false;

    bool bReturn = false;

    // Iterates through all the Houdini Assets in the scene
    UWorld* editorWorld = GEditor ? GEditor->GetEditorWorldContext().World() : nullptr;
    if ( !editorWorld )
        return false;

    for ( TActorIterator<AHoudiniAssetActor> ActorItr( editorWorld ); ActorItr; ++ActorItr )
    {
        AHoudiniAssetActor* Actor = *ActorItr;
        UHoudiniAssetComponent * HoudiniAssetComponent = Actor->GetHoudiniAssetComponent();
        if ( !HoudiniAssetComponent || !HoudiniAssetComponent->IsValidLowLevel() )
        {
            HOUDINI_LOG_ERROR(TEXT("Failed to export a Houdini Asset in the scene!"));
            continue;
        }

        if ( HoudiniAssetComponent->IsTemplate() )
            continue;

        if ( HoudiniAssetComponent->IsPendingKillOrUnreachable() )
            continue;

        if ( !HoudiniAssetComponent->GetOuter() )
            continue;

        bReturn = HoudiniAssetComponent->ReplaceLandscapeInInputs( OldLandscape, NewLandscape );
    }

    return bReturn;
}

bool
FHoudiniLandscapeUtils::InitDefaultHeightfieldMask(
    const HAPI_VolumeInfo& HeightVolumeInfo,
    const HAPI_NodeId& MaskVolumeNodeId )
{
    // We need to have a mask layer as it is required for proper heightfield functionalities

    // Creating an array filled with 0.0
    TArray< float > MaskFloatData;
    MaskFloatData.Init( 0.0f, HeightVolumeInfo.xLength * HeightVolumeInfo.yLength );

    // Creating the volume infos
    HAPI_VolumeInfo MaskVolumeInfo = HeightVolumeInfo;

    // Set the heighfield data in Houdini
    FString MaskName = TEXT("mask");
    HAPI_PartId PartId = 0;
    if ( !SetHeighfieldData( MaskVolumeNodeId, PartId, MaskFloatData, MaskVolumeInfo, MaskName ) )
        return false;

    return true;
}


bool
FHoudiniLandscapeUtils::BackupLandscapeToFile(const FString& BaseName, ALandscapeProxy* Landscape)
{
    // We need to cache the input landscape to a file    
    if ( !Landscape )
        return false;

    ULandscapeInfo* LandscapeInfo = Landscape->GetLandscapeInfo();
    if (!LandscapeInfo)
        return false;

    // Save Height data to file
    //FString HeightSave = TEXT("/Game/HoudiniEngine/Temp/HeightCache.png");    
    FString HeightSave = BaseName + TEXT("_height.png");
    LandscapeInfo->ExportHeightmap(HeightSave);
    Landscape->ReimportHeightmapFilePath = HeightSave;

    // Save each layer to a file
    for ( int LayerIndex = 0; LayerIndex < LandscapeInfo->Layers.Num(); LayerIndex++ )
    {
        FName CurrentLayerName = LandscapeInfo->Layers[LayerIndex].GetLayerName();
        //ULandscapeLayerInfoObject* CurrentLayerInfo = LandscapeInfo->GetLayerInfoByName(CurrentLayerName, Landscape);
        ULandscapeLayerInfoObject* CurrentLayerInfo = LandscapeInfo->Layers[LayerIndex].LayerInfoObj;
        if ( !CurrentLayerInfo || CurrentLayerInfo->IsPendingKill() )
            continue;

        FString LayerSave = BaseName + CurrentLayerName.ToString() + TEXT(".png");
        LandscapeInfo->ExportLayer(CurrentLayerInfo, LayerSave);

        // Update the file reimport path on the input landscape for this layer
        LandscapeInfo->GetLayerEditorSettings(CurrentLayerInfo).ReimportLayerFilePath = LayerSave;
    }

    return true;
}

bool
FHoudiniLandscapeUtils::RestoreLandscapeFromFile( ALandscapeProxy* LandscapeProxy )
{
    if ( !LandscapeProxy )
        return false;

    ULandscapeInfo* LandscapeInfo = LandscapeProxy->GetLandscapeInfo();
    if (!LandscapeInfo)
        return false;

    // Restore Height data from the backup file
    FString ReimportFile = LandscapeProxy->ReimportHeightmapFilePath;
    if ( !ImportLandscapeData(LandscapeInfo, ReimportFile, TEXT("height") ) )
        HOUDINI_LOG_ERROR(TEXT("Could not restore the landscape actor's source height data."));

    
    // Restore each layer from the backup file
    TArray< ULandscapeLayerInfoObject* > SourceLayers;
    for ( int LayerIndex = 0; LayerIndex < LandscapeProxy->EditorLayerSettings.Num(); LayerIndex++ )
    {
        ULandscapeLayerInfoObject* CurrentLayerInfo = LandscapeProxy->EditorLayerSettings[LayerIndex].LayerInfoObj;
        if (!CurrentLayerInfo || CurrentLayerInfo->IsPendingKill())
            continue;

        FString CurrentLayerName = CurrentLayerInfo->LayerName.ToString();
        ReimportFile = LandscapeProxy->EditorLayerSettings[LayerIndex].ReimportLayerFilePath;

        if (!ImportLandscapeData(LandscapeInfo, ReimportFile, CurrentLayerName, CurrentLayerInfo))
            HOUDINI_LOG_ERROR( TEXT("Could not restore the landscape actor's source height data.") );

        SourceLayers.Add( CurrentLayerInfo );
    }

    // Iterate on the landscape info's layer to remove any layer that could have been added by Houdini
    for (int LayerIndex = 0; LayerIndex < LandscapeInfo->Layers.Num(); LayerIndex++)
    {
        ULandscapeLayerInfoObject* CurrentLayerInfo = LandscapeInfo->Layers[LayerIndex].LayerInfoObj;
        if ( SourceLayers.Contains( CurrentLayerInfo ) )
            continue;

        // Delete the added layer
        FName LayerName = LandscapeInfo->Layers[LayerIndex].LayerName;
        LandscapeInfo->DeleteLayer(CurrentLayerInfo, LayerName);
    }

    return true;
}

bool
FHoudiniLandscapeUtils::ImportLandscapeData(
    ULandscapeInfo* LandscapeInfo, const FString& Filename, const FString& LayerName, ULandscapeLayerInfoObject* LayerInfoObject )
{
    //
    // Code copied/edited from FEdModeLandscape::ImportData as we cannot access that function
    //
    if ( !LandscapeInfo )
        return false;

    bool IsHeight = LayerName.Equals(TEXT("height"), ESearchCase::IgnoreCase);

    int32 MinX, MinY, MaxX, MaxY;
    if (LandscapeInfo && LandscapeInfo->GetLandscapeExtent(MinX, MinY, MaxX, MaxY))
    {
        const FLandscapeFileResolution LandscapeResolution = { (uint32)(1 + MaxX - MinX), (uint32)(1 + MaxY - MinY) };

        ILandscapeEditorModule& LandscapeEditorModule = FModuleManager::GetModuleChecked<ILandscapeEditorModule>("LandscapeEditor");

        if ( IsHeight )
        {
            const ILandscapeHeightmapFileFormat* HeightmapFormat = LandscapeEditorModule.GetHeightmapFormatByExtension(*FPaths::GetExtension(Filename, true));

            if (!HeightmapFormat)
            {
                HOUDINI_LOG_ERROR( TEXT("Could not reimport the input heightfield's source data for %s, File type not recognised"), *LayerName );
                return false;
            }

            FLandscapeFileResolution ImportResolution = { 0, 0 };

            const FLandscapeHeightmapInfo HeightmapInfo = HeightmapFormat->Validate(*Filename);

            // display error message if there is one, and abort the import
            if (HeightmapInfo.ResultCode == ELandscapeImportResult::Error)
            {
                HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s, %s"), *LayerName, *(HeightmapInfo.ErrorMessage.ToString()) );
                return false;
            }

            // if the file is a raw format with multiple possibly resolutions, only attempt import if one matches the current landscape
            if (HeightmapInfo.PossibleResolutions.Num() > 1)
            {
                if (!HeightmapInfo.PossibleResolutions.Contains(LandscapeResolution))
                {
                    HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s. The heightmap file does not match the Landscape extent and its exact resolution could not be determined"));
                    return false;
                }
                else
                {
                    ImportResolution = LandscapeResolution;
                }
            }

            // display warning message if there is one and allow user to cancel
            if (HeightmapInfo.ResultCode == ELandscapeImportResult::Warning)
                HOUDINI_LOG_WARNING(TEXT("When reimporting the input heightfield's source data for %s. %s"), *LayerName, *(HeightmapInfo.ErrorMessage.ToString()));

            // if the file is a format with resolution information, warn the user if the resolution doesn't match the current landscape
            // unlike for raw this is only a warning as we can pad/clip the data if we know what resolution it is
            if (HeightmapInfo.PossibleResolutions.Num() == 1)
            {
                ImportResolution = HeightmapInfo.PossibleResolutions[0];
                if (ImportResolution != LandscapeResolution)
                    HOUDINI_LOG_WARNING(TEXT("When reimporting the input heightfield's source data for %s. The heightmap file's size does not match the current Landscape extent, data will be padded/clipped"), *LayerName);
            }

            FLandscapeHeightmapImportData ImportData = HeightmapFormat->Import(*Filename, ImportResolution);
            if (ImportData.ResultCode == ELandscapeImportResult::Error)
            {
                HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s. %s"), *LayerName, *(ImportData.ErrorMessage.ToString()));
                return false;
            }

            TArray<uint16> Data;
            if (ImportResolution != LandscapeResolution)
            {
                // Cloned from FLandscapeEditorDetailCustomization_NewLandscape.OnCreateButtonClicked
                // so that reimports behave the same as the initial import :)

                const int32 OffsetX = (int32)(LandscapeResolution.Width - ImportResolution.Width) / 2;
                const int32 OffsetY = (int32)(LandscapeResolution.Height - ImportResolution.Height) / 2;

                Data.SetNumUninitialized(LandscapeResolution.Width * LandscapeResolution.Height * sizeof(uint16));

                ExpandData<uint16>(Data.GetData(), ImportData.Data.GetData(),
                    0, 0, ImportResolution.Width - 1, ImportResolution.Height - 1,
                    -OffsetX, -OffsetY, LandscapeResolution.Width - OffsetX - 1, LandscapeResolution.Height - OffsetY - 1);
            }
            else
            {
                Data = MoveTemp(ImportData.Data);
            }

            //FScopedTransaction Transaction(TEXT("Undo_ImportHeightmap", "Importing Landscape Heightmap"));

            FHeightmapAccessor<false> HeightmapAccessor(LandscapeInfo);
            HeightmapAccessor.SetData(MinX, MinY, MaxX, MaxY, Data.GetData());
        }
        else
        {
            // We're importing a Landscape layer
            if ( !LayerInfoObject || LayerInfoObject->IsPendingKill() )
                return false;

            const ILandscapeWeightmapFileFormat* WeightmapFormat = LandscapeEditorModule.GetWeightmapFormatByExtension(*FPaths::GetExtension(Filename, true));

            if (!WeightmapFormat)
            {
                HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s, File type not recognised"), *LayerName);
                return false;
            }

            FLandscapeFileResolution ImportResolution = { 0, 0 };

            const FLandscapeWeightmapInfo WeightmapInfo = WeightmapFormat->Validate(*Filename, FName(*LayerName));

            // display error message if there is one, and abort the import
            if (WeightmapInfo.ResultCode == ELandscapeImportResult::Error)
            {
                HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s, %s"), *LayerName, *(WeightmapInfo.ErrorMessage.ToString()));
                return false;
            }

            // if the file is a raw format with multiple possibly resolutions, only attempt import if one matches the current landscape
            if (WeightmapInfo.PossibleResolutions.Num() > 1)
            {
                if (!WeightmapInfo.PossibleResolutions.Contains(LandscapeResolution))
                {
                    HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s. The weightmap file does not match the Landscape extent and its exact resolution could not be determined"));
                    return false;
                }
                else
                {
                    ImportResolution = LandscapeResolution;
                }
            }

            // display warning message if there is one and allow user to cancel
            if (WeightmapInfo.ResultCode == ELandscapeImportResult::Warning)
                HOUDINI_LOG_WARNING(TEXT("When reimporting the input heightfield's source data for %s. %s"), *LayerName, *(WeightmapInfo.ErrorMessage.ToString()));

            // if the file is a format with resolution information, warn the user if the resolution doesn't match the current landscape
            // unlike for raw this is only a warning as we can pad/clip the data if we know what resolution it is
            if (WeightmapInfo.PossibleResolutions.Num() == 1)
            {
                ImportResolution = WeightmapInfo.PossibleResolutions[0];
                if (ImportResolution != LandscapeResolution)
                    HOUDINI_LOG_WARNING(TEXT("When reimporting the input heightfield's source data for %s. The heightmap file's size does not match the current Landscape extent, data will be padded/clipped"), *LayerName);
            }

            FLandscapeWeightmapImportData ImportData = WeightmapFormat->Import(*Filename, FName(*LayerName), ImportResolution);

            if (ImportData.ResultCode == ELandscapeImportResult::Error)
            {
                HOUDINI_LOG_ERROR(TEXT("Could not reimport the input heightfield's source data for %s. %s"), *LayerName, *(ImportData.ErrorMessage.ToString()));
                return false;
            }

            TArray<uint8> Data;
            if (ImportResolution != LandscapeResolution)
            {
                // Cloned from FLandscapeEditorDetailCustomization_NewLandscape.OnCreateButtonClicked
                // so that reimports behave the same as the initial import :)
                const int32 OffsetX = (int32)(LandscapeResolution.Width - ImportResolution.Width) / 2;
                const int32 OffsetY = (int32)(LandscapeResolution.Height - ImportResolution.Height) / 2;

                Data.SetNumUninitialized(LandscapeResolution.Width * LandscapeResolution.Height * sizeof(uint8));

                ExpandData<uint8>(Data.GetData(), ImportData.Data.GetData(),
                    0, 0, ImportResolution.Width - 1, ImportResolution.Height - 1,
                    -OffsetX, -OffsetY, LandscapeResolution.Width - OffsetX - 1, LandscapeResolution.Height - OffsetY - 1);
            }
            else
            {
                Data = MoveTemp(ImportData.Data);
            }

            //FScopedTransaction Transaction(LOCTEXT("Undo_ImportWeightmap", "Importing Landscape Layer"));

            FAlphamapAccessor<false, false> AlphamapAccessor(LandscapeInfo, LayerInfoObject);
            AlphamapAccessor.SetData(MinX, MinY, MaxX, MaxY, Data.GetData(), ELandscapeLayerPaintingRestriction::None);
        }
    }

    return true;
}

#endif

bool
FHoudiniLandscapeUtils::IsUnitLandscapeLayer(const FHoudiniGeoPartObject& LayerGeoPartObject)
{
    // Check the attribute exists on primitive or detail
    HAPI_AttributeOwner Owner = HAPI_ATTROWNER_INVALID;
    if (FHoudiniEngineUtils::HapiCheckAttributeExists(LayerGeoPartObject, "unreal_unit_landscape_layer", HAPI_ATTROWNER_PRIM))
        Owner = HAPI_ATTROWNER_PRIM;
    else if (FHoudiniEngineUtils::HapiCheckAttributeExists(LayerGeoPartObject, "unreal_unit_landscape_layer", HAPI_ATTROWNER_DETAIL))
        Owner = HAPI_ATTROWNER_DETAIL;
    else
        return false;

    // Check the value
    HAPI_AttributeInfo AttribInfoUnitLayer;
    FHoudiniApi::AttributeInfo_Init(&AttribInfoUnitLayer);
    TArray< int32 > AttribValues;
    FHoudiniEngineUtils::HapiGetAttributeDataAsInteger(
        LayerGeoPartObject, "unreal_unit_landscape_layer", AttribInfoUnitLayer, AttribValues, 1, Owner);

    if (AttribValues.Num() > 0 && AttribValues[0] == 1 )
        return true;

    return false;
}