// Copyright Epic Games, Inc. All Rights Reserved.


#pragma once

#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/SkeletalMesh.h"
#include "EngineDefines.h"
#include "Components/SkeletalMeshComponent.h"
#include "Delegates/DelegateCombinations.h"
#include "SkeletalMeshSceneProxy.h"
#include "DebugSkelMeshComponent.generated.h"

class Error;

DECLARE_DELEGATE_RetVal(FText, FGetExtendedViewportText);
DECLARE_DELEGATE(FOnDebugForceLODChanged);

USTRUCT()
struct FSelectedSocketInfo
{
	GENERATED_USTRUCT_BODY()

	/** Default constructor */
	FSelectedSocketInfo()
		: Socket(nullptr)
		, bSocketIsOnSkeleton( false )
	{

	}

	/** Constructor */
	FSelectedSocketInfo( class USkeletalMeshSocket* InSocket, bool bInSocketIsOnSkeleton )
		: Socket( InSocket )
		, bSocketIsOnSkeleton( bInSocketIsOnSkeleton )
	{

	}

	bool IsValid() const
	{
		return Socket != nullptr;
	}

	void Reset()
	{
		Socket = nullptr;
	}

	/** The socket we have selected */
	class USkeletalMeshSocket* Socket;

	/** true if on skeleton, false if on mesh */
	bool bSocketIsOnSkeleton;
};

/** Different modes for Persona's Turn Table. */
namespace EPersonaTurnTableMode
{
	enum Type
	{
		Stopped,
		Playing,
		Paused
	};
};

/** Different modes for when processing root motion */
UENUM()
enum class EProcessRootMotionMode : uint8
{
	/** Preview mesh will not consume root motion */
	Ignore,

	/** Preview mesh will consume root motion continually */
	Loop,

	/** Preview mesh will consume root motion resetting the position back to the origin every time the animation loops */
	LoopAndReset
};

/** Different modes for visualizing root motion */
UENUM()
enum class EVisualizeRootMotionMode : uint8
{
	/** Preview will not show root motion */
	None,

	/** Preview will show root motion path */
	Trajectory,

	/** Preview will show root motion path and orientation. */
	TrajectoryAndOrientation
};

//////////////////////////////////////////////////////////////////////////
// FDebugSkelMeshSceneProxy

class UDebugSkelMeshComponent;
class FSkeletalMeshRenderData;

class FDebugSkelMeshDynamicData
{
public:

	FDebugSkelMeshDynamicData(UDebugSkelMeshComponent* InComponent);

	bool bDrawMesh;
	bool bDrawNormals;
	bool bDrawTangents;
	bool bDrawBinormals;
	bool bDrawClothPaintPreview;

	bool bFlipNormal;

	bool bDoubleSidedOpaqueCloth;
	int32 ClothingSimDataIndexWhenPainting;
	TArray<uint32> ClothingSimIndices;

	TArray<float> ClothingVisiblePropertyValues;
	float PropertyViewMin;
	float PropertyViewMax;

	TArray<FVector3f> SkinnedPositions;
	TArray<FVector3f> SkinnedNormals;
};

/**
* A skeletal mesh component scene proxy with additional debugging options.
*/
class FDebugSkelMeshSceneProxy : public FSkeletalMeshSceneProxy
{
public:
	SIZE_T GetTypeHash() const override;

	/**
	* Constructor.
	* @param	Component - skeletal mesh primitive being added
	*/
	FDebugSkelMeshSceneProxy(const UDebugSkelMeshComponent* InComponent, FSkeletalMeshRenderData* InSkelMeshRenderData, FLinearColor InWireframeOverlayColor = FLinearColor::White);

	virtual ~FDebugSkelMeshSceneProxy()
	{}

	virtual void GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, FMeshElementCollector& Collector) const override;

	FDebugSkelMeshDynamicData* DynamicData;

	SIZE_T GetAllocatedSize() const
	{
		return FSkeletalMeshSceneProxy::GetAllocatedSize();
	}

	virtual uint32 GetMemoryFootprint() const override
	{
		return sizeof(*this) + GetAllocatedSize();
	}

private:

	bool bSelectable;
};

/** Generic modes used to render debug skeletons depending on editor-specific context */
UENUM()
enum class ESkeletonDrawMode : uint8
{
	/** Bones are visible and selectable */
	Default,

	/** Bones are completely hidden */
	Hidden,

	/** Bones are visible but non-selectable */
	GreyedOut
};

UCLASS(transient, MinimalAPI)
class UDebugSkelMeshComponent : public USkeletalMeshComponent
{
	GENERATED_UCLASS_BODY()
	
	/** Global drawing mode for this skeleton. Depends on context of specific editor using the component. */
	UPROPERTY()
	ESkeletonDrawMode SkeletonDrawMode = ESkeletonDrawMode::Default;

	/** If true then the skeletal mesh associated with the component is drawn. */
	UPROPERTY()
	uint32 bDrawMesh:1;
	
	/** If true then the bone names associated with the skeletal mesh are displayed */
	UPROPERTY()
	uint32 bShowBoneNames:1;

	/** Bone influences viewing */
	UPROPERTY(transient)
	uint32 bDrawBoneInfluences:1;

	/** Morphtarget viewing */
	UPROPERTY(transient)
	uint32 bDrawMorphTargetVerts : 1;

	/** Vertex normal viewing */
	UPROPERTY(transient)
	uint32 bDrawNormals:1;

	/** Vertex tangent viewing */
	UPROPERTY(transient)
	uint32 bDrawTangents:1;

	/** Vertex binormal viewing */
	UPROPERTY(transient)
	uint32 bDrawBinormals:1;

	/** Socket hit points viewing */
	UPROPERTY(transient)
	uint32 bDrawSockets:1;

	/** Attribute visualization */
	UPROPERTY(transient)
	uint32 bDrawAttributes : 1;

	/** Skeleton sockets visible? */
	UPROPERTY(transient)
	uint32 bSkeletonSocketsVisible:1;

	/** Mesh sockets visible? */
	UPROPERTY(transient)
	uint32 bMeshSocketsVisible:1;

	/** Display raw animation bone transform */
	UPROPERTY(transient)
	uint32 bDisplayRawAnimation:1;

	/** Display non retargeted animation pose */
	UPROPERTY(Transient)
	uint32 bDisplayNonRetargetedPose:1;

	/** Display additive base bone transform */
	UPROPERTY(transient)
	uint32 bDisplayAdditiveBasePose:1;

	/** Display baked animation pose */
	UPROPERTY(Transient)
	uint32 bDisplayBakedAnimation:1;

	/** Display source animation pose */
	UPROPERTY(Transient)
	uint32 bDisplaySourceAnimation:1;

	/** Display Notification visualizations in viewport */
	UPROPERTY(Transient)
	uint32 bShowNotificationVisualizations:1;

	/** Display Metadata visualizations in viewport */
	UPROPERTY(Transient)
	uint32 bShowAssetUserDataVisualizations:1;

	/** Display Bound **/
	UPROPERTY(transient)
	bool bDisplayBound;

	UPROPERTY(transient)
	bool bDisplayVertexColors;

	UPROPERTY(transient)
	FLinearColor WireframeMeshOverlayColor;

	UE_DEPRECATED(5.0, "This variable is no longer used. Use ProcessRootMotionMode instead.")
	UPROPERTY()
	uint32 bPreviewRootMotion_DEPRECATED : 1;

	/** Requested Process root motion mode, ProcessRootMotionMode gets set based on requested mode and what is supported. */
	UPROPERTY(transient)
	EProcessRootMotionMode RequestedProcessRootMotionMode;

	/** Process root motion mode */
	UPROPERTY(transient)
	EProcessRootMotionMode ProcessRootMotionMode;

	UPROPERTY(transient)
	EVisualizeRootMotionMode VisualizeRootMotionMode;

	/** Playback time last time ConsumeRootmotion was called */
	UPROPERTY(transient)
	float ConsumeRootMotionPreviousPlaybackTime;
	
	UPROPERTY(transient)
	TEnumAsByte<EAdditiveAnimationType> ConsumeRootMotionPreviousAdditiveAnimType = AAT_MAX;

	UPROPERTY(transient)
	uint32 bShowClothData : 1;

	UPROPERTY(transient)
	float MinClothPropertyView;

	UPROPERTY(transient)
	float MaxClothPropertyView;

	UPROPERTY(transient)
	float ClothMeshOpacity;

	UPROPERTY(transient)
	bool bClothFlipNormal;

	UPROPERTY(transient)
	bool bClothCullBackface;

	UPROPERTY(transient)
	uint32 bRequiredBonesUpToDateDuringTick : 1;

	/* Bounds computed from cloth. */
	FBoxSphereBounds CachedClothBounds;

	/** Non Compressed SpaceBases for when bDisplayRawAnimation == true **/
	TArray<FTransform> UncompressedSpaceBases;

	/** Storage of Additive Base Pose for when bDisplayAdditiveBasePose == true, as they have to be calculated */
	TArray<FTransform> AdditiveBasePoses;

	/** Storage for non retargeted pose. */
	TArray<FTransform> NonRetargetedSpaceBases;

	/** Storage of Baked Animation Pose for when bDisplayBakedAnimation == true, as they have to be calculated */
	TArray<FTransform> BakedAnimationPoses;

	/** Storage of Source Animation Pose for when bDisplaySourceAnimation == true, as they have to be calculated */
	TArray<FTransform> SourceAnimationPoses;

	/** Transform representing the actor transform at the beginning of the animation sequence. */
	FTransform RootMotionReferenceTransform;

	/** Array of bones to render bone weights for */
	UPROPERTY(transient)
	TArray<int32> BonesOfInterest;

	/** Array of morphtargets to render verts for */
	UPROPERTY(transient)
	TArray<TObjectPtr<class UMorphTarget>> MorphTargetOfInterests;

	/** Array of materials to restore when not rendering blend weights */
	UPROPERTY(transient)
	TArray<TObjectPtr<class UMaterialInterface>> SkelMaterials;
	
	UPROPERTY(transient, NonTransactional)
	TObjectPtr<class UAnimPreviewInstance> PreviewInstance;

	UPROPERTY(transient)
	TObjectPtr<class UAnimInstance> SavedAnimScriptInstance;

	/** Does this component use in game bounds or does it use bounds calculated from bones */
	UPROPERTY(transient)
	bool bIsUsingInGameBounds;
	
	/** Does this component use pre-skinned bounds? This overrides other bounds settings */
	UPROPERTY(transient)
	bool bIsUsingPreSkinnedBounds;

	/** Base skel mesh has support for suspending clothing, but single ticks are more of a debug feature when stepping through an animation
	 *  So we control that using this flag
	 */
	UPROPERTY(transient)
	bool bPerformSingleClothingTick;

	UPROPERTY(transient)
	bool bPauseClothingSimulationWithAnim;

	/** Should the LOD of the debug mesh component track the LOD of the instance being debugged */
	UPROPERTY(transient)
	bool bTrackAttachedInstanceLOD;
	
	/** Palettized semi randomized colors for multi-color bone display */
	UNREALED_API FLinearColor GetBoneColor(int32 BoneIndex) const;

	// Helper method that sets the forced lod
	UNREALED_API void SetDebugForcedLOD(int32 InNewForcedLOD);

	//~ Begin USceneComponent Interface.
	UNREALED_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
	//~ End USceneComponent Interface.

	//~ Begin UPrimitiveComponent Interface.
	UNREALED_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
	
	// engine only draw bounds IF selected
	// @todo fix this properly
	// this isn't really the best way to do this, but for now
	// we'll just mark as selected
	UNREALED_API virtual bool ShouldRenderSelected() const override;
	//~ End UPrimitiveComponent Interface.

	//~ Begin SkinnedMeshComponent Interface
	UNREALED_API virtual bool ShouldCPUSkin() const override;
	UNREALED_API virtual bool ShouldNaniteSkin() override;
	UNREALED_API virtual void PostInitMeshObject(class FSkeletalMeshObject* MeshObject) override;
	UNREALED_API virtual void RefreshBoneTransforms(FActorComponentTickFunction* TickFunction = NULL) override;
	virtual int32 GetLODBias() const override { return 0; }
	//~ End SkinnedMeshComponent Interface

	//~ Begin SkeletalMeshComponent Interface
	UNREALED_API virtual void InitAnim(bool bForceReinit) override;
	virtual bool IsWindEnabled() const override { return true; }
	UNREALED_API virtual void OnClearAnimScriptInstance() override;
	UNREALED_API virtual void SetSkeletalMesh(USkeletalMesh* InSkelMesh, bool bReinitPose = true) override;
	//~ End SkeletalMeshComponent Interface

	//~ Begin UObject interface
	UNREALED_API virtual void PostInitProperties() override;
	//~ End UObject interface

	// return true if currently preview animation asset is on
	UNREALED_API virtual bool IsPreviewOn() const;

	// @todo document
	UNREALED_API FString GetPreviewText() const;

	// @todo anim : you still need to give asset, so that we know which one to disable
	// we can disable per asset, so that if some other window disabled before me, I don't accidently turn it off
	UNREALED_API virtual void EnablePreview(bool bEnable, class UAnimationAsset * PreviewAsset);

	// Create the preview instance to use (default UAnimPreviewInstance)
	UNREALED_API virtual TObjectPtr<UAnimPreviewInstance> CreatePreviewInstance();

	// reference pose for this component
	// we don't want to use default refpose because you still want to move joint when this mode is on
	UNREALED_API virtual void ShowReferencePose(bool bRefPose);
	UNREALED_API virtual bool IsReferencePoseShown() const;

	/** Called when mirror data table changes on anim instance. */
	UNREALED_API void OnMirrorDataTableChanged();

	/**
	 * Update material information depending on color render mode 
	 * Refresh/replace materials 
	 */
	UNREALED_API void SetShowBoneWeight(bool bNewShowBoneWeight);

	/**
	* Update material information depending on color render mode
	* Refresh/replace materials
	*/
	UNREALED_API void SetShowMorphTargetVerts(bool bNewShowMorphTargetVerts);

	/**
	 * Does it use in-game bounds or bounds calculated from bones
	 */
	UNREALED_API bool IsUsingInGameBounds() const;

	/**
	 * Set to use in-game bounds or bounds calculated from bones
	 */
	UNREALED_API void UseInGameBounds(bool bUseInGameBounds);

	/**
	 * Does it use pre-skinned bounds
	 */
	UNREALED_API bool IsUsingPreSkinnedBounds() const;

	/**
	 * Set to use pre-skinned bounds
	 */
	UNREALED_API void UsePreSkinnedBounds(bool bUsePreSkinnedBounds);

	/**
	 * Test if in-game bounds are as big as preview bounds
	 */
	UNREALED_API bool CheckIfBoundsAreCorrrect();

	/** Get the in-game bounds of the skeleton mesh */
	UNREALED_API FBoxSphereBounds CalcGameBounds(const FTransform& LocalToWorld) const;

	/** 
	 * Update components position based on animation root motion
	 */
	UNREALED_API void ConsumeRootMotion(const FVector& FloorMin, const FVector& FloorMax);

	/** Sets the flag used to determine whether or not the current active cloth sim mesh should be rendered */
	UNREALED_API void SetShowClothProperty(bool bState);

	/** Get whether we should be previewing root motion */
	UE_DEPRECATED(5.0, "Please use IsProcessingRootMotion or GetProcessRootMotionMode")
	bool GetPreviewRootMotion() const { return IsProcessingRootMotion(); }

	/** Set whether we should be previewing root motion. Note: disabling root motion preview resets transform. */
	UE_DEPRECATED(5.0, "Please use SetProcessRootMotionMode")
	void SetPreviewRootMotion(bool bInPreviewRootMotion) { SetProcessRootMotionMode(bInPreviewRootMotion ? EProcessRootMotionMode::Loop : EProcessRootMotionMode::Ignore); }

	/** Whether we are processing root motion or not */
	UNREALED_API bool IsProcessingRootMotion() const;

	/** Gets requested process root motion mode, can differ from GetProcessRootMotionMode() if the current asset does not support root motion. */
	UNREALED_API EProcessRootMotionMode GetRequestedProcessRootMotionMode() const;

	/** Gets process root motion mode */
	UNREALED_API EProcessRootMotionMode GetProcessRootMotionMode() const;

	/** Sets process root motion mode, the request may be ignored if current asset does not support the mode. Note: disabling root motion preview resets transform. */
	UNREALED_API void SetProcessRootMotionMode(EProcessRootMotionMode Mode);

	/** Sets how we visualize root motion in the viewport. See EVisualizeRootMotionMode for details. */
	UNREALED_API void SetVisualizeRootMotionMode(EVisualizeRootMotionMode Mode) { VisualizeRootMotionMode = Mode; };
	UNREALED_API bool IsVisualizeRootMotionMode(EVisualizeRootMotionMode Mode) const { return VisualizeRootMotionMode == Mode; };
	UNREALED_API EVisualizeRootMotionMode GetVisualizeRootMotionMode() const { return VisualizeRootMotionMode; };

	/** Whether the supplied root motion mode can be used for the current asset */
	UNREALED_API bool CanUseProcessRootMotionMode(EProcessRootMotionMode Mode) const;

	/** Whether the current asset or animation blueprint is using root motion */
	UNREALED_API bool DoesCurrentAssetHaveRootMotion() const;

	/** Sets flags whether we notification visualizations should be drawn in the viewport. */
	UNREALED_API void SetShowNotificationVisualizations(const bool bShow) { bShowNotificationVisualizations = bShow; }
	UNREALED_API bool IsNotificationVisualizationsEnabled() const { return bShowNotificationVisualizations; }

	UE_DEPRECATED(5.5, "Use VisualizeRootMotionMode functions instead.")
	UNREALED_API void SetShowRootMotionVisualizations(const bool bShow) { VisualizeRootMotionMode = bShow ? EVisualizeRootMotionMode::Trajectory : EVisualizeRootMotionMode::None; }
	UNREALED_API bool IsRootMotionVisualizationsEnabled() const { return VisualizeRootMotionMode != EVisualizeRootMotionMode::None; }

	/** Sets flags whether we AssetUserData visualizations should be drawn in the viewport. */
	UNREALED_API void SetShowAssetUserDataVisualizations(const bool bShow) { bShowAssetUserDataVisualizations = bShow; }
	UNREALED_API bool IsAssetUserDataVisualizationsEnabled() const { return bShowAssetUserDataVisualizations; }

	/** Whether the current LOD of the debug mesh is being synced with the attached (preview) mesh instance. */
	UNREALED_API bool IsTrackingAttachedLOD() const;

	/** Set the wireframe mesh overlay color, which basically controls the color of the wireframe. */
	void SetWireframeMeshOverlayColor(FLinearColor Color) { WireframeMeshOverlayColor = Color; }

	/** Get the wireframe mesh overlay color, which basically controls the color of the wireframe. */
	FLinearColor GetWireframeMeshOverlayColor() const { return WireframeMeshOverlayColor; }


#if WITH_EDITOR
	//TODO - This is a really poor way to post errors to the user. Work out a better way.
	struct FAnimNotifyErrors
	{
		FAnimNotifyErrors(UObject* InSourceNotify)
		: SourceNotify(InSourceNotify)
		{}
		UObject* SourceNotify;
		TArray<FString> Errors;
	};
	TArray<FAnimNotifyErrors> AnimNotifyErrors;
	UNREALED_API virtual void ReportAnimNotifyError(const FText& Error, UObject* InSourceNotify) override;
	UNREALED_API virtual void ClearAnimNotifyErrors(UObject* InSourceNotify) override;

	/** 
	 * Extended viewport text delegate handling. Registering a delegate allows external
	 * objects to place custom text in the anim tools viewports.
	 */
	UNREALED_API FDelegateHandle RegisterExtendedViewportTextDelegate(const FGetExtendedViewportText& InDelegate);
	UNREALED_API void UnregisterExtendedViewportTextDelegate(const FDelegateHandle& InDelegateHandle);
	const TArray<FGetExtendedViewportText>& GetExtendedViewportTextDelegates() const { return ExtendedViewportTextDelegates; }

	UNREALED_API FDelegateHandle RegisterOnDebugForceLODChangedDelegate(const FOnDebugForceLODChanged& InDelegate);
	UNREALED_API void UnregisterOnDebugForceLODChangedDelegate();

private:
	TArray<FGetExtendedViewportText> ExtendedViewportTextDelegates;
	FOnDebugForceLODChanged OnDebugForceLODChangedDelegate;
public:

#endif

	/**
	 * Force all body instance to not simulate physics regardless of their physic type
	 * To get back in a default state call : ResetAllBodiesSimulatePhysics
	 */
	void DisableAllBodiesSimulatePhysics()
	{
		for (int32 BodyIdx = 0; BodyIdx < Bodies.Num(); ++BodyIdx)
		{
			if (FBodyInstance* BodyInst = Bodies[BodyIdx])
			{
				BodyInst->SetInstanceSimulatePhysics(false);
			}
		}
	}

	/** 
	 * toggle visibility between cloth sections and non-cloth sections for all LODs
	 * if bShowOnlyClothSections is true, shows only cloth sections. On the other hand, 
	 * if bShowOnlyClothSections is false, hides only cloth sections.
	 */
	UNREALED_API void ToggleClothSectionsVisibility(bool bShowOnlyClothSections);
	/** Restore all section visibilities to original states for all LODs */
	UNREALED_API void RestoreClothSectionsVisibility();

	/** 
	 * To normal game/runtime code we don't want to expose a non-const pointer to the simulation, so we can only get
	 * one from this editor-only component. Intended for debug options/visualisations/editor-only code to poke the sim
	 */
	UNREALED_API IClothingSimulation* GetMutableClothingSimulation();

	/** to avoid clothing reset while modifying properties in Persona */
	UNREALED_API virtual void CheckClothTeleport() override;

	/** The currently selected asset guid if we're painting, used to build dynamic mesh to paint sim parameters */
	FGuid SelectedClothingGuidForPainting;

	/** The currently selected LOD for painting */
	int32 SelectedClothingLodForPainting;

	/** The currently selected mask inside the above LOD to be painted */
	int32 SelectedClothingLodMaskForPainting;

	/** Find a section using a clothing asset with the given GUID and set its visiblity */
	UNREALED_API void SetMeshSectionVisibilityForCloth(FGuid InClothGuid, bool bVisibility);

	// fixes up the disabled flags so clothing is enabled and originals are disabled as
	// ToggleMeshSectionForCloth will make these get out of sync
	UNREALED_API void ResetMeshSectionVisibility();

	// Rebuilds the fixed parameter on the mesh to mesh data, to be used if the editor has
	// changed a vert to be fixed or unfixed otherwise the simulation will not work
	// bInvalidateDerivedDataCache can only be false during previewing as otherwise the changes won't be correctly saved
	UE_DEPRECATED(5.0, "This function is redundant, since it is always called after ApplyParameterMasks and therefore will be removed.")
	UNREALED_API void RebuildClothingSectionsFixedVerts(bool bInvalidateDerivedDataCache = true);

	TArray<FVector3f> SkinnedSelectedClothingPositions;
	TArray<FVector3f> SkinnedSelectedClothingNormals;

private:
	// Rebuilds the fixed vertex attribute on any cloth deformer mappings,
	// including LOD bias mappings, that reference the specified LOD section.
	UE_DEPRECATED(5.0, "This function is redundant, since it is always called after ApplyParameterMasks and therefore will be removed.")
	UNREALED_API void RebuildClothingSectionFixedVerts(int32 LODIndex, int32 SectionIndex);

	// Helper function to generate space bases for current frame
	UNREALED_API void GenSpaceBases(TArray<FTransform>& OutSpaceBases);

	// Helper function to enable overlay material
	UNREALED_API void EnableOverlayMaterial(bool bEnable);

	// Rebuilds the cloth bounds for the asset.
	UNREALED_API void RebuildCachedClothBounds();

	UNREALED_API void SetProcessRootMotionModeInternal(EProcessRootMotionMode Mode);

	void ResetRootTransform();
protected:

	// Overridden to support single clothing ticks
	UNREALED_API virtual bool ShouldRunClothTick() const override;

	UNREALED_API virtual void SendRenderDynamicData_Concurrent() override;

public:

	/** Set TurnTableMode and reset the turntable rotation if needed. */
	UNREALED_API void SetTurnTableMode(EPersonaTurnTableMode::Type NewMode);
	
	/** Current turn table mode */
	EPersonaTurnTableMode::Type TurnTableMode;
	/** Current turn table speed scaling */
	float TurnTableSpeedScaling;

	UNREALED_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;

	UNREALED_API void RefreshSelectedClothingSkinnedPositions();

	virtual bool CanOverrideCollisionProfile() const { return true; }

	UNREALED_API virtual void GetUsedMaterials(TArray<UMaterialInterface *>& OutMaterials, bool bGetDebugMaterials = false) const override;

	/**
	 * Define Custom Default pose for this component for preview
	 */
	virtual void SetCustomDefaultPose() {};

	/*
	 *	return RefSkeleton for drawing; 
	 */
	virtual const FReferenceSkeleton& GetReferenceSkeleton() const
	{
		if (GetSkeletalMeshAsset())
		{
			return GetSkeletalMeshAsset()->GetRefSkeleton();
		}

		static FReferenceSkeleton EmptySkeleton;
		return EmptySkeleton;
	}

	/*
	*	return bone indices to draw
	*/
	virtual const TArray<FBoneIndexType>& GetDrawBoneIndices() const
	{
		return RequiredBones;
	}

	virtual int32 GetNumDrawTransform() const 
	{
		return GetNumComponentSpaceTransforms();
	}
	/*
	 *	returns the transform of the joint 
	 */
	virtual FTransform GetDrawTransform(int32 BoneIndex) const
	{
		const TArray<FTransform>& SpaceTransforms = GetComponentSpaceTransforms();
		if (SpaceTransforms.IsValidIndex(BoneIndex))
		{
			return SpaceTransforms[BoneIndex];
		}

		return FTransform::Identity;
	}
};


/*
 * This class is use to remove the alternate skinning preview from the multiple editor that can show it.
 * Important it should be destroy after the PostEditChange of the skeletalmesh is done and the renderdata have been recreate
 * i.e. FScopedSkeletalMeshPostEditChange should be create after FScopedSuspendAlternateSkinWeightPreview and delete before FScopedSuspendAlternateSkinWeightPreview
 */
class FScopedSuspendAlternateSkinWeightPreview
{
public:
	/*
	 * This constructor suspend the alternate skinning preview for all editor component that use the specified skeletalmesh
	 * Parameters:
	 * @param InSkeletalMesh - SkeletalMesh use to know which preview component we have to suspend the alternate skinning preview.
	 */
	UNREALED_API FScopedSuspendAlternateSkinWeightPreview(class USkeletalMesh* InSkeletalMesh);

	/*
	 * This destructor put back the preview alternate skinning
	 */
	UNREALED_API ~FScopedSuspendAlternateSkinWeightPreview();

private:
	TArray< TTuple<UDebugSkelMeshComponent*, FName> > SuspendedComponentArray;
};