[UE4]Remove and Add Instanced Foliage Mesh at Run-time

UCLASS(minimalapi)
class ATestProjGameMode : public AGameModeBase
{
    GENERATED_BODY()

public:
    ATestProjGameMode();

protected:

    void BeginPlay() override;

    UFUNCTION(BlueprintCallable)
        void RemoveAllFoliages();

    UFUNCTION(BlueprintCallable)
        void AddAllFoliages();

private:

    //Instanced Static Mesh Components Array in current Level.
    TArray<UActorComponent*> InstancedStaticMeshCompArray;

    //Each Instanced Static Mesh's Transform. Key: Instanced Static Mesh Component Name, Value:All Transforms in current Instanced Static Mesh Component
    TMap<FString, TArray<FTransform>> TransformMap;
};

void ATestProjGameMode::BeginPlay()
{
    Super::BeginPlay();

    for (TActorIterator<AInstancedFoliageActor> Iter(GetWorld()); Iter; ++Iter)
    {
        if (*Iter)
        {
            //Get the all InstancedStaticMeshComponent in current Level.
            InstancedStaticMeshCompArray = Iter->GetComponentsByClass(UInstancedStaticMeshComponent::StaticClass());

            //Print the name of InstancedStaticMeshComponent
            for (UActorComponent* ActorComp : InstancedStaticMeshCompArray)
            {
                GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, ActorComp->GetName());
            }
            break;
        }
    }
}

void ATestProjGameMode::RemoveAllFoliage()
{
    TransformMap.Empty();

    for (UActorComponent* Comp : InstancedStaticMeshCompArray)
    {
        if (UInstancedStaticMeshComponent* InstancedComp = Cast<UInstancedStaticMeshComponent>(Comp))
        {
            GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Green, FString::Printf(TEXT("%d"), InstancedComp->GetInstanceCount()));

            TArray<FTransform> TransformArray;

            for (int i = InstancedComp->GetInstanceCount() - 1; i >= 0; i--)
            {
                //Save the transform of current Instance.
                FTransform Out;
                InstancedComp->GetInstanceTransform(i, Out);
                TransformArray.Add(Out);

                //Remove Instance at Run-time.
                InstancedComp->RemoveInstance(i);
            }

            TransformMap.Add(InstancedComp->GetName(), TransformArray);
        }
    }
}

void ATestProjGameMode::AddAllFoliage()
{
    for (UActorComponent* Comp : InstancedStaticMeshCompArray)
    {
        if (UInstancedStaticMeshComponent* InstancedComp = Cast<UInstancedStaticMeshComponent>(Comp))
        {
            if (TArray<FTransform>* TransformArray = TransformMap.Find(InstancedComp->GetName()))
            {
                for (FTransform& Trans : *TransformArray)
                {
                    //Add Instance at Run-time, use the previous Transform.
                    InstancedComp->AddInstance(Trans);
                }
            }
            
        }
    }
}

const TArray<UMaterialInterface*> Materials = ...;
const TArray<FMatrix> Instances = ...;
const int32 InstanceNum = ...;

for (int32 Index = 0; i < InstanceNum; i++)
{
    UInstancedStaticMeshComponent* Component = NewObject<UInstancedStaticMeshComponent>(GetTransientPackage(), *FString::Printf(TEXT("InstancedMesh_%d"), Index), RF_Transient);
    Component->SetRelativeLocation(FVector(0.f, 0.f, 0.f));
    Component->SetRelativeRotation(FRotator(0.f, 0.f, 0.f));
    Component->SetRelativeScale3D(FVector(1.f, 1.f, 1.f));
    Component->SetMobility(EComponentMobility::Type::Static);
    Component->SetStaticMesh(Mesh);

    for (int i = 0; i < Materials.Num(); i++)
    {
        Component->SetMaterial(i, Materials[i]);
    }

    for (const FMatrix& Matrix : Instances)
    {
        FInstancedStaticMeshInstanceData InstancedStaticMeshInstanceData(Matrix);
        Component->PerInstanceSMData.Add(InstancedStaticMeshInstanceData);
    }
}

void ATestProjGameMode::BeginPlay()
{
    Super::BeginPlay();

    for (TActorIterator<AInstancedFoliageActor> Iter(GetWorld()); Iter; ++Iter)
    {
        if (*Iter)
        {
            //Get the all InstancedStaticMeshComponent in current Level.
            TArray<UActorComponent*> InstancedStaticMeshCompArray = Iter->GetComponentsByClass(UInstancedStaticMeshComponent::StaticClass());
            
            for (UActorComponent* ActorComp : InstancedStaticMeshCompArray)
            {
                if (UInstancedStaticMeshComponent* InstancedComp = Cast<UInstancedStaticMeshComponent>(ActorComp))
                {
                    UStaticMesh* Mesh = InstancedComp->GetStaticMesh();

                    TArray<UMaterialInterface*> Materials = InstancedComp->GetMaterials();
                }
            }
            break;
        }
    }
}

void ATestProjGameMode::BeginPlay()
{
    Super::BeginPlay();

    for (TActorIterator<AInstancedFoliageActor> Iter(GetWorld()); Iter; ++Iter)
    {
        if (*Iter)
        {
            //Get the all InstancedStaticMeshComponent in current Level.
            TArray<UActorComponent*> InstancedStaticMeshCompArray = Iter->GetComponentsByClass(UInstancedStaticMeshComponent::StaticClass());
            
            for (UActorComponent* ActorComp : InstancedStaticMeshCompArray)
            {
                if (UInstancedStaticMeshComponent* InstancedComp = Cast<UInstancedStaticMeshComponent>(ActorComp))
                {
                    for (int i = InstancedComp->GetInstanceCount() - 1; i >= 0; i--)
                    {
                        //Set Transform of Instance
                        FTransform NewTransform;
                        InstancedComp->UpdateInstanceTransform(i, NewTransform);
                    }
                }
            }
            break;
        }
    }
}

for (TActorIterator<AInstancedFoliageActor> ActorItr(GetWorld()); ActorItr; ++ActorItr)
{
    AInstancedFoliageActor* FoliageMesh = *ActorItr;

    for (auto& MeshPair : FoliageMesh->FoliageMeshes)
    {
        const FFoliageMeshInfo& MeshInfo = *MeshPair.Value;
        UHierarchicalInstancedStaticMeshComponent* MeshComponent = MeshInfo.Component;
        TArray<FInstancedStaticMeshInstanceData> MeshDataArray = MeshComponent->PerInstanceSMData;
        FString MeshName = MeshComponent->GetStaticMesh()->GetName();

        for (auto& MeshMatrix : MeshDataArray)
        {
            FTransform MeshTransform = FTransform(MeshMatrix.Transform);

            UE_LOG(LogTemp, Warning, TEXT("%s, %f, %f, %f, %f, %f, %f, %f, %f, %f,"),
                *MeshName,
                MeshTransform.GetLocation().X,
                MeshTransform.GetLocation().Y,
                MeshTransform.GetLocation().Z,
                MeshTransform.GetRotation().X,
                MeshTransform.GetRotation().Y,
                MeshTransform.GetRotation().Z,
                MeshTransform.GetScale3D().X,
                MeshTransform.GetScale3D().Y, 
                MeshTransform.GetScale3D().Z);
        }
    }
}