Andron666
558 lines
22 KiB
C++
558 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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "CoreTypes.h"
|
|
#include "UObject/Object.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "Misc/Optional.h"
|
|
|
|
#include "HoudiniInputTypes.h"
|
|
#include "HoudiniInputObject.h"
|
|
|
|
#include "GameFramework/Actor.h"
|
|
#include "LandscapeProxy.h"
|
|
|
|
#include "HoudiniInput.generated.h"
|
|
|
|
|
|
|
|
class FReply;
|
|
|
|
enum class EHoudiniCurveType : int8;
|
|
enum class ECheckBoxState : unsigned char;
|
|
|
|
UCLASS()
|
|
class HOUDINIENGINERUNTIME_API UHoudiniInput : public UObject
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
public:
|
|
|
|
UHoudiniInput();
|
|
|
|
// Equality operator,
|
|
// We consider two inputs equals if they have the same name, objparam state, and input index/parmId
|
|
// TODO: ParmId might be an incorrect condition
|
|
bool operator==(const UHoudiniInput& other) const
|
|
{
|
|
return (bIsObjectPathParameter == other.bIsObjectPathParameter
|
|
&& InputIndex == other.InputIndex
|
|
&& ParmId == other.ParmId
|
|
&& Name.Equals(other.Name)
|
|
&& Label.Equals(other.Label));
|
|
}
|
|
|
|
bool Matches(const UHoudiniInput& other) const { return (*this == other); };
|
|
|
|
// Helper function returning a string from an InputType
|
|
static FString InputTypeToString(const EHoudiniInputType& InInputType);
|
|
|
|
// Helper function returning an InputType from a string
|
|
static EHoudiniInputType StringToInputType(const FString& InInputTypeString);
|
|
// Helper function returning a Houdini curve type from a string
|
|
static EHoudiniCurveType StringToHoudiniCurveType(const FString& CurveTypeString);
|
|
// Helper function returning a Houdini curve method from a string
|
|
static EHoudiniCurveMethod StringToHoudiniCurveMethod(const FString& CurveMethodString);
|
|
|
|
// Helper function indicating what classes are supported by an input type
|
|
static TArray<const UClass*> GetAllowedClasses(const EHoudiniInputType& InInputType);
|
|
|
|
// Helper function indicating if an object is supported by an input type
|
|
static bool IsObjectAcceptable(const EHoudiniInputType& InInputType, const UObject* InObject);
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
// Accessors
|
|
//------------------------------------------------------------------------------------------------
|
|
|
|
// Returns the NodeId of the asset / object merge we are associated with
|
|
int32 GetAssetNodeId() const { return AssetNodeId; };
|
|
// For objpath parameter, return the associated ParamId, -1 if we're a Geo input
|
|
int32 GetParameterId() const { return bIsObjectPathParameter ? ParmId : -1; };
|
|
// Returns the NodeId of the node plugged into this input
|
|
int32 GetInputNodeId() const { return InputNodeId; };
|
|
|
|
// For Geo inputs, returns the InputIndex, -1 if we're an object path parameter
|
|
int32 GetInputIndex() const { return bIsObjectPathParameter ? -1 : InputIndex; };
|
|
// Return the array containing all the nodes created for this input's data
|
|
TArray<int32>& GetCreatedDataNodeIds() { return CreatedDataNodeIds; };
|
|
// Returns the current input type
|
|
EHoudiniInputType GetInputType() const { return Type; };
|
|
// Returns the previous input type
|
|
EHoudiniInputType GetPreviousInputType() const { return PreviousType; };
|
|
// Returns the current input type as a string
|
|
FString GetInputTypeAsString() const { return InputTypeToString(Type); };
|
|
|
|
EHoudiniXformType GetDefaultXTransformType();
|
|
// Returns true when this input's Transform Type is set to NONE,
|
|
// false if set to INTO_THIS_OBJECT, 2 will use the input's type default value
|
|
bool GetKeepWorldTransform() const;
|
|
// Indicates if this input has changed and should be updated
|
|
bool HasChanged();
|
|
// Indicates if this input needs to trigger an update
|
|
bool NeedsToTriggerUpdate();
|
|
// Indicates this input should upload its data
|
|
bool IsDataUploadNeeded();
|
|
// Indicates this input's transform need to be uploaded
|
|
bool IsTransformUploadNeeded();
|
|
// Indicates if this input type has been changed
|
|
bool HasInputTypeChanged() const { return PreviousType != EHoudiniInputType::Invalid ? PreviousType != Type : false; }
|
|
//
|
|
bool GetUpdateInputLandscape() const;
|
|
|
|
void SetUpdateInputLandscape(const bool bInUpdateInputLandcape);
|
|
|
|
FString GetName() const { return Name; };
|
|
FString GetLabel() const { return Label; };
|
|
FString GetHelp() const { return Help; };
|
|
bool GetPackBeforeMerge() const { return bPackBeforeMerge; };
|
|
bool GetImportAsReference() const { return bImportAsReference; };
|
|
bool GetExportLODs() const { return bExportLODs; };
|
|
bool GetExportSockets() const { return bExportSockets; };
|
|
bool GetExportColliders() const { return bExportColliders; };
|
|
bool IsObjectPathParameter() const { return bIsObjectPathParameter; };
|
|
float GetUnrealSplineResolution() const { return UnrealSplineResolution; };
|
|
|
|
virtual bool GetCookOnCurveChange() const { return bCookOnCurveChanged; };
|
|
|
|
TArray<UHoudiniInputObject*>* GetHoudiniInputObjectArray(const EHoudiniInputType& InType);
|
|
const TArray<UHoudiniInputObject*>* GetHoudiniInputObjectArray(const EHoudiniInputType& InType) const;
|
|
TArray<AActor*>* GetBoundSelectorObjectArray();
|
|
const TArray<AActor*>* GetBoundSelectorObjectArray() const;
|
|
|
|
UHoudiniInputObject* GetHoudiniInputObjectAt(const int32& AtIndex);
|
|
const UHoudiniInputObject* GetHoudiniInputObjectAt(const int32& AtIndex) const;
|
|
AActor* GetBoundSelectorObjectAt(const int32& AtIndex);
|
|
|
|
UHoudiniInputObject* GetHoudiniInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex);
|
|
|
|
UObject* GetInputObjectAt(const int32& AtIndex);
|
|
UObject* GetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex);
|
|
|
|
int32 GetNumberOfInputObjects();
|
|
int32 GetNumberOfInputObjects(const EHoudiniInputType& InType);
|
|
|
|
int32 GetNumberOfInputMeshes();
|
|
int32 GetNumberOfInputMeshes(const EHoudiniInputType& InType);
|
|
|
|
int32 GetNumberOfBoundSelectorObjects() const;
|
|
|
|
bool IsWorldInputBoundSelector() const { return bIsWorldInputBoundSelector; };
|
|
bool GetWorldInputBoundSelectorAutoUpdates() const { return bWorldInputBoundSelectorAutoUpdate; };
|
|
|
|
FString GetNodeBaseName() const;
|
|
|
|
bool IsTransformUIExpanded(const int32& AtIndex);
|
|
|
|
// Return the transform offset for a given input object
|
|
FTransform* GetTransformOffset(const int32& AtIndex);
|
|
const FTransform GetTransformOffset(const int32& AtIndex) const;
|
|
|
|
// Returns the position offset for a given input object
|
|
TOptional<float> GetPositionOffsetX(int32 AtIndex) const;
|
|
TOptional<float> GetPositionOffsetY(int32 AtIndex) const;
|
|
TOptional<float> GetPositionOffsetZ(int32 AtIndex) const;
|
|
|
|
// Returns the rotation offset for a given input object
|
|
TOptional<float> GetRotationOffsetRoll(int32 AtIndex) const;
|
|
TOptional<float> GetRotationOffsetPitch(int32 AtIndex) const;
|
|
TOptional<float> GetRotationOffsetYaw(int32 AtIndex) const;
|
|
|
|
// Returns the scale offset for a given input object
|
|
TOptional<float> GetScaleOffsetX(int32 AtIndex) const;
|
|
TOptional<float> GetScaleOffsetY(int32 AtIndex) const;
|
|
TOptional<float> GetScaleOffsetZ(int32 AtIndex) const;
|
|
|
|
// Returns true if the object is one of our input object for the given type
|
|
bool ContainsInputObject(const UObject* InObject, const EHoudiniInputType& InType) const;
|
|
|
|
// Get all input object arrays
|
|
TArray<const TArray<UHoudiniInputObject*>*> GetAllObjectArrays() const;
|
|
TArray<TArray<UHoudiniInputObject*>*> GetAllObjectArrays();
|
|
|
|
// Iterate over all input object arrays
|
|
void ForAllHoudiniInputObjectArrays(TFunctionRef<void(const TArray<UHoudiniInputObject*>&)> Fn) const;
|
|
void ForAllHoudiniInputObjectArrays(TFunctionRef<void(TArray<UHoudiniInputObject*>&)> Fn);
|
|
|
|
void ForAllHoudiniInputObjects(TFunctionRef<void(UHoudiniInputObject*)> Fn) const;
|
|
// Collect top-level HoudiniInputObjects from this UHoudiniInput. Does not traverse nested input objects.
|
|
void GetAllHoudiniInputObjects(TArray<UHoudiniInputObject*>& OutObjects) const;
|
|
// Collect top-level UHoudiniInputSceneComponent from this UHoudiniInput. Does not traverse nested input objects.
|
|
void ForAllHoudiniInputSceneComponents(TFunctionRef<void(class UHoudiniInputSceneComponent*)> Fn) const;
|
|
void GetAllHoudiniInputSceneComponents(TArray<class UHoudiniInputSceneComponent*>& OutObjects) const;
|
|
void GetAllHoudiniInputSplineComponents(TArray<class UHoudiniInputHoudiniSplineComponent*>& OutObjects) const;
|
|
|
|
// Remove all instances of this input object from all object arrays.
|
|
void RemoveHoudiniInputObject(UHoudiniInputObject* InInputObject);
|
|
|
|
bool IsAddRotAndScaleAttributesEnabled() const { return bAddRotAndScaleAttributesOnCurves; };
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
// Mutators
|
|
//------------------------------------------------------------------------------------------------
|
|
|
|
void MarkChanged(const bool& bInChanged)
|
|
{
|
|
bHasChanged = bInChanged;
|
|
SetNeedsToTriggerUpdate(bInChanged);
|
|
};
|
|
void SetNeedsToTriggerUpdate(const bool& bInTriggersUpdate) { bNeedsToTriggerUpdate = bInTriggersUpdate; };
|
|
void MarkDataUploadNeeded(const bool& bInDataUploadNeeded) { bDataUploadNeeded = bInDataUploadNeeded; };
|
|
void MarkAllInputObjectsChanged(const bool& bInChanged);
|
|
|
|
void SetSOPInput(const int32& InInputIndex);
|
|
void SetObjectPathParameter(const int32& InParmId);
|
|
void SetKeepWorldTransform(const bool& bInKeepWorldTransform);
|
|
|
|
void SetName(const FString& InName) { Name = InName; };
|
|
void SetLabel(const FString& InLabel) { Label = InLabel; };
|
|
void SetHelp(const FString& InHelp) { Help = InHelp; };
|
|
void SetAssetNodeId(const int32& InNodeId) { AssetNodeId = InNodeId; };
|
|
void SetInputType(const EHoudiniInputType &InInputType, bool& bOutBlueprintStructureModified);
|
|
void SetPreviousInputType(const EHoudiniInputType& InType) { PreviousType = InType; };
|
|
void SetPackBeforeMerge(const bool& bInPackBeforeMerge) { bPackBeforeMerge = bInPackBeforeMerge; };
|
|
void SetImportAsReference(const bool& bInImportAsReference) { bImportAsReference = bInImportAsReference; };
|
|
void SetExportLODs(const bool& bInExportLODs) { bExportLODs = bInExportLODs; };
|
|
void SetExportSockets(const bool& bInExportSockets) { bExportSockets = bInExportSockets; };
|
|
void SetExportColliders(const bool& bInExportColliders) { bExportColliders = bInExportColliders; };
|
|
void SetInputNodeId(const int32& InCreatedNodeId) { InputNodeId = InCreatedNodeId; };
|
|
void SetUnrealSplineResolution(const float& InResolution) { UnrealSplineResolution = InResolution; };
|
|
|
|
virtual void SetCookOnCurveChange(const bool & bInCookOnCurveChanged) { bCookOnCurveChanged = bInCookOnCurveChanged; };
|
|
|
|
void ResetDefaultCurveOffset() { DefaultCurveOffset = 0.f; }
|
|
|
|
UHoudiniInputObject* CreateNewCurveInputObject(bool& bBlueprintStructureModified);
|
|
|
|
void SetGeometryInputObjectsNumber(const int32& NewCount);
|
|
void SetInputObjectsNumber(const EHoudiniInputType& InType, const int32& InNewCount);
|
|
|
|
void InsertInputObjectAt(const int32& AtIndex);
|
|
void InsertInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex);
|
|
|
|
void DeleteInputObjectAt(const int32& AtIndex);
|
|
void DeleteInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex);
|
|
|
|
void DuplicateInputObjectAt(const int32& AtIndex);
|
|
void DuplicateInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex);
|
|
|
|
void SetInputObjectAt(const int32& AtIndex, UObject* InObject);
|
|
void SetInputObjectAt(const EHoudiniInputType& InType, const int32& AtIndex, UObject* InObject);
|
|
|
|
void SetBoundSelectorObjectsNumber(const int32& InNewCount);
|
|
void SetBoundSelectorObjectAt(const int32& AtIndex, AActor* InActor);
|
|
void SetWorldInputBoundSelector(const bool& InIsBoundSelector) { bIsWorldInputBoundSelector = InIsBoundSelector; };
|
|
void SetWorldInputBoundSelectorAutoUpdates(const bool& InAutoUpdate) { bWorldInputBoundSelectorAutoUpdate = InAutoUpdate; };
|
|
|
|
// Updates the world selection using bound selectors
|
|
// returns false if the selection hasn't changed
|
|
bool UpdateWorldSelectionFromBoundSelectors();
|
|
// Updates the world selection
|
|
// returns false if the selection hasn't changed
|
|
bool UpdateWorldSelection(const TArray<AActor*>& InNewSelection);
|
|
|
|
void OnTransformUIExpand(const int32& AtIndex);
|
|
|
|
// Sets the input's transform offset
|
|
bool SetTransformOffsetAt(const float& Value, const int32& AtIndex, const int32& PosRotScaleIndex, const int32& XYZIndex);
|
|
|
|
// Sets the input's transform scale values
|
|
void SetPositionOffsetX(float InValue, int32 AtIndex);
|
|
void SetPositionOffsetY(float InValue, int32 AtIndex);
|
|
void SetPositionOffsetZ(float InValue, int32 AtIndex);
|
|
|
|
// Sets the input's transform rotation value
|
|
void SetRotationOffsetRoll(float InValue, int32 AtIndex);
|
|
void SetRotationOffsetPitch(float InValue, int32 AtIndex);
|
|
void SetRotationOffsetYaw(float InValue, int32 AtIndex);
|
|
|
|
// Sets the input's transform scale values
|
|
void SetScaleOffsetX(float InValue, int32 AtIndex);
|
|
void SetScaleOffsetY(float InValue, int32 AtIndex);
|
|
void SetScaleOffsetZ(float InValue, int32 AtIndex);
|
|
|
|
void SetAddRotAndScaleAttributes(const bool& InValue);
|
|
|
|
// Duplicate this object and copy its state to the resulting object.
|
|
// This is typically used to transfer state between between template and instance components.
|
|
UHoudiniInput* DuplicateAndCopyState(UObject* DestOuter, bool bInCanDeleteHoudiniNodes);
|
|
virtual void CopyStateFrom(UHoudiniInput* InInput, bool bCopyAllProperties, bool bInCanDeleteHoudiniNodes);
|
|
|
|
void SetCanDeleteHoudiniNodes(bool bInCanDeleteNodes);
|
|
bool CanDeleteHoudiniNodes() { return bCanDeleteHoudiniNodes; }
|
|
|
|
virtual void InvalidateData();
|
|
|
|
protected:
|
|
void CopyInputs(TArray<UHoudiniInputObject*>& ToInputs, TArray<UHoudiniInputObject*>& FromInputs, bool bInCanDeleteHoudiniNodes);
|
|
|
|
public:
|
|
|
|
// Create a Houdini Spline input component, with an existing Houdini Spline input Object.
|
|
// Pass in nullptr to create a default Houdini Spline
|
|
UHoudiniInputHoudiniSplineComponent* CreateHoudiniSplineInput(
|
|
UHoudiniInputHoudiniSplineComponent* FromHoudiniSplineInputObject,
|
|
const bool & bAttachToParent,
|
|
const bool & bAppendToInputArray,
|
|
bool& bOutBlueprintStructureModified);
|
|
|
|
// Given an existing spline input object, remove the associated
|
|
// Houdini Spline component from the owning actor / blueprint.
|
|
void RemoveSplineFromInputObject(
|
|
UHoudiniInputHoudiniSplineComponent* InHoudiniSplineInputObject,
|
|
bool& bOutBlueprintStructureModified) const;
|
|
|
|
bool HasLandscapeExportTypeChanged () const;
|
|
|
|
void SetHasLandscapeExportTypeChanged(const bool InChanged);
|
|
|
|
#if WITH_EDITOR
|
|
FText GetCurrentSelectionText() const;
|
|
#endif
|
|
|
|
EHoudiniLandscapeExportType GetLandscapeExportType() const { return LandscapeExportType; };
|
|
|
|
void SetLandscapeExportType(const EHoudiniLandscapeExportType InType) { LandscapeExportType = InType; };
|
|
|
|
virtual void BeginDestroy() override;
|
|
|
|
#if WITH_EDITOR
|
|
virtual void PostEditUndo() override;
|
|
#endif
|
|
|
|
FBox GetBounds() const;
|
|
|
|
protected:
|
|
|
|
// Name of the input / Object path parameter
|
|
UPROPERTY()
|
|
FString Name;
|
|
|
|
// Label of the SOP input or of the object path parameter
|
|
UPROPERTY()
|
|
FString Label;
|
|
|
|
// Input type
|
|
UPROPERTY()
|
|
EHoudiniInputType Type;
|
|
|
|
// Previous type, used to detect input type changes
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
EHoudiniInputType PreviousType;
|
|
|
|
// NodeId of the asset / object merge we are associated with
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
int32 AssetNodeId;
|
|
|
|
// NodeId of the created input node
|
|
// when there is multiple inputs objects, this will be the merge node.
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
int32 InputNodeId;
|
|
|
|
// SOP input index (-1 if we're an object path input)
|
|
UPROPERTY()
|
|
int32 InputIndex;
|
|
|
|
// Parameter Id of the associated object path parameter (-1 if we're a SOP input)
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
int32 ParmId;
|
|
|
|
// Indicates if we're an object path parameter input
|
|
UPROPERTY()
|
|
bool bIsObjectPathParameter;
|
|
|
|
// Array containing all the node Ids created by this input
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
TArray<int32> CreatedDataNodeIds;
|
|
|
|
// Indicates data connected to this input should be uploaded
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
bool bHasChanged;
|
|
|
|
// Indicates this input should trigger an HDA update/cook
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
bool bNeedsToTriggerUpdate;
|
|
|
|
// Indicates data for this input needs to be uploaded
|
|
// If this is false but the input has changed, we may have just updated in input parameter,
|
|
// and don't need to resend all the input data
|
|
bool bDataUploadNeeded;
|
|
|
|
// Help for this parameter/input
|
|
UPROPERTY()
|
|
FString Help;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// General Input options
|
|
|
|
// Is set to true when this input's Transform Type is set to NONE, 2 will use the input's default value
|
|
UPROPERTY()
|
|
EHoudiniXformType KeepWorldTransform;
|
|
|
|
// Indicates that the geometry must be packed before merging it into the input
|
|
UPROPERTY()
|
|
bool bPackBeforeMerge;
|
|
|
|
// Indicates that all the input objects are imported to Houdini as references instead of actual geo
|
|
// (for Geo/World/Asset input types only)
|
|
UPROPERTY()
|
|
bool bImportAsReference = false;
|
|
|
|
// Indicates that all LODs in the input should be marshalled to Houdini
|
|
UPROPERTY()
|
|
bool bExportLODs;
|
|
|
|
// Indicates that all sockets in the input should be marshalled to Houdini
|
|
UPROPERTY()
|
|
bool bExportSockets;
|
|
|
|
// Indicates that all colliders in the input should be marshalled to Houdini
|
|
UPROPERTY()
|
|
bool bExportColliders;
|
|
|
|
// Indicates that if trigger cook automatically on curve Input spline modified
|
|
UPROPERTY()
|
|
bool bCookOnCurveChanged;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// Geometry objects
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> GeometryInputObjects;
|
|
|
|
// Is set to true when static mesh used for geometry input has changed.
|
|
UPROPERTY()
|
|
bool bStaticMeshChanged;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
// Are the transform UI expanded ?
|
|
// Values default to false and are actually added to the array in OnTransformUIExpand()
|
|
UPROPERTY()
|
|
TArray<bool> TransformUIExpanded;
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// Asset inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> AssetInputObjects;
|
|
|
|
// Is set to true if the asset input is actually connected inside Houdini.
|
|
UPROPERTY()
|
|
bool bInputAssetConnectedInHoudini;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// Curve/Spline inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> CurveInputObjects;
|
|
|
|
// Offset used when using muiltiple curves
|
|
UPROPERTY()
|
|
float DefaultCurveOffset;
|
|
|
|
// Set this to true to add rot and scale attributes on curve inputs.
|
|
UPROPERTY()
|
|
bool bAddRotAndScaleAttributesOnCurves;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// Landscape inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> LandscapeInputObjects;
|
|
|
|
UPROPERTY()
|
|
bool bLandscapeHasExportTypeChanged = false;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// World inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> WorldInputObjects;
|
|
|
|
// Objects used for automatic bound selection
|
|
UPROPERTY()
|
|
TArray<AActor*> WorldInputBoundSelectorObjects;
|
|
|
|
// Indicates that this world input is in "BoundSelector" mode
|
|
UPROPERTY()
|
|
bool bIsWorldInputBoundSelector;
|
|
|
|
// Indicates that selected actors by the bound selectors should update automatically
|
|
UPROPERTY()
|
|
bool bWorldInputBoundSelectorAutoUpdate;
|
|
|
|
// Resolution used when converting unreal splines to houdini curves
|
|
UPROPERTY()
|
|
float UnrealSplineResolution;
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------
|
|
// Skeletal Inputs
|
|
UPROPERTY()
|
|
TArray<UHoudiniInputObject*> SkeletalInputObjects;
|
|
|
|
public:
|
|
|
|
// This array is to record the last insert action, for undo input insertion actions.
|
|
UPROPERTY(Transient, DuplicateTransient)
|
|
TArray<UHoudiniInputHoudiniSplineComponent*> LastInsertedInputs;
|
|
|
|
// This array is to cache the action of last undo delete action, and redo that action.
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
TArray<UHoudiniInputObject*> LastUndoDeletedInputs;
|
|
|
|
|
|
// Indicates that the landscape input's source landscape should be updated instead of creating a new component
|
|
UPROPERTY()
|
|
bool bUpdateInputLandscape;
|
|
|
|
// Indicates if the landscape should be exported as heightfield, mesh or points
|
|
UPROPERTY()
|
|
EHoudiniLandscapeExportType LandscapeExportType = EHoudiniLandscapeExportType::Heightfield;
|
|
|
|
// Is set to true when landscape input is set to selection only.
|
|
UPROPERTY()
|
|
bool bLandscapeExportSelectionOnly = false;
|
|
|
|
// Is set to true when the automatic selection of landscape component is active
|
|
UPROPERTY()
|
|
bool bLandscapeAutoSelectComponent = false;
|
|
|
|
// Is set to true when materials are to be exported.
|
|
UPROPERTY()
|
|
bool bLandscapeExportMaterials = false;
|
|
|
|
// Is set to true when lightmap information export is desired.
|
|
UPROPERTY()
|
|
bool bLandscapeExportLighting = false;
|
|
|
|
// Is set to true when uvs should be exported in [0,1] space.
|
|
UPROPERTY()
|
|
bool bLandscapeExportNormalizedUVs = false;
|
|
|
|
// Is set to true when uvs should be exported for each tile separately.
|
|
UPROPERTY()
|
|
bool bLandscapeExportTileUVs = false;
|
|
|
|
UPROPERTY()
|
|
bool bCanDeleteHoudiniNodes = true;
|
|
}; |