BuildingISMComponent.cpp

#include "BuildingISMComponent.h"
#include "InstancedStaticMeshDelegates.h"
#include "Engine/Engine.h"

UBuildingISMComponent::UBuildingISMComponent(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
    , bDelegatesBound(false)
{
    // Enable per-instance custom data if needed
    NumCustomDataFloats = 0;
}

void UBuildingISMComponent::BeginPlay()
{
    Super::BeginPlay();
    BindToInternalDelegates();
}

void UBuildingISMComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    UnbindFromInternalDelegates();
    Super::EndPlay(EndPlayReason);
}

bool UBuildingISMComponent::IsValidInstanceIndex(int32 Index) const
{
    return Index >= 0 && Index < GetInstanceCount();
}

void UBuildingISMComponent::BindToInternalDelegates()
{
    if (bDelegatesBound)
    {
        return;
    }

    FInstancedStaticMeshDelegates::OnInstanceIndexUpdated.AddUObject(this, &UBuildingISMComponent::HandleInstanceIndexUpdated);
    bDelegatesBound = true;
}

void UBuildingISMComponent::UnbindFromInternalDelegates()
{
    if (!bDelegatesBound)
    {
        return;
    }

    // Unbind from the delegates
    FInstancedStaticMeshDelegates::OnInstanceIndexUpdated.RemoveAll(this);

    bDelegatesBound = false;
}

void UBuildingISMComponent::HandleInstanceIndexUpdated(UInstancedStaticMeshComponent* InComponent, TArrayView<const FInstancedStaticMeshDelegates::FInstanceIndexUpdateData> InIndexUpdates)
{
    // Process each update and broadcast the appropriate events
    for (const auto& UpdateData : InIndexUpdates)
    {
        switch (UpdateData.Type)
        {
        case FInstancedStaticMeshDelegates::EInstanceIndexUpdateType::Added:
        {
            FTransform InstanceTransform;
            if (IsValidInstanceIndex(UpdateData.Index) && GetInstanceTransform(UpdateData.Index, InstanceTransform, true))
            {
                CachedInstanceTransforms.Add(UpdateData.Index, InstanceTransform);
                OnInstanceAdded.Broadcast(UpdateData.Index, InstanceTransform);
            }
            break;
        }

        case FInstancedStaticMeshDelegates::EInstanceIndexUpdateType::Removed:
        {
            // We can't get the transform of a removed instance, so use cached data if available
            FTransform LastTransform = FTransform::Identity;
            if (CachedInstanceTransforms.Contains(UpdateData.Index))
            {
                LastTransform = CachedInstanceTransforms[UpdateData.Index];
                CachedInstanceTransforms.Remove(UpdateData.Index);
            }

            OnInstanceRemoved.Broadcast(UpdateData.Index, LastTransform);
            break;
        }

        case FInstancedStaticMeshDelegates::EInstanceIndexUpdateType::Relocated:
        {
            // Update cached transforms
            if (CachedInstanceTransforms.Contains(UpdateData.OldIndex))
            {
                FTransform MovedTransform = CachedInstanceTransforms[UpdateData.OldIndex];
                CachedInstanceTransforms.Remove(UpdateData.OldIndex);

                if (IsValidInstanceIndex(UpdateData.Index))
                {
                    // Get the actual new transform
                    FTransform ActualTransform = MovedTransform; // Initialize with fallback

                    if (!GetInstanceTransform(UpdateData.Index, ActualTransform, true))
                    {
                        // Log warning if needed - using cached transform as fallback
                        UE_LOG(LogTemp, Warning, TEXT("Failed to get actual transform for relocated instance %d"), UpdateData.Index);
                    }

                    CachedInstanceTransforms.Add(UpdateData.Index, ActualTransform);
                    OnInstanceMoved.Broadcast(UpdateData.OldIndex, MovedTransform, UpdateData.Index, ActualTransform);
                }
            }
            break;
        }
        }
    }
}