Andron666
940 lines
22 KiB
C++
940 lines
22 KiB
C++
/*
|
|
* Copyright (c) <2021> Side Effects Software Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. The name of Side Effects Software may not be used to endorse or
|
|
* promote products derived from this software without specific prior
|
|
* written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE "AS IS" AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
* NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "HoudiniOutput.h"
|
|
#include "HoudiniAssetComponent.h"
|
|
|
|
#include "HoudiniEngineRuntimeUtils.h"
|
|
#include "HoudiniSplineComponent.h"
|
|
|
|
#include "Components/SceneComponent.h"
|
|
#include "Components/MeshComponent.h"
|
|
#include "Components/SplineComponent.h"
|
|
#include "Misc/StringFormatArg.h"
|
|
#include "Engine/Engine.h"
|
|
#include "LandscapeLayerInfoObject.h"
|
|
|
|
UHoudiniLandscapePtr::UHoudiniLandscapePtr(class FObjectInitializer const& Initializer)
|
|
{
|
|
// bIsWorldCompositionLandscape = false;
|
|
// BakeType = EHoudiniLandscapeOutputBakeType::Detachment;
|
|
};
|
|
|
|
uint32
|
|
GetTypeHash(const FHoudiniOutputObjectIdentifier& HoudiniOutputObjectIdentifier)
|
|
{
|
|
return HoudiniOutputObjectIdentifier.GetTypeHash();
|
|
}
|
|
|
|
void
|
|
FHoudiniInstancedOutput::SetVariationObjectAt(const int32& AtIndex, UObject* InObject)
|
|
{
|
|
// Resize the array if needed
|
|
if (VariationObjects.Num() <= AtIndex)
|
|
VariationObjects.SetNum(AtIndex + 1);
|
|
|
|
if (VariationTransformOffsets.Num() <= AtIndex)
|
|
VariationTransformOffsets.SetNum(AtIndex + 1);
|
|
|
|
UObject* CurrentObject = VariationObjects[AtIndex].LoadSynchronous();
|
|
if (CurrentObject == InObject)
|
|
return;
|
|
|
|
VariationObjects[AtIndex] = InObject;
|
|
}
|
|
|
|
bool
|
|
FHoudiniInstancedOutput::SetTransformOffsetAt(const float& Value, const int32& AtIndex, const int32& PosRotScaleIndex, const int32& XYZIndex)
|
|
{
|
|
FTransform* Transform = VariationTransformOffsets.IsValidIndex(AtIndex) ? &VariationTransformOffsets[AtIndex] : nullptr;
|
|
if (!Transform)
|
|
return false;
|
|
|
|
if (PosRotScaleIndex == 0)
|
|
{
|
|
FVector Position = Transform->GetLocation();
|
|
if (Position[XYZIndex] == Value)
|
|
return false;
|
|
Position[XYZIndex] = Value;
|
|
Transform->SetLocation(Position);
|
|
}
|
|
else if (PosRotScaleIndex == 1)
|
|
{
|
|
FRotator Rotator = Transform->Rotator();
|
|
switch (XYZIndex)
|
|
{
|
|
case 0:
|
|
{
|
|
if (Rotator.Roll == Value)
|
|
return false;
|
|
Rotator.Roll = Value;
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
if (Rotator.Pitch == Value)
|
|
return false;
|
|
Rotator.Pitch = Value;
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
if (Rotator.Yaw == Value)
|
|
return false;
|
|
Rotator.Yaw = Value;
|
|
break;
|
|
}
|
|
}
|
|
Transform->SetRotation(Rotator.Quaternion());
|
|
}
|
|
else if (PosRotScaleIndex == 2)
|
|
{
|
|
FVector Scale = Transform->GetScale3D();
|
|
if (Scale[XYZIndex] == Value)
|
|
return false;
|
|
|
|
Scale[XYZIndex] = Value;
|
|
Transform->SetScale3D(Scale);
|
|
}
|
|
|
|
MarkChanged(true);
|
|
|
|
return true;
|
|
}
|
|
|
|
float
|
|
FHoudiniInstancedOutput::GetTransformOffsetAt(const int32& AtIndex, const int32& PosRotScaleIndex, const int32& XYZIndex)
|
|
{
|
|
FTransform* Transform = VariationTransformOffsets.IsValidIndex(AtIndex) ? &VariationTransformOffsets[AtIndex] : nullptr;
|
|
if (!Transform)
|
|
return 0.0f;
|
|
|
|
if (PosRotScaleIndex == 0)
|
|
{
|
|
FVector Position = Transform->GetLocation();
|
|
return Position[XYZIndex];
|
|
}
|
|
else if (PosRotScaleIndex == 1)
|
|
{
|
|
FRotator Rotator = Transform->Rotator();
|
|
switch (XYZIndex)
|
|
{
|
|
case 0:
|
|
{
|
|
return Rotator.Roll;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
return Rotator.Pitch;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
return Rotator.Yaw;
|
|
}
|
|
}
|
|
}
|
|
else if (PosRotScaleIndex == 2)
|
|
{
|
|
FVector Scale = Transform->GetScale3D();
|
|
return Scale[XYZIndex];
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// FHoudiniOutputObjectIdentifier
|
|
// ----------------------------------------------------
|
|
|
|
FHoudiniOutputObjectIdentifier::FHoudiniOutputObjectIdentifier()
|
|
{
|
|
ObjectId = -1;
|
|
GeoId = -1;
|
|
PartId = -1;
|
|
SplitIdentifier = FString();
|
|
PartName = FString();
|
|
}
|
|
|
|
FHoudiniOutputObjectIdentifier::FHoudiniOutputObjectIdentifier(
|
|
const int32& InObjectId, const int32& InGeoId, const int32& InPartId, const FString& InSplitIdentifier)
|
|
{
|
|
ObjectId = InObjectId;
|
|
GeoId = InGeoId;
|
|
PartId = InPartId;
|
|
SplitIdentifier = InSplitIdentifier;
|
|
}
|
|
|
|
uint32
|
|
FHoudiniOutputObjectIdentifier::GetTypeHash() const
|
|
{
|
|
int32 HashBuffer[3] = { ObjectId, GeoId, PartId };
|
|
int32 Hash = FCrc::MemCrc32((void *)&HashBuffer[0], sizeof(HashBuffer));
|
|
return FCrc::StrCrc32(*SplitIdentifier, Hash);
|
|
}
|
|
|
|
bool
|
|
FHoudiniOutputObjectIdentifier::operator==(const FHoudiniOutputObjectIdentifier& InOutputObjectIdentifier) const
|
|
{
|
|
// Object/Geo/Part IDs must match
|
|
bool bMatchingIds = true;
|
|
if (ObjectId != InOutputObjectIdentifier.ObjectId
|
|
|| GeoId != InOutputObjectIdentifier.GeoId
|
|
|| PartId != InOutputObjectIdentifier.PartId)
|
|
bMatchingIds = false;
|
|
|
|
if ((bLoaded && !InOutputObjectIdentifier.bLoaded)
|
|
|| (!bLoaded && InOutputObjectIdentifier.bLoaded))
|
|
{
|
|
// If one of the two identifier is loaded,
|
|
// we can simply compare the part names
|
|
if (PartName.Equals(InOutputObjectIdentifier.PartName)
|
|
&& SplitIdentifier.Equals(InOutputObjectIdentifier.SplitIdentifier))
|
|
return true;
|
|
}
|
|
|
|
if (!bMatchingIds)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If split ID and name match, we're equal...
|
|
if (SplitIdentifier.Equals(InOutputObjectIdentifier.SplitIdentifier))
|
|
return true;
|
|
|
|
// ... if not we're different
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FHoudiniOutputObjectIdentifier::Matches(const FHoudiniGeoPartObject& InHGPO) const
|
|
{
|
|
// Object/Geo/Part IDs must match
|
|
bool bMatchingIds = true;
|
|
if (ObjectId != InHGPO.ObjectId
|
|
|| GeoId != InHGPO.GeoId
|
|
|| PartId != InHGPO.PartId)
|
|
bMatchingIds = false;
|
|
|
|
if ((bLoaded && !InHGPO.bLoaded) || (!bLoaded && InHGPO.bLoaded))
|
|
{
|
|
// If either the HGPO or the Identifer is nmarked as loaded,
|
|
// we can simply compare the part names
|
|
if (PartName.Equals(InHGPO.PartName))
|
|
return true;
|
|
}
|
|
|
|
if (!bMatchingIds)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If the HGPO has our split identifier
|
|
//if (InHGPO.SplitGroups.Contains(SplitIdentifier))
|
|
// return true;
|
|
|
|
//
|
|
return true;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
// FHoudiniBakedOutputObjectIdentifier
|
|
// ----------------------------------------------------
|
|
|
|
|
|
FHoudiniBakedOutputObjectIdentifier::FHoudiniBakedOutputObjectIdentifier()
|
|
{
|
|
PartId = -1;
|
|
SplitIdentifier = FString();
|
|
}
|
|
|
|
FHoudiniBakedOutputObjectIdentifier::FHoudiniBakedOutputObjectIdentifier(
|
|
const int32& InPartId, const FString& InSplitIdentifier)
|
|
{
|
|
PartId = InPartId;
|
|
SplitIdentifier = InSplitIdentifier;
|
|
}
|
|
|
|
FHoudiniBakedOutputObjectIdentifier::FHoudiniBakedOutputObjectIdentifier(const FHoudiniOutputObjectIdentifier& InIdentifier)
|
|
{
|
|
PartId = InIdentifier.PartId;
|
|
SplitIdentifier = InIdentifier.SplitIdentifier;
|
|
}
|
|
|
|
uint32
|
|
FHoudiniBakedOutputObjectIdentifier::GetTypeHash() const
|
|
{
|
|
const int32 HashBuffer = PartId;
|
|
const int32 Hash = FCrc::MemCrc32((void *)&HashBuffer, sizeof(HashBuffer));
|
|
return FCrc::StrCrc32(*SplitIdentifier, Hash);
|
|
}
|
|
|
|
uint32
|
|
GetTypeHash(const FHoudiniBakedOutputObjectIdentifier& InIdentifier)
|
|
{
|
|
return InIdentifier.GetTypeHash();
|
|
}
|
|
|
|
bool
|
|
FHoudiniBakedOutputObjectIdentifier::operator==(const FHoudiniBakedOutputObjectIdentifier& InIdentifier) const
|
|
{
|
|
return (InIdentifier.PartId == PartId && InIdentifier.SplitIdentifier.Equals(SplitIdentifier));
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
// FHoudiniBakedOutputObject
|
|
// ----------------------------------------------------
|
|
|
|
|
|
FHoudiniBakedOutputObject::FHoudiniBakedOutputObject()
|
|
: Actor()
|
|
, ActorBakeName(NAME_None)
|
|
, BakedObject()
|
|
, BakedComponent()
|
|
{
|
|
}
|
|
|
|
|
|
FHoudiniBakedOutputObject::FHoudiniBakedOutputObject(AActor* InActor, FName InActorBakeName, UObject* InBakeObject, UObject* InBakedComponent)
|
|
: Actor(FSoftObjectPath(InActor).ToString())
|
|
, ActorBakeName(InActorBakeName)
|
|
, BakedObject(FSoftObjectPath(InBakeObject).ToString())
|
|
, BakedComponent(FSoftObjectPath(InBakedComponent).ToString())
|
|
{
|
|
}
|
|
|
|
|
|
AActor*
|
|
FHoudiniBakedOutputObject::GetActorIfValid(bool bInTryLoad) const
|
|
{
|
|
const FSoftObjectPath ActorPath(Actor);
|
|
|
|
if (!ActorPath.IsValid())
|
|
return nullptr;
|
|
|
|
UObject* Object = ActorPath.ResolveObject();
|
|
if (!Object && bInTryLoad)
|
|
Object = ActorPath.TryLoad();
|
|
|
|
if (!IsValid(Object))
|
|
return nullptr;
|
|
|
|
return Cast<AActor>(Object);
|
|
}
|
|
|
|
UObject*
|
|
FHoudiniBakedOutputObject::GetBakedObjectIfValid(bool bInTryLoad) const
|
|
{
|
|
const FSoftObjectPath ObjectPath(BakedObject);
|
|
|
|
if (!ObjectPath.IsValid())
|
|
return nullptr;
|
|
|
|
UObject* Object = ObjectPath.ResolveObject();
|
|
if (!Object && bInTryLoad)
|
|
Object = ObjectPath.TryLoad();
|
|
|
|
if (!IsValid(Object))
|
|
return nullptr;
|
|
|
|
return Object;
|
|
}
|
|
|
|
UObject*
|
|
FHoudiniBakedOutputObject::GetBakedComponentIfValid(bool bInTryLoad) const
|
|
{
|
|
const FSoftObjectPath ComponentPath(BakedComponent);
|
|
|
|
if (!ComponentPath.IsValid())
|
|
return nullptr;
|
|
|
|
UObject* Object = ComponentPath.ResolveObject();
|
|
if (!Object && bInTryLoad)
|
|
Object = ComponentPath.TryLoad();
|
|
|
|
if (!IsValid(Object))
|
|
return nullptr;
|
|
|
|
return Object;
|
|
}
|
|
|
|
UBlueprint*
|
|
FHoudiniBakedOutputObject::GetBlueprintIfValid(bool bInTryLoad) const
|
|
{
|
|
const FSoftObjectPath BlueprintPath(Blueprint);
|
|
|
|
if (!BlueprintPath.IsValid())
|
|
return nullptr;
|
|
|
|
UObject* Object = BlueprintPath.ResolveObject();
|
|
if (!Object && bInTryLoad)
|
|
Object = BlueprintPath.TryLoad();
|
|
|
|
if (!IsValid(Object))
|
|
return nullptr;
|
|
|
|
return Cast<UBlueprint>(Object);
|
|
}
|
|
|
|
ULandscapeLayerInfoObject*
|
|
FHoudiniBakedOutputObject::GetLandscapeLayerInfoIfValid(const FName& InLayerName, const bool bInTryLoad) const
|
|
{
|
|
if (!LandscapeLayers.Contains(InLayerName))
|
|
return nullptr;
|
|
|
|
const FString& LayerInfoPathStr = LandscapeLayers.FindChecked(InLayerName);
|
|
const FSoftObjectPath LayerInfoPath(LayerInfoPathStr);
|
|
|
|
if (!LayerInfoPath.IsValid())
|
|
return nullptr;
|
|
|
|
UObject* Object = LayerInfoPath.ResolveObject();
|
|
if (!Object && bInTryLoad)
|
|
Object = LayerInfoPath.TryLoad();
|
|
|
|
if (!IsValid(Object))
|
|
return nullptr;
|
|
|
|
return Cast<ULandscapeLayerInfoObject>(Object);
|
|
}
|
|
|
|
|
|
UHoudiniOutput::UHoudiniOutput(const FObjectInitializer & ObjectInitializer)
|
|
: Super(ObjectInitializer)
|
|
, Type(EHoudiniOutputType::Invalid)
|
|
, StaleCount(0)
|
|
, bLandscapeWorldComposition(false)
|
|
, bIsEditableNode(false)
|
|
, bHasEditableNodeBuilt(false)
|
|
, bCanDeleteHoudiniNodes(true)
|
|
{
|
|
|
|
}
|
|
|
|
UHoudiniOutput::~UHoudiniOutput()
|
|
{
|
|
Type = EHoudiniOutputType::Invalid;
|
|
StaleCount = 0;
|
|
bIsUpdating = false;
|
|
|
|
HoudiniGeoPartObjects.Empty();
|
|
OutputObjects.Empty();
|
|
InstancedOutputs.Empty();
|
|
AssignementMaterials.Empty();
|
|
ReplacementMaterials.Empty();
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::BeginDestroy()
|
|
{
|
|
Super::BeginDestroy();
|
|
}
|
|
|
|
FBox
|
|
UHoudiniOutput::GetBounds() const
|
|
{
|
|
FBox BoxBounds(ForceInitToZero);
|
|
|
|
switch (GetType())
|
|
{
|
|
case EHoudiniOutputType::Mesh:
|
|
{
|
|
for (auto & CurPair : OutputObjects)
|
|
{
|
|
const FHoudiniOutputObject& CurObj = CurPair.Value;
|
|
|
|
UMeshComponent* MeshComp = nullptr;
|
|
if (CurObj.bProxyIsCurrent)
|
|
{
|
|
MeshComp = Cast<UMeshComponent>(CurObj.ProxyComponent);
|
|
}
|
|
else
|
|
{
|
|
MeshComp = Cast<UMeshComponent>(CurObj.OutputComponent);
|
|
}
|
|
|
|
if (!MeshComp || MeshComp->IsPendingKill())
|
|
continue;
|
|
|
|
BoxBounds += MeshComp->Bounds.GetBox();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EHoudiniOutputType::Landscape:
|
|
{
|
|
for (auto & CurPair : OutputObjects)
|
|
{
|
|
const FHoudiniOutputObject& CurObj = CurPair.Value;
|
|
UHoudiniLandscapePtr* CurLandscapeObj = Cast<UHoudiniLandscapePtr>(CurObj.OutputObject);
|
|
if (!CurLandscapeObj || CurLandscapeObj->IsPendingKill())
|
|
continue;
|
|
|
|
ALandscapeProxy* Landscape = Cast<ALandscapeProxy>(CurLandscapeObj->GetRawPtr());
|
|
if (!Landscape || Landscape->IsPendingKill())
|
|
continue;
|
|
|
|
FVector Origin, Extent;
|
|
Landscape->GetActorBounds(false, Origin, Extent);
|
|
|
|
FBox LandscapeBounds = FBox::BuildAABB(Origin, Extent);
|
|
BoxBounds += LandscapeBounds;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EHoudiniOutputType::Instancer:
|
|
{
|
|
for (auto & CurPair : OutputObjects)
|
|
{
|
|
const FHoudiniOutputObject& CurObj = CurPair.Value;
|
|
USceneComponent* InstancedComp = Cast<USceneComponent>(CurObj.OutputObject);
|
|
if (!InstancedComp || InstancedComp->IsPendingKill())
|
|
continue;
|
|
|
|
BoxBounds += InstancedComp->Bounds.GetBox();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EHoudiniOutputType::Curve:
|
|
{
|
|
for (auto & CurPair : OutputObjects)
|
|
{
|
|
const FHoudiniOutputObject& CurObj = CurPair.Value;
|
|
UHoudiniSplineComponent* CurHoudiniSplineComp = Cast<UHoudiniSplineComponent>(CurObj.OutputComponent);
|
|
if (!CurHoudiniSplineComp || CurHoudiniSplineComp->IsPendingKill())
|
|
continue;
|
|
|
|
FBox CurCurveBound(ForceInitToZero);
|
|
for (auto & Trans : CurHoudiniSplineComp->CurvePoints)
|
|
{
|
|
CurCurveBound += Trans.GetLocation();
|
|
}
|
|
|
|
UHoudiniAssetComponent* OuterHAC = Cast<UHoudiniAssetComponent>(GetOuter());
|
|
if (OuterHAC && !OuterHAC->IsPendingKill())
|
|
BoxBounds += CurCurveBound.MoveTo(OuterHAC->GetComponentLocation());
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case EHoudiniOutputType::Skeletal:
|
|
case EHoudiniOutputType::Invalid:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return BoxBounds;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::Clear()
|
|
{
|
|
StaleCount = 0;
|
|
|
|
HoudiniGeoPartObjects.Empty();
|
|
|
|
for (auto& CurrentOutputObject : OutputObjects)
|
|
{
|
|
// Clear the output component
|
|
USceneComponent* SceneComp = Cast<USceneComponent>(CurrentOutputObject.Value.OutputComponent);
|
|
if (SceneComp && !SceneComp->IsPendingKill())
|
|
{
|
|
SceneComp->DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
|
|
SceneComp->UnregisterComponent();
|
|
SceneComp->DestroyComponent();
|
|
}
|
|
|
|
// Also destroy proxy components
|
|
USceneComponent* ProxyComp = Cast<USceneComponent>(CurrentOutputObject.Value.ProxyComponent);
|
|
if (ProxyComp && !ProxyComp->IsPendingKill())
|
|
{
|
|
ProxyComp->DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
|
|
ProxyComp->UnregisterComponent();
|
|
ProxyComp->DestroyComponent();
|
|
}
|
|
|
|
if (Type == EHoudiniOutputType::Landscape && !bLandscapeWorldComposition && !IsGarbageCollecting())
|
|
{
|
|
// NOTE: We cannot resolve soft pointers during garbage collection. Any Get() or IsValid() call
|
|
// will result in a StaticFindObject() call which will raise an exception during GC.
|
|
UHoudiniLandscapePtr* LandscapePtr = Cast<UHoudiniLandscapePtr>(CurrentOutputObject.Value.OutputObject);
|
|
ALandscapeProxy* LandscapeProxy = LandscapePtr ? LandscapePtr->GetRawPtr() : nullptr;
|
|
if (LandscapeProxy && !LandscapeProxy->IsPendingKill())
|
|
{
|
|
LandscapeProxy->DetachFromActor(FDetachmentTransformRules::KeepWorldTransform);
|
|
LandscapeProxy->ConditionalBeginDestroy();
|
|
LandscapeProxy->Destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
OutputObjects.Empty();
|
|
InstancedOutputs.Empty();
|
|
AssignementMaterials.Empty();
|
|
ReplacementMaterials.Empty();
|
|
|
|
Type = EHoudiniOutputType::Invalid;
|
|
}
|
|
|
|
bool
|
|
UHoudiniOutput::ShouldDeferClear() const
|
|
{
|
|
if (Type == EHoudiniOutputType::Landscape)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasGeoChanged() const
|
|
{
|
|
for (auto currentHGPO : HoudiniGeoPartObjects)
|
|
{
|
|
if (currentHGPO.bHasGeoChanged)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasTransformChanged() const
|
|
{
|
|
for (auto currentHGPO : HoudiniGeoPartObjects)
|
|
{
|
|
if (currentHGPO.bHasTransformChanged)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasMaterialsChanged() const
|
|
{
|
|
for (auto currentHGPO : HoudiniGeoPartObjects)
|
|
{
|
|
if (currentHGPO.bHasMaterialsChanged)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasHoudiniGeoPartObject(const FHoudiniGeoPartObject& InHGPO) const
|
|
{
|
|
return HoudiniGeoPartObjects.Find(InHGPO) != INDEX_NONE;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HeightfieldMatch(const FHoudiniGeoPartObject& InHGPO, const bool& bVolumeNameShouldMatch) const
|
|
{
|
|
if (InHGPO.Type != EHoudiniPartType::Volume)
|
|
return false;
|
|
|
|
if (InHGPO.VolumeName.IsEmpty())
|
|
return false;
|
|
|
|
for (auto& currentHGPO : HoudiniGeoPartObjects)
|
|
{
|
|
// Asset/Object/Geo IDs should match
|
|
if (currentHGPO.AssetId != InHGPO.AssetId
|
|
|| currentHGPO.ObjectId != InHGPO.ObjectId
|
|
|| currentHGPO.GeoId != InHGPO.GeoId)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Both HGPO type should be volumes
|
|
if (currentHGPO.Type != EHoudiniPartType::Volume)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Volume tile index should match
|
|
if (currentHGPO.VolumeTileIndex != InHGPO.VolumeTileIndex)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// We've specified if we want the name to match/to be different:
|
|
// when looking in previous outputs, we want the name to match
|
|
// when looking in newly created outputs, we want to be sure the names are different
|
|
bool bNameMatch = InHGPO.VolumeName.Equals(currentHGPO.VolumeName, ESearchCase::IgnoreCase);
|
|
if (bNameMatch != bVolumeNameShouldMatch)
|
|
continue;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::MarkAllHGPOsAsStale(const bool& bInStale)
|
|
{
|
|
// Since objects can only be added to this array,
|
|
// Simply keep track of the current number of HoudiniGeoPartObject
|
|
StaleCount = bInStale ? HoudiniGeoPartObjects.Num() : 0;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::DeleteAllStaleHGPOs()
|
|
{
|
|
// Simply delete the first "StaleCount" objects and reset the stale marker
|
|
HoudiniGeoPartObjects.RemoveAt(0, StaleCount);
|
|
StaleCount = 0;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::AddNewHGPO(const FHoudiniGeoPartObject& InHGPO)
|
|
{
|
|
HoudiniGeoPartObjects.Add(InHGPO);
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::UpdateOutputType()
|
|
{
|
|
int32 MeshCount = 0;
|
|
int32 CurveCount = 0;
|
|
int32 VolumeCount = 0;
|
|
int32 InstancerCount = 0;
|
|
for (auto& HGPO : HoudiniGeoPartObjects)
|
|
{
|
|
switch (HGPO.Type)
|
|
{
|
|
case EHoudiniPartType::Mesh:
|
|
MeshCount++;
|
|
break;
|
|
case EHoudiniPartType::Curve:
|
|
CurveCount++;
|
|
break;
|
|
case EHoudiniPartType::Volume:
|
|
VolumeCount++;
|
|
break;
|
|
case EHoudiniPartType::Instancer:
|
|
InstancerCount++;
|
|
break;
|
|
default:
|
|
case EHoudiniPartType::Invalid:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (VolumeCount > 0)
|
|
{
|
|
// If we have a volume, we're a landscape
|
|
Type = EHoudiniOutputType::Landscape;
|
|
}
|
|
else if (InstancerCount > 0)
|
|
{
|
|
// if we have at least an instancer, we're one
|
|
Type = EHoudiniOutputType::Instancer;
|
|
}
|
|
else if (MeshCount > 0)
|
|
{
|
|
Type = EHoudiniOutputType::Mesh;
|
|
}
|
|
else if (CurveCount > 0)
|
|
{
|
|
Type = EHoudiniOutputType::Curve;
|
|
}
|
|
else
|
|
{
|
|
// No valid HGPO detected...
|
|
Type = EHoudiniOutputType::Invalid;
|
|
}
|
|
}
|
|
|
|
UHoudiniOutput*
|
|
UHoudiniOutput::DuplicateAndCopyProperties(UObject* DestOuter, FName NewName)
|
|
{
|
|
UHoudiniOutput* NewOutput = Cast<UHoudiniOutput>(StaticDuplicateObject(this, DestOuter, NewName));
|
|
|
|
NewOutput->CopyPropertiesFrom(this, false);
|
|
|
|
return NewOutput;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::CopyPropertiesFrom(UHoudiniOutput* InInput, bool bCopyAllProperties)
|
|
{
|
|
// Copy the state of this UHoudiniInput object.
|
|
if (bCopyAllProperties)
|
|
{
|
|
// Stash all the data that we want to preserve, and re-apply after property copy took place
|
|
// (similar to Get/Apply component instance data). This is typically only needed
|
|
// for certain properties that require cleanup when being replaced / removed.
|
|
TMap<FHoudiniOutputObjectIdentifier, FHoudiniOutputObject> PrevOutputObjects = OutputObjects;
|
|
TMap<FHoudiniOutputObjectIdentifier, FHoudiniInstancedOutput> PrevInstancedOutputs = InstancedOutputs;
|
|
|
|
UEngine::FCopyPropertiesForUnrelatedObjectsParams Params;
|
|
Params.bDoDelta = false; // Perform a deep copy
|
|
Params.bClearReferences = false; // References will be replaced afterwards.
|
|
UEngine::CopyPropertiesForUnrelatedObjects(InInput, this, Params);
|
|
|
|
// Restore the desired properties.
|
|
OutputObjects = PrevOutputObjects;
|
|
InstancedOutputs = PrevInstancedOutputs;
|
|
}
|
|
|
|
// Copy any additional DuplicateTransient properties.
|
|
bHasEditableNodeBuilt = InInput->bHasEditableNodeBuilt;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes)
|
|
{
|
|
bCanDeleteHoudiniNodes = bInCanDeleteNodes;
|
|
}
|
|
|
|
FString
|
|
UHoudiniOutput::OutputTypeToString(const EHoudiniOutputType& InOutputType)
|
|
{
|
|
FString OutputTypeStr;
|
|
switch (InOutputType)
|
|
{
|
|
case EHoudiniOutputType::Mesh:
|
|
OutputTypeStr = TEXT("Mesh");
|
|
break;
|
|
case EHoudiniOutputType::Instancer:
|
|
OutputTypeStr = TEXT("Instancer");
|
|
break;
|
|
case EHoudiniOutputType::Landscape:
|
|
OutputTypeStr = TEXT("Landscape");
|
|
break;
|
|
case EHoudiniOutputType::Curve:
|
|
OutputTypeStr = TEXT("Curve");
|
|
break;
|
|
case EHoudiniOutputType::Skeletal:
|
|
OutputTypeStr = TEXT("Skeletal");
|
|
break;
|
|
|
|
default:
|
|
case EHoudiniOutputType::Invalid:
|
|
OutputTypeStr = TEXT("Invalid");
|
|
break;
|
|
}
|
|
|
|
return OutputTypeStr;
|
|
}
|
|
|
|
void
|
|
UHoudiniOutput::MarkAsLoaded(const bool& InLoaded)
|
|
{
|
|
// Mark all HGPO as loaded
|
|
for (auto& HGPO : HoudiniGeoPartObjects)
|
|
{
|
|
HGPO.bLoaded = InLoaded;
|
|
}
|
|
|
|
// Mark all output object's identifier as loaded
|
|
for (auto& Iter : OutputObjects)
|
|
{
|
|
FHoudiniOutputObjectIdentifier& Identifier = Iter.Key;
|
|
Identifier.bLoaded = InLoaded;
|
|
}
|
|
|
|
// Instanced outputs
|
|
for (auto& Iter : InstancedOutputs)
|
|
{
|
|
FHoudiniOutputObjectIdentifier& Identifier = Iter.Key;
|
|
Identifier.bLoaded = InLoaded;
|
|
}
|
|
}
|
|
|
|
|
|
const bool
|
|
UHoudiniOutput::HasAnyProxy() const
|
|
{
|
|
for (const auto& Pair : OutputObjects)
|
|
{
|
|
UObject* FoundProxy = Pair.Value.ProxyObject;
|
|
if (FoundProxy && !FoundProxy->IsPendingKill())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasProxy(const FHoudiniOutputObjectIdentifier& InIdentifier) const
|
|
{
|
|
const FHoudiniOutputObject* FoundOutputObject = OutputObjects.Find(InIdentifier);
|
|
if (!FoundOutputObject)
|
|
return false;
|
|
|
|
UObject* FoundProxy = FoundOutputObject->ProxyObject;
|
|
if (!FoundProxy || FoundProxy->IsPendingKill())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::HasAnyCurrentProxy() const
|
|
{
|
|
for (const auto& Pair : OutputObjects)
|
|
{
|
|
UObject* FoundProxy = Pair.Value.ProxyObject;
|
|
if (FoundProxy && !FoundProxy->IsPendingKill())
|
|
{
|
|
if(Pair.Value.bProxyIsCurrent)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const bool
|
|
UHoudiniOutput::IsProxyCurrent(const FHoudiniOutputObjectIdentifier &InIdentifier) const
|
|
{
|
|
if (!HasProxy(InIdentifier))
|
|
return false;
|
|
|
|
const FHoudiniOutputObject* FoundOutputObject = OutputObjects.Find(InIdentifier);
|
|
if (!FoundOutputObject)
|
|
return false;
|
|
|
|
return FoundOutputObject->bProxyIsCurrent;
|
|
}
|