Andron666
863 lines
26 KiB
C++
863 lines
26 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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <functional>
|
|
|
|
#include "HoudiniSplineComponent.h"
|
|
#include "HoudiniGeoPartObject.h"
|
|
|
|
#include "CoreTypes.h"
|
|
#include "Materials/MaterialInterface.h"
|
|
#include "UObject/Object.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
|
|
#include "Engine/Brush.h"
|
|
#include "Engine/Polys.h"
|
|
#include "UObject/SoftObjectPtr.h"
|
|
|
|
#include "HoudiniInputObject.generated.h"
|
|
|
|
class UStaticMesh;
|
|
class USkeletalMesh;
|
|
class USceneComponent;
|
|
class UStaticMeshComponent;
|
|
class UInstancedStaticMeshComponent;
|
|
class USplineComponent;
|
|
class UHoudiniAssetComponent;
|
|
class AActor;
|
|
class ALandscapeProxy;
|
|
class ABrush;
|
|
class UHoudiniInput;
|
|
class ALandscapeProxy;
|
|
class UModel;
|
|
class UHoudiniInput;
|
|
class UCameraComponent;
|
|
|
|
UENUM()
|
|
enum class EHoudiniInputObjectType : uint8
|
|
{
|
|
Invalid,
|
|
|
|
Object,
|
|
StaticMesh,
|
|
SkeletalMesh,
|
|
SceneComponent,
|
|
StaticMeshComponent,
|
|
InstancedStaticMeshComponent,
|
|
SplineComponent,
|
|
HoudiniSplineComponent,
|
|
HoudiniAssetComponent,
|
|
Actor,
|
|
Landscape,
|
|
Brush,
|
|
CameraComponent,
|
|
DataTable,
|
|
HoudiniAssetActor,
|
|
FoliageType_InstancedStaticMesh,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UObjects input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputObject : public UObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
// Create the proper input object
|
|
static UHoudiniInputObject * CreateTypedInputObject(UObject * InObject, UObject* InOuter, const FString& InParamName);
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
// Check whether two input objects match
|
|
virtual bool Matches(const UHoudiniInputObject& Other) const;
|
|
|
|
//
|
|
static EHoudiniInputObjectType GetInputObjectTypeFromObject(UObject* InObject);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject);
|
|
|
|
// Invalidate and ask for the deletion of this input object's node
|
|
virtual void InvalidateData();
|
|
|
|
// UObject accessor
|
|
virtual UObject* GetObject() const;
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasChanged() const { return bHasChanged; };
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasTransformChanged() const { return bTransformChanged; };
|
|
|
|
// Indicates if this input needs to trigger an update
|
|
virtual bool NeedsToTriggerUpdate() const { return bNeedsToTriggerUpdate; };
|
|
|
|
virtual void MarkChanged(const bool& bInChanged) { bHasChanged = bInChanged; SetNeedsToTriggerUpdate(bInChanged); };
|
|
void MarkTransformChanged(const bool& bInChanged) { bTransformChanged = bInChanged; SetNeedsToTriggerUpdate(bInChanged); };
|
|
virtual void SetNeedsToTriggerUpdate(const bool& bInTriggersUpdate) { bNeedsToTriggerUpdate = bInTriggersUpdate; };
|
|
|
|
void SetImportAsReference(const bool& bInImportAsRef) { bImportAsReference = bInImportAsRef; };
|
|
bool GetImportAsReference() const { return bImportAsReference; };
|
|
|
|
#if WITH_EDITOR
|
|
void SwitchUniformScaleLock() { bUniformScaleLocked = !bUniformScaleLocked; };
|
|
bool IsUniformScaleLocked() const { return bUniformScaleLocked; };
|
|
|
|
void PostEditUndo() override;
|
|
#endif
|
|
|
|
virtual UHoudiniInputObject* DuplicateAndCopyState(UObject* DestOuter);
|
|
virtual void CopyStateFrom(UHoudiniInputObject* InInput, bool bCopyAllProperties);
|
|
|
|
// Set whether this object can delete Houdini nodes.
|
|
virtual void SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes);
|
|
bool CanDeleteHoudiniNodes() const { return bCanDeleteHoudiniNodes; }
|
|
|
|
FGuid GetInputGuid() const { return Guid; }
|
|
|
|
|
|
protected:
|
|
|
|
virtual void BeginDestroy() override;
|
|
|
|
public:
|
|
|
|
// The object referenced by this input
|
|
// This property should be protected. Don't access this directly. Use GetObject() / Update() instead.
|
|
UPROPERTY()
|
|
TSoftObjectPtr<UObject> InputObject;
|
|
|
|
// The object's transform/transform offset
|
|
UPROPERTY()
|
|
FTransform Transform;
|
|
|
|
// The type of Object this input refers to
|
|
UPROPERTY()
|
|
EHoudiniInputObjectType Type;
|
|
|
|
// This input object's "main" (SOP) NodeId
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
int32 InputNodeId;
|
|
|
|
// This input object's "container" (OBJ) NodeId
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
int32 InputObjectNodeId;
|
|
|
|
// Guid that uniquely identifies this input object.
|
|
// Also useful to correlate inputs between blueprint component templates and instances.
|
|
UPROPERTY(DuplicateTransient)
|
|
FGuid Guid;
|
|
|
|
protected:
|
|
|
|
// Indicates this input object has changed
|
|
UPROPERTY(DuplicateTransient)
|
|
bool bHasChanged;
|
|
|
|
// Indicates this input object should trigger an input update/cook
|
|
UPROPERTY(DuplicateTransient)
|
|
bool bNeedsToTriggerUpdate;
|
|
|
|
// Indicates that this input transform should be updated
|
|
UPROPERTY(DuplicateTransient)
|
|
bool bTransformChanged;
|
|
|
|
UPROPERTY()
|
|
bool bImportAsReference;
|
|
|
|
// Indicates if change the scale of Transfrom Offset of this object uniformly
|
|
#if WITH_EDITORONLY_DATA
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
bool bUniformScaleLocked;
|
|
#endif
|
|
|
|
UPROPERTY()
|
|
bool bCanDeleteHoudiniNodes;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UStaticMesh input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputStaticMesh : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
// UHoudiniInputObject overrides
|
|
|
|
// virtual void DuplicateAndCopyState(UObject* DestOuter, UHoudiniInputObject*& OutNewObject) override;
|
|
virtual void CopyStateFrom(UHoudiniInputObject* InInput, bool bCopyAllProperties) override;
|
|
virtual void SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes) override;
|
|
virtual void InvalidateData() override;
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// Nothing to add for Static Meshes?
|
|
|
|
// StaticMesh accessor
|
|
virtual class UStaticMesh* GetStaticMesh() const;
|
|
|
|
// Blueprint accessor
|
|
virtual class UBlueprint* GetBlueprint() const;
|
|
|
|
// Check if this SM Input object is passed in as a BP
|
|
virtual bool bIsBlueprint() const;
|
|
|
|
// The Blueprint's Static Meshe Components that can be sent as inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputStaticMesh*> BlueprintStaticMeshes;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// USkeletalMesh input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputSkeletalMesh : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// Nothing to add for SkeletalMesh Meshes?
|
|
|
|
// StaticMesh accessor
|
|
class USkeletalMesh* GetSkeletalMesh();
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// USceneComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputSceneComponent : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// SceneComponent accessor
|
|
class USceneComponent* GetSceneComponent();
|
|
|
|
// Returns true if the attached actor's (parent) transform has been modified
|
|
virtual bool HasActorTransformChanged() const;
|
|
|
|
// Returns true if the attached component's transform has been modified
|
|
virtual bool HasComponentTransformChanged() const;
|
|
|
|
// Return true if the component itself has been modified
|
|
virtual bool HasComponentChanged() const;
|
|
|
|
public:
|
|
|
|
// This component's parent Actor transform
|
|
UPROPERTY()
|
|
FTransform ActorTransform = FTransform::Identity;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UStaticMeshComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputMeshComponent : public UHoudiniInputSceneComponent
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// StaticMeshComponent accessor
|
|
UStaticMeshComponent* GetStaticMeshComponent();
|
|
|
|
// Get the referenced StaticMesh
|
|
UStaticMesh* GetStaticMesh();
|
|
|
|
// Returns true if the attached component's materials have been modified
|
|
bool HasComponentMaterialsChanged() const;
|
|
|
|
// Return true if SMC's static mesh has been modified
|
|
virtual bool HasComponentChanged() const override;
|
|
|
|
public:
|
|
|
|
// Keep track of the selected Static Mesh
|
|
UPROPERTY()
|
|
TSoftObjectPtr<class UStaticMesh> StaticMesh = nullptr;
|
|
|
|
// Path to the materials assigned on the SMC
|
|
UPROPERTY()
|
|
TArray<FString> MeshComponentsMaterials;
|
|
};
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UInstancedStaticMeshComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputInstancedMeshComponent : public UHoudiniInputMeshComponent
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// InstancedStaticMeshComponent accessor
|
|
UInstancedStaticMeshComponent* GetInstancedStaticMeshComponent();
|
|
|
|
// Returns true if the instances have changed
|
|
bool HasInstancesChanged() const;
|
|
|
|
// Returns true if the attached component's transform has been modified
|
|
virtual bool HasComponentTransformChanged() const override;
|
|
|
|
public:
|
|
|
|
// Array of transform for this ISMC's instances
|
|
UPROPERTY()
|
|
TArray<FTransform> InstanceTransforms;
|
|
};
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// USplineComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputSplineComponent : public UHoudiniInputSceneComponent
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// USplineComponent accessor
|
|
USplineComponent* GetSplineComponent();
|
|
|
|
// Returns true if the attached spline component has been modified
|
|
bool HasSplineComponentChanged(float fCurrentSplineResolution) const;
|
|
|
|
// Returns true if the attached actor's (parent) transform has been modified
|
|
virtual bool HasActorTransformChanged() const;
|
|
|
|
// Returns true if the attached component's transform has been modified
|
|
virtual bool HasComponentTransformChanged() const;
|
|
|
|
// Return true if the component itself has been modified
|
|
virtual bool HasComponentChanged() const;
|
|
|
|
public:
|
|
|
|
// Number of CVs used by the spline component, used to detect modification
|
|
UPROPERTY()
|
|
int32 NumberOfSplineControlPoints = -1;
|
|
|
|
// Spline Length, used for fast detection of modifications of the spline..
|
|
UPROPERTY()
|
|
float SplineLength = -1.0f;
|
|
|
|
// Spline resolution used to generate the asset, used to detect setting modification
|
|
UPROPERTY()
|
|
float SplineResolution = -1.0f;
|
|
|
|
// Is the spline closed?
|
|
UPROPERTY()
|
|
bool SplineClosed = false;
|
|
|
|
// Transforms of each of the spline's control points
|
|
UPROPERTY()
|
|
TArray<FTransform> SplineControlPoints;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UHoudiniSplineComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputHoudiniSplineComponent : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
virtual UObject* GetObject() const override;
|
|
|
|
virtual void MarkChanged(const bool& bInChanged) override;
|
|
|
|
virtual void SetNeedsToTriggerUpdate(const bool& bInTriggersUpdate) override;
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasChanged() const override;
|
|
|
|
// Indicates if this input needs to trigger an update
|
|
virtual bool NeedsToTriggerUpdate() const override;
|
|
|
|
// UHoudiniSplineComponent accessor
|
|
UHoudiniSplineComponent* GetCurveComponent() const;
|
|
|
|
public:
|
|
|
|
// The type of curve (polygon, NURBS, bezier)
|
|
UPROPERTY()
|
|
EHoudiniCurveType CurveType = EHoudiniCurveType::Polygon;
|
|
|
|
// The curve's method (CVs, Breakpoint, Freehand)
|
|
UPROPERTY()
|
|
EHoudiniCurveMethod CurveMethod = EHoudiniCurveMethod::CVs;
|
|
|
|
UPROPERTY()
|
|
bool Reversed = false;
|
|
|
|
|
|
protected:
|
|
|
|
// NOTE: We are using this reference to the component since the component, for now,
|
|
// lives on the same actor as this input object. If we use a Soft Object Reference instead the editor
|
|
// will complain about breaking references everytime we try to delete the actor.
|
|
UPROPERTY(Instanced)
|
|
UHoudiniSplineComponent* CachedComponent;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UCameraComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputCameraComponent : public UHoudiniInputSceneComponent
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// UCameraComponent accessor
|
|
UCameraComponent* GetCameraComponent();
|
|
|
|
// Return true if SMC's static mesh has been modified
|
|
virtual bool HasComponentChanged() const override;
|
|
|
|
public:
|
|
|
|
UPROPERTY()
|
|
float FOV;
|
|
|
|
UPROPERTY()
|
|
float AspectRatio;
|
|
|
|
UPROPERTY()
|
|
//TEnumAsByte<ECameraProjectionMode::Type> ProjectionType;
|
|
bool bIsOrthographic;
|
|
|
|
UPROPERTY()
|
|
float OrthoWidth;
|
|
UPROPERTY()
|
|
float OrthoNearClipPlane;
|
|
UPROPERTY()
|
|
float OrthoFarClipPlane;
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UHoudiniAssetComponent input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputHoudiniAsset : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// UHoudiniAssetComponent accessor
|
|
UHoudiniAssetComponent* GetHoudiniAssetComponent();
|
|
public:
|
|
|
|
// The output index of the node that we want to use as input
|
|
UPROPERTY()
|
|
int32 AssetOutputIndex;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// AActor input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputActor : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
//
|
|
virtual bool HasActorTransformChanged();
|
|
|
|
// Return true if any content of this actor has possibly changed (for example geometry edits on a
|
|
// Brush or changes on procedurally generated content).
|
|
// NOTE: This is more generally applicable and could be moved to the HoudiniInputObject class.
|
|
virtual bool HasContentChanged() const;
|
|
|
|
// AActor accessor
|
|
AActor* GetActor();
|
|
|
|
const TArray<UHoudiniInputSceneComponent*>& GetActorComponents() const { return ActorComponents; }
|
|
|
|
// The number of components added with the last call to Update
|
|
int32 GetLastUpdateNumComponentsAdded() const { return LastUpdateNumComponentsAdded; }
|
|
// The number of components remove with the last call to Update
|
|
int32 GetLastUpdateNumComponentsRemoved() const { return LastUpdateNumComponentsRemoved; }
|
|
|
|
protected:
|
|
|
|
// The actor's components that can be sent as inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputSceneComponent*> ActorComponents;
|
|
|
|
// The USceneComponents the actor had the last time we called Update (matches the ones in ActorComponents).
|
|
UPROPERTY()
|
|
TSet<TSoftObjectPtr<UObject>> ActorSceneComponents;
|
|
|
|
// The number of components added with the last call to Update
|
|
UPROPERTY()
|
|
int32 LastUpdateNumComponentsAdded;
|
|
|
|
// The number of components remove with the last call to Update
|
|
UPROPERTY()
|
|
int32 LastUpdateNumComponentsRemoved;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// ALandscapeProxy input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputLandscape : public UHoudiniInputActor
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
virtual bool HasActorTransformChanged() override;
|
|
|
|
// ALandscapeProxy accessor
|
|
ALandscapeProxy* GetLandscapeProxy();
|
|
|
|
void SetLandscapeProxy(UObject* InLandscapeProxy);
|
|
|
|
// Used to restore an input landscape's transform to its original state
|
|
UPROPERTY()
|
|
FTransform CachedInputLandscapeTraqnsform;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// ABrush input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// Cache info for a brush in order to determine whether it has changed.
|
|
|
|
#define BRUSH_HASH_SURFACE_PROPERTIES 0
|
|
|
|
//USTRUCT()
|
|
//struct FHoudiniBrushSurfaceInfo {
|
|
// GENERATED_BODY()
|
|
//
|
|
// FVector Base;
|
|
// FVector Normal;
|
|
// FVector TextureU;
|
|
// FVector TextureV;
|
|
// TSoftObjectPtr<UMaterialInterface> Material;
|
|
//
|
|
// FHoudiniBrushSurfaceInfo(const FVector& InBase, const FVector& InNormal, const FVector& InTextureU, const FVector& InTextureV, UMaterialInterface* InMaterial)
|
|
// : Base(InBase)
|
|
// , Normal(InNormal)
|
|
// , TextureU(InTextureU)
|
|
// , TextureV(InTextureV)
|
|
// , Material(InMaterial)
|
|
// { }
|
|
//
|
|
// inline bool operator==(const FHoudiniBrushSurfaceInfo& Other) {
|
|
// return Base.Equals(Other.Base)
|
|
// && Normal.Equals(Other.Normal)
|
|
// && TextureU.Equals(Other.TextureU)
|
|
// && TextureV.Equals(Other.TextureV)
|
|
// && Material.Get() == Other.Material.Get();
|
|
// }
|
|
//
|
|
// inline bool operator==(const FPoly& Poly) {
|
|
// return Base.Equals(Poly.Base)
|
|
// && Normal.Equals(Poly.Normal)
|
|
// && TextureU.Equals(Poly.TextureU)
|
|
// && TextureV.Equals(Poly.TextureV)
|
|
// && Material.Get() == Poly.Material;
|
|
// }
|
|
//};
|
|
|
|
USTRUCT()
|
|
struct FHoudiniBrushInfo
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
UPROPERTY()
|
|
TWeakObjectPtr<ABrush> BrushActor;
|
|
UPROPERTY()
|
|
FTransform CachedTransform;
|
|
UPROPERTY()
|
|
FVector CachedOrigin;
|
|
UPROPERTY()
|
|
FVector CachedExtent;
|
|
UPROPERTY()
|
|
TEnumAsByte<EBrushType> CachedBrushType;
|
|
|
|
UPROPERTY()
|
|
uint64 CachedSurfaceHash;
|
|
|
|
bool HasChanged() const;
|
|
|
|
static int32 GetNumVertexIndicesFromModel(const UModel* Model);
|
|
|
|
FHoudiniBrushInfo();
|
|
FHoudiniBrushInfo(ABrush* InBrushActor);
|
|
|
|
template <class T>
|
|
inline void HashCombine(uint64& s, const T & v) const
|
|
{
|
|
std::hash<T> h;
|
|
s^= h(v) + 0x9e3779b9 + (s<< 6) + (s>> 2);
|
|
}
|
|
|
|
inline void HashCombine(uint64& s, const FVector & V) const
|
|
{
|
|
HashCombine(s, V.X);
|
|
HashCombine(s, V.Y);
|
|
HashCombine(s, V.Z);
|
|
}
|
|
|
|
inline void CombinePolyHash(uint64& Hash, const FPoly& Poly) const
|
|
{
|
|
HashCombine(Hash, Poly.Base);
|
|
HashCombine(Hash, Poly.TextureU);
|
|
HashCombine(Hash, Poly.TextureV);
|
|
HashCombine(Hash, Poly.Normal);
|
|
// Do not add addresses to the hash, otherwise it would force a recook every unreal session!
|
|
// HashCombine(Hash, (uint64)(Poly.Material));
|
|
}
|
|
};
|
|
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputBrush : public UHoudiniInputActor
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
public:
|
|
|
|
UHoudiniInputBrush();
|
|
|
|
// Factory function
|
|
static UHoudiniInputBrush* Create(UObject* InObject, UObject* InOuter, const FString& InName);
|
|
|
|
//----------------------------------------------------------------------
|
|
// UHoudiniInputActor Interface - Begin
|
|
//----------------------------------------------------------------------
|
|
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasContentChanged() const override;
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasChanged() const override { return (!bIgnoreInputObject) && bHasChanged; };
|
|
|
|
// Indicates if this input has changed and should be updated
|
|
virtual bool HasTransformChanged() const override { return (!bIgnoreInputObject) && bTransformChanged; };
|
|
|
|
virtual bool HasActorTransformChanged() override;
|
|
|
|
virtual bool NeedsToTriggerUpdate() const override { return (!bIgnoreInputObject) && bNeedsToTriggerUpdate; };
|
|
|
|
//----------------------------------------------------------------------
|
|
// UHoudiniInputActor Interface - End
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
// ABrush accessor
|
|
ABrush* GetBrush() const;
|
|
|
|
UModel* GetCachedModel() const;
|
|
|
|
// Check whether any of the brushes, or their transforms, used to generate this model have changed.
|
|
bool HasBrushesChanged(const TArray<ABrush*>& InBrushes) const;
|
|
|
|
// Cache the combined model as well as the input brushes.
|
|
void UpdateCachedData(UModel* InCombinedModel, const TArray<ABrush*>& InBrushes);
|
|
|
|
// Returns whether this input object should be ignored when uploading objects to Houdini.
|
|
// This mechanism could be implemented on UHoudiniInputObject.
|
|
bool ShouldIgnoreThisInput();
|
|
|
|
|
|
// Find only the subtractive brush actors that intersect with the InputObject (Brush actor) bounding box but
|
|
// excluding any selector bounds actors.
|
|
static bool FindIntersectingSubtractiveBrushes(const UHoudiniInputBrush* InputBrush, TArray<ABrush*>& OutBrushes);
|
|
|
|
protected:
|
|
UPROPERTY()
|
|
TArray<FHoudiniBrushInfo> BrushesInfo;
|
|
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
UModel* CombinedModel;
|
|
|
|
UPROPERTY()
|
|
bool bIgnoreInputObject;
|
|
|
|
UPROPERTY()
|
|
TEnumAsByte<EBrushType> CachedInputBrushType;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UDataTable input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputDataTable : public UHoudiniInputObject
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
// DataTable accessor
|
|
class UDataTable* GetDataTable() const;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
// UFoliageType_InstancedStaticMesh input
|
|
//-----------------------------------------------------------------------------------------------------------------------------
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInputFoliageType_InstancedStaticMesh : public UHoudiniInputStaticMesh
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
public:
|
|
|
|
//
|
|
static UHoudiniInputObject* Create(UObject * InObject, UObject* InOuter, const FString& InName);
|
|
|
|
// UHoudiniInputObject overrides
|
|
|
|
// virtual void DuplicateAndCopyState(UObject* DestOuter, UHoudiniInputObject*& OutNewObject) override;
|
|
virtual void CopyStateFrom(UHoudiniInputObject* InInput, bool bCopyAllProperties) override;
|
|
|
|
//
|
|
virtual void Update(UObject * InObject) override;
|
|
|
|
// StaticMesh accessor
|
|
virtual class UStaticMesh* GetStaticMesh() const override;
|
|
|
|
virtual class UBlueprint* GetBlueprint() const override { return nullptr; }
|
|
|
|
virtual bool bIsBlueprint() const override { return false; }
|
|
};
|