
/**
 * Contains the shared data that is used by all SkeletalMeshComponents (instances).
 * Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
 */

class SkeletalMesh extends Object
	native(SkeletalMesh)
	noexport
	dependson(ApexClothingAsset)
	hidecategories(Object);

var()	const native			BoxSphereBounds			Bounds;

/** List of materials applied to this mesh. */
var()	const native			array<MaterialInterface>	Materials;
/** List of clothing assets associated with each material int this mesh. */
var()	editfixedsize			array<ApexClothingAsset>    ClothingAssets;

struct native ApexClothingLodInfo
{
	/** The mesh section that the clothing submesh will override. */
	var()	editfixedsize	array<int>	ClothingSectionInfo;
};

struct native ApexClothingAssetInfo
{
	/** Graphical Lod Info for the clothing asset */
	var()	editfixedsize	array<ApexClothingLodInfo> ClothingLodInfo;
	/** Clothing Asset Name */
	var		Name	ClothingAssetName;
};

/** List of Clothing LOD and the mapping of clothing to skeletal mesh section */
var()	editfixedsize			array<ApexClothingAssetInfo>	ClothingLodMap;
/** Origin in original coordinate system */
var()	const native			vector					Origin;
/** Amount to rotate when importing (mostly for yawing) */
var()	const native			rotator					RotOrigin;

var		const native			array<int>				RefSkeleton;	// FMeshBone
var		const native			int						SkeletalDepth;
var		const native			map{FName,INT}			NameIndexMap;

var		const native private	IndirectArray_Mirror	LODModels;		// FStaticLODModel
var		const native private	pointer					SourceData;		// FSkeletalMeshSourceData
var		const native			array<AnimNode.BoneAtom>			RefBasesInvMatrix;

struct native BoneMirrorInfo
{
	/** The bone to mirror. */
	var()	int		SourceIndex <ArrayClamp=RefSkeleton>;
	/** Axis the bone is mirrored across. */
	var()	EAxis	BoneFlipAxis;
};

/** Structure to export/import bone mirroring information */
struct native BoneMirrorExport
{
	var()	Name	BoneName;
	var()	Name	SourceBoneName;
	var()	EAxis	BoneFlipAxis;
};

/** List of bones that should be mirrored. */
var()	editfixedsize	array<BoneMirrorInfo>	SkelMirrorTable;
var()	EAxis									SkelMirrorAxis;
var()	EAxis									SkelMirrorFlipAxis;

var		array<SkeletalMeshSocket>		Sockets;

/** Array of bone names that break for use in game/editor */
var()	editconst const native array<string>		BoneBreakNames;

enum BoneBreakOption
{
	BONEBREAK_SoftPreferred, 
	BONEBREAK_AutoDetect,
	BONEBREAK_RigidPreferred
};

/** Array of options that break bones for use in game/editor */
/** Match with BoneBreakNames array **/
var()	const native array<BoneBreakOption>		BoneBreakOptions;

enum TriangleSortOption
{
	TRISORT_None,						//0
	TRISORT_CenterRadialDistance,		//1
	TRISORT_Random,						//2
	TRISORT_MergeContiguous,			//3
	TRISORT_Custom,						//4
	TRISORT_CustomLeftRight,			//5
};

/** Enum indicating which method to use to generate per-vertex cloth vert movement scale (ClothMovementScale) */
enum ClothMovementScaleGen
{
	ECMDM_DistToFixedVert,
	ECMDM_VertexBoneWeight,
	ECMDM_Empty,
};

/** Enum to specify which axis to use for the forward vector when using TRISORT_CustomLeftRight sort mode */
enum TriangleSortAxis
{
	TSA_X_Axis,
	TSA_Y_Axis,
	TSA_Z_Axis,
};

/** Struct containing triangle sort settings for a particular section */
struct TriangleSortSettings
{
	var() TriangleSortOption TriangleSorting;
	var() TriangleSortAxis CustomLeftRightAxis;
	var() name CustomLeftRightBoneName;
};

/** Struct containing information for a particular LOD level, such as materials and info for when to use it. */
struct native SkeletalMeshLODInfo
{
	/**	Indicates when to use this LOD. A smaller number means use this LOD when further away. */
	var()	float						DisplayFactor;
	/**	Used to avoid 'flickering' when on LOD boundary. Only taken into account when moving from complex->simple. */
	var()	float						LODHysteresis;
	/** Mapping table from this LOD's materials to the SkeletalMesh materials array. */
	var()	editfixedsize array<INT>	LODMaterialMap;
	/** Per-section control over whether to enable shadow casting. */
	var()	editfixedsize array<bool>	bEnableShadowCasting;
	/** Per-section sorting options */
	var		deprecated array<TriangleSortOption>	TriangleSorting;
	var()	editfixedsize array<TriangleSortSettings> TriangleSortSettings;
	/** Use compressed position XYZs(4 bytes saving 8 bytes). This is only useful for GPU skinning.*/
	var()	bool						bDisableCompressions;
	/** Whether to disable morph targets for this LOD. */
	var		bool						bHasBeenSimplified;
};

/** Struct containing information for each LOD level, such as materials to use, whether to cast shadows, and when use the LOD. */
var()	editfixedsize array<SkeletalMeshLODInfo>	LODInfo;

/** Enum specifying the importance of properties when simplifying skeletal meshes. */
enum SkeletalMeshOptimizationImportance
{
	SMOI_Off,
	SMOI_Lowest,
	SMOI_Low,
	SMOI_Normal,
	SMOI_High,
	SMOI_Highest
};

/** Enum specifying the reduction type to use when simplifying skeletal meshes. */
enum SkeletalMeshOptimizationType
{
	SMOT_NumOfTriangles,
	SMOT_MaxDeviation,
	SMOT_MAX,
};

/** Enum specifying how to generate normals when simplifying skeletal meshes. */
enum SkeletalMeshOptimizationNormalMode
{
	SMONM_Recalculate,
	SMONM_RecalculateSoft,
	SMONM_RecalculateHard
};

/**
 * FSkeletalMeshOptimizationSettings - The settings used to optimize a skeletal mesh LOD.
 */
struct native SkeletalMeshOptimizationSettings
{

	/**If ReductionMethod equals SMOT_MaxDeviation this value is the maximum deviation from the base mesh as a percentage of the bounding sphere. */
	var float MaxDeviationPercentage;
	/** How important the shape of the geometry is. */
	var SkeletalMeshOptimizationImportance SilhouetteImportance;
	/** How important texture density is. */
	var SkeletalMeshOptimizationImportance TextureImportance;
	/** How important shading quality is. */
	var SkeletalMeshOptimizationImportance ShadingImportance;
	/** How important skinning quality is. */
	var SkeletalMeshOptimizationImportance SkinningImportance;
	/** How to compute normals for the optimized mesh. */
	var deprecated SkeletalMeshOptimizationNormalMode NormalMode;
	/** The ratio of bones that will be removed from the mesh */
	var float BoneReductionRatio;
	/** Maximum number of bones that can be assigned to each vertex. */
	var int MaxBonesPerVertex;
	/** The method to use when optimizing the skeletal mesh LOD */
	var SkeletalMeshOptimizationType ReductionMethod;
	/** If ReductionMethod equals SMOT_NumOfTriangles this value is the ratio of triangles [0-1] to remove from the mesh */
	var float NumOfTrianglesPercentage;
	/** The welding threshold distance. Vertices under this distance will be welded. */
	var float WeldingThreshold; 
	/** Whether Normal smoothing groups should be preserved. If false then NormalsThreshold is used **/
	var bool bRecalcNormals;
	/** If the angle between two triangles are above this value, the normals will not be
	smooth over the edge between those two triangles. Set in degrees. This is only used when PreserveNormals is set to false*/
	var float NormalsThreshold;
};

/** Optimization settings used to simplify LODs of this mesh. */
var		array<SkeletalMeshOptimizationSettings> OptimizationSettings;

/** For each bone specified here, all triangles rigidly weighted to that bone are entered into a kDOP, allowing per-poly collision checks. */
var()	array<name>	PerPolyCollisionBones;

/** For each of these bones, find the parent that is in PerPolyCollisionBones and add its polys to that bone. */
var()	array<name>	AddToParentPerPolyCollisionBone;

/**
 *	KDOP tree's used for storing rigid triangle information for a subset of bones.
 *	Length of this array matches PerPolyCollisionBones
 */
var		private const native array<int> PerPolyBoneKDOPs;

/** If true, include triangles that are soft weighted to bones. */
var()	bool		bPerPolyUseSoftWeighting;

/** If true, use PhysicsAsset for line collision checks. If false, use per-poly bone collision (if present). */
var()	bool		bUseSimpleLineCollision;

/** If true, use PhysicsAsset for extent (swept box) collision checks. If false, use per-poly bone collision (if present). */
var()	bool		bUseSimpleBoxCollision;

/** All meshes default to GPU skinning. Set to True to enable CPU skinning. If CPU skinning is enabled, bUsePackedPosition can't be enabled */
var()	const bool	bForceCPUSkinning;

/** If true, use 32 bit UVs. If false, use 16 bit UVs to save memory */
var()	const bool	bUseFullPrecisionUVs;

/** TRUE if this mesh has ever been simplified with Simplygon. */
var		bool		bHasBeenSimplified;

/** The FaceFX asset the skeletal mesh uses for FaceFX operations. */
var() FaceFXAsset FaceFXAsset;

/** Asset used for previewing bounds in AnimSetViewer. Makes setting up LOD distance factors more reliable. */
var()	editoronly PhysicsAsset		BoundsPreviewAsset;

/** Asset used for previewing morph target animations in AnimSetViewer. Only for editor. */
var()	editoronly array<MorphTargetSet>	PreviewMorphSets;

/** LOD bias to use for PC. */
var() int LODBiasPC;
/** LOD bias to use for PS3. */
var() int LODBiasPS3;
/** LOD bias to use for Xbox 360. */
var() int LODBiasXbox360;
//@zombie_ps4_begin
/** LOD bias to use for Orbis. */
var() int LODBiasOrbis;
//@zombie_ps4_end

/** Path to the resource used to construct this skeletal mesh */
var() const editconst editoronly string	SourceFilePath;

/** Date/Time-stamp of the file from the last import */
var() const editconst editoronly string	SourceFileTimestamp;

/** Cache of ClothMesh objects at different scales. */
var	const native transient array<pointer>	ClothMesh;

/** Scale of each of the ClothMesh objects in cache. This array is same size as ClothMesh. */
var const native transient array<float>		ClothMeshScale;

/** 
 *	Mapping between each vertex in the simulation mesh and the graphics mesh. 
 *	This is ordered so that 'free' vertices are first, and then after NumFreeClothVerts they are 'fixed' to the skinned mesh.
 */
var const array<int>		ClothToGraphicsVertMap;

/** Scaling (per vertex) for how far cloth vert can move from its animated position  */
var const array<float>		ClothMovementScale;

/** Method to use to generate the ClothMovementScale table */
var(Cloth)	ClothMovementScaleGen	ClothMovementScaleGenMode;

/** How far a simulated vertex can move from its animated location */
var(Cloth)	float					ClothToAnimMeshMaxDist;

/** If TRUE, simulated verts are limited to a certain distance from */
var(Cloth)	bool					bLimitClothToAnimMesh;

/**
 * Mapping from index of rendered mesh to index of simulated mesh.
 * This mapping applies before ClothToGraphicsVertMap which can then operate normally
 * The reason for this mapping is to weld several vertices with the same position but different texture coordinates into one
 * simulated vertex which makes it possible to run closed meshes for cloth.
 */
var const array<int>		ClothWeldingMap;

/**
 * This is the highest value stored in ClothWeldingMap
 */
var const int				ClothWeldingDomain;

/**
 * This will hold the indices to the reduced number of cloth vertices used for cooking the NxClothMesh.
 */
var const array<int>		ClothWeldedIndices;

/**
 * Forces the Welding Code to be turned off even if the mesh has doubled vertices
 */
var(ClothAdvanced)	const bool		bForceNoWelding;

/** Point in the simulation cloth vertex array where the free verts finish and we start having 'fixed' verts. */
var const int				NumFreeClothVerts;

/** Index buffer for simulation cloth. */
var const array<int>		ClothIndexBuffer;

/** Vertices with any weight to these bones are considered 'cloth'. */
var(Cloth)	const array<name>		ClothBones;

/** If greater than 1, will generate smaller meshes internally, used to improve simulation time and reduce stretching. */
var(Cloth)	const int				ClothHierarchyLevels;

/** Enable constraints that attempt to minimize curvature or folding of the cloth. */
var(Cloth)	const bool				bEnableClothBendConstraints;

/** Enable damping forces on the cloth. */
var(Cloth)	const bool				bEnableClothDamping;

/** Enable center of mass damping of cloth internal velocities.  */
var(Cloth)	const bool				bUseClothCOMDamping;

/** Controls strength of springs that attempts to keep particles in the cloth together. */
var(Cloth)	const float				ClothStretchStiffness <UIMin=0.0 | UIMax=1.0 | ClampMin=0.0 | ClampMax=1.0>;

/** 
 *	Controls strength of springs that stop the cloth from bending. 
 *	bEnableClothBendConstraints must be true to take affect. 
 */
var(Cloth)	const float				ClothBendStiffness <UIMin=0.0 | UIMax=1.0 | ClampMin=0.0 | ClampMax=1.0>;

/** 
 *	This is multiplied by the size of triangles sharing a point to calculate the points mass.
 *	This cannot be modified after the cloth has been created.
 */
var(Cloth)	const float				ClothDensity;

/** How thick the cloth is considered when doing collision detection. */
var(Cloth)	const float				ClothThickness;

/** 
 *	Controls how much damping force is applied to cloth particles.
 *	bEnableClothDamping must be true to take affect.
 */
var(Cloth)	const float				ClothDamping  <UIMin=0.0 | UIMax=1.0 | ClampMin=0.0 | ClampMax=1.0>;

/** Increasing the number of solver iterations improves how accurately the cloth is simulated, but will also slow down simulation. */
var(Cloth)	const int				ClothIterations;

/** If ClothHierarchyLevels is more than 0, this number controls the number of iterations of the hierarchical solver. */
var(Cloth)	const int				ClothHierarchicalIterations;

/** Controls movement of cloth when in contact with other bodies. */
var(Cloth)	const float				ClothFriction <UIMin=0.0 | UIMax=1.0 | ClampMin=0.0 | ClampMax=1.0>;

/** 
 * Controls the size of the grid cells a cloth is divided into when performing broadphase collision. 
 * The cell size is relative to the AABB of the cloth.
 */
var(ClothAdvanced)	const float				ClothRelativeGridSpacing;

/** Adjusts the internal "air" pressure of the cloth. Only has affect when bEnableClothPressure. */
var(ClothAdvanced)	const float				ClothPressure;

/** Response coefficient for cloth/rb collision */
var(ClothAdvanced)	const float				ClothCollisionResponseCoefficient;

/** How much an attachment to a rigid body influences the cloth */
var(ClothAdvanced)	const float				ClothAttachmentResponseCoefficient;

/** How much extension an attachment can undergo before it tears/breaks */
var(ClothAdvanced)	const float				ClothAttachmentTearFactor;

/**
 * Maximum linear velocity at which cloth can go to sleep.
 * If negative, the global default will be used.
 */
var(ClothAdvanced)	const float				ClothSleepLinearVelocity;

/** If bHardStretchLimit is TRUE, how much stretch is allowed in the cloth. 1.0 is no stretch (but will cause jitter) */
var(Cloth)	const float				HardStretchLimitFactor;

/** 
 *	If TRUE, limit the total amount of stretch that is allowed in the cloth, based on HardStretchLimitFactor. 
 *	Note that bLimitClothToAnimMesh must be TRUE for this to work.
 */
var(Cloth)	const bool				bHardStretchLimit;


/** Enable orthogonal bending resistance to minimize curvature or folding of the cloth. 
 *  This technique uses angular springs instead of distance springs as used in
 *  'bEnableClothBendConstraints'. This mode is slower but independent of stretching resistance.
 */
var(ClothAdvanced)	const bool				bEnableClothOrthoBendConstraints;

/** Enables cloth self collision. */
var(ClothAdvanced)	const bool				bEnableClothSelfCollision;

/** Enables pressure support. Simulates inflated objects like balloons. */
var(ClothAdvanced)	const bool				bEnableClothPressure;

/** Enables two way collision with rigid-bodies. */
var(ClothAdvanced)	const bool				bEnableClothTwoWayCollision;

/** Cloth bone type, used when attaching to the physics asset. */
enum ClothBoneType
{
	CLOTHBONE_Fixed,						//0
	CLOTHBONE_BreakableAttachment,			//1
	CLOTHBONE_TearLine						//2
};

/** Used to specify a set of special cloth bones which are attached to the physics asset */
struct native ClothSpecialBoneInfo
{
	/** The bone name to attach to a cloth vertex */
	var() name BoneName;
	
	/** The type of attachment */
	var() ClothBoneType BoneType;
	
	/** Array used to cache cloth indices which will be attached to this bone, created in BuildClothMapping(),
	 * Note: These are welded indices.
	 */
	var const array<int> AttachedVertexIndices;
};

/** 
 * Vertices with any weight to these bones are considered cloth with special behavoir, currently
 * they are attached to the physics asset with fixed or breakable attachments or tearlines.
 */
var(ClothAdvanced)	const array<ClothSpecialBoneInfo>		ClothSpecialBones; 

/** 
 * Enable cloth line/extent/point checks. 
 * Note: line checks are performed with a raycast against the cloth, but point and swept extent checks are performed against the cloth AABB 
 */
var(Cloth)	const bool				bEnableClothLineChecks;

/**
 *  Whether cloth simulation should be wrapped inside a Rigid Body and only be used upon impact
 */
var(ClothAdvanced)  const bool				bClothMetal;

/** Threshold for when deformation is allowed */
var(ClothAdvanced)	const float				ClothMetalImpulseThreshold;
/** Amount by which colliding objects are brought closer to the cloth */
var(ClothAdvanced)	const float				ClothMetalPenetrationDepth;
/** Maximum deviation of cloth particles from initial position */
var(ClothAdvanced)	const float				ClothMetalMaxDeformationDistance;

/** 
 *  Used to enable cloth tearing. Note, extra vertices/indices must be reserved using ClothTearReserve 
 *  Also cloth tearing is not available when welding is enabled.
 */
var(Cloth)	const bool				bEnableClothTearing;

/** Stretch factor beyond which a cloth edge/vertex will tear. Should be greater than 1. */
var(Cloth)	const float				ClothTearFactor;

/** Number of vertices/indices to set aside to accomodate new triangles created as a result of tearing */
var(Cloth)	const int				ClothTearReserve;

/** Any cloth vertex that exceeds its valid bounds will be deleted if bEnableValidBounds is set. Tune ValidBoundMin and ValidBoundMax if valid bound is enabled.*/
var(Cloth)	bool			bEnableValidBounds;

/** The minimum coordinates triplet of the cloth valid bound */
var(Cloth)	Vector			ValidBoundsMin;

/** The maximum coordinates triplet of the cloth valid bound */
var(Cloth)	Vector			ValidBoundsMax;

`if(`isdefined(WITH_PHYSX))
struct native Sphere
{
	var() Vector Center;
	var() float Radius;
};

/** Only for PhysX 3.x. Need to explicitly add spheres or capsules to the cloth collision system. An array of spheres colliding with this cloth*/
var(ClothCollisionData) array< Sphere > ClothCollisionSpheres; 

/** Only for PhysX 3.x. Capsule indices (into the ClothCollisionSpheres array). E.g: A pair of (0, 1) will create 1 capsule from sphere 0 and sphere 1 in the ClothCollisionSpheres. Another pair of (1, 2) will create another capsule from sphere 1 and sphere 2. 
Can contain spheres with different radii to create tapered capsules.*/
var(ClothCollisionData) array<int>		ClothCollisionCapsuleIndices;  //LOC_MOD revisit unsigned int
`endif 

/** Map which maps from a set of 3 triangle indices packet in a 64bit to the location in the index buffer,
 *  Used to update indices for torn triangles.
 *  Note: This structure is lazy initialized when a torn cloth mesh is created. (But could be precomputed
 *  in BuildClothMapping() if serialization is handled correctly).
 */
var			const native Map_Mirror ClothTornTriMap {TMap<QWORD,INT>};

struct native SoftBodyTetraLink
{
	var int Index;
	var vector Bary;
};

/** Mapping between each vertex of the simulated soft-body's surface-mesh and the graphics mesh. */ 
var const array<int>											SoftBodySurfaceToGraphicsVertMap;

/** Index buffer of the triangles of the soft-body's surface mesh. Indices refer to entries in SoftBodySurfaceToGraphicsVertMap. */
var const array<int>											SoftBodySurfaceIndices;

/** Base array of tetrahedron vertex positions. Used to generate the scaled versions from. */
var const array<vector>											SoftBodyTetraVertsUnscaled;

/** Index buffer of the tetrahedra of the soft-body's tetra-mesh. Indices refer to the vertices in SoftBodyTetraVertsUnscaled.*/
var const array<int>											SoftBodyTetraIndices;

/** Mapping between each vertex of the surface-mesh and its tetrahedron, with local positions given in barycentric coordinates. */
var const array<SoftBodyTetraLink>								SoftBodyTetraLinks;

/** Cache of pointers to NxSoftBodyMesh objects at different scales. */
var	const native transient array<pointer>						CachedSoftBodyMeshes;

/** Scale of each of the NxSoftBodyMesh objects in cache. This array is same size as CachedSoftBodyMeshes. */
var const native transient array<float>							CachedSoftBodyMeshScales;

/** Vertices with any weight to these bones are considered 'soft-body'. */
var(SoftBody)	const array<name>								SoftBodyBones;

/** Cloth bone type, used when attaching to the physics asset. */
enum SoftBodyBoneType
{
	SOFTBODYBONE_Fixed,						//0
	SOFTBODYBONE_BreakableAttachment,		//1
	SOFTBODYBONE_TwoWayAttachment,			//2
};

/** Used to specify a set of special softbody bones which are attached to the physics asset */
struct native SoftBodySpecialBoneInfo
{
	/** The bone name to attach to a cloth vertex */
	var() name BoneName;
	
	/** The type of attachment */
	var() SoftBodyBoneType BoneType;
	
	/** Array used to cache softbody indices which will be attached to this bone, created in BuildSoftBodyMapping(),
	 * Note: These are welded indices.
	 */
	var const array<int> AttachedVertexIndices;
};

/** 
 * Vertices with any weight to these bones are considered softbody with special behavoir, currently
 * they are attached to the physics asset with fixed or breakable attachments.
 */
var(SoftBody)	const array<SoftBodySpecialBoneInfo>		SoftBodySpecialBones; 

/** Defines how strongly the soft-body resists motion that changes the rest volume. Range (0,1]. */
var(SoftBody)	const float				SoftBodyVolumeStiffness;

/** Defines how strongly the soft-body resists stretching motions. Range (0,1]. */
var(SoftBody)	const float				SoftBodyStretchingStiffness;

/** Density of the soft-body (mass per volume). */
var(SoftBody)	const float				SoftBodyDensity;

/** Size of the soft-body particles used for collision detection. */
var(SoftBody)	const float				SoftBodyParticleRadius;

/** 
 *	Controls how much damping force is applied to soft-body particles.
 *	bEnableSoftBodyDamping must be true to take affect.
 */
var(SoftBody)	const float				SoftBodyDamping;

/** Increasing the number of solver iterations improves how accurately the soft-body is simulated, but will also slow down simulation. */
var(SoftBody)	const int				SoftBodySolverIterations;

/** Controls movement of soft-body when in contact with other bodies. */
var(SoftBody)	const float				SoftBodyFriction;

/** 
 * Controls the size of the grid cells a soft-body is divided into when performing broadphase collision. 
 * The cell size is relative to the AABB of the soft-body.
 */
var(SoftBody)	const float				SoftBodyRelativeGridSpacing;

/**
 * Maximum linear velocity at which a soft-body can go to sleep.
 * If negative, the global default will be used.
 */
var(SoftBody)	const float				SoftBodySleepLinearVelocity;

/** Enables soft-body self collision. */
var(SoftBody)	const bool				bEnableSoftBodySelfCollision;

/** 
 * Defines a factor for the impulse transfer from the soft body to attached rigid bodies. 
 * bEnableSoftBodyTwoWayCollision must be true to take effect.
 */
var(SoftBody)	const float				SoftBodyAttachmentResponse;

/** 
 * Defines a factor for the impulse transfer from the soft body to colliding rigid bodies. 
 * bEnableSoftBodyTwoWayCollision must be true to take effect.
 */
var(SoftBody)	const float				SoftBodyCollisionResponse;

/** 
 * Controls how much the original graphics mesh is simplified before it is used
 * to seed to tetrahedron-mesh generator.
 */
var(SoftBody)	const float				SoftBodyDetailLevel<ClampMin=0.0 | ClampMax=1.0>;

/** Controls how many tetrahedra are generated to approximate the surface-mesh. */
var(SoftBody)	const int				SoftBodySubdivisionLevel<ClampMin=1.0>;

/** If enabled, an iso-surface is generated around the original graphics-mesh before
 * the tetrahedron-mesh is created.
 */
var(SoftBody)	const bool				bSoftBodyIsoSurface;

/** Enable damping forces on the softbody. */
var(SoftBody)	const bool				bEnableSoftBodyDamping;

/** Enable center of mass damping of SoftBody internal velocities.  */
var(SoftBody)	const bool				bUseSoftBodyCOMDamping;

/** Specifies the maximum distance a tetra-vertex is allowed to have from the 
 *  surface-mesh to still end up attached to a bone. 
 */
var(SoftBody)	const float				SoftBodyAttachmentThreshold;

/** Enables two way collision with rigid-bodies. */
var(SoftBody)	const bool				bEnableSoftBodyTwoWayCollision;

/** How much extension an attachment can undergo before it tears/breaks */
var(SoftBody)	const float				SoftBodyAttachmentTearFactor;

/** Enable soft body line checks. */
var(SoftBody)	const bool				bEnableSoftBodyLineChecks;

/** Whether or not the mesh has vertex colors */
var bool bHasVertexColors;

/** Saves if Graphics Vertex is simulated cloth or not */
var const native array<bool>			GraphicsIndexIsCloth;

/** The cached streaming texture factors.  If the array doesn't have MAX_TEXCOORDS entries in it, the cache is outdated. */
var const native array<float>			CachedStreamingTextureFactors;

/**
 * Allows artists to adjust the distance where textures using UV 0 are streamed in/out.
 * 1.0 is the default, whereas a higher value increases the streamed-in resolution.
 */
var() const float						StreamingDistanceMultiplier;

var const native transient int			ReleaseResourcesFence;

/** Runtime UID for this SkeletalMeshm, used when linking meshes to AnimSets. */
var const transient qword				SkelMeshRUID;

/** When enabled the material in the APEX clothing asset will override the skeletal mesh material. */
var(ApexClothing) const bool			bUseClothingAssetMaterial;

defaultproperties
{
	SkelMirrorAxis=AXIS_X
	SkelMirrorFlipAxis=AXIS_Z
	// Cloth params
	ClothThickness = 0.5
	ClothDensity = 1.0
	ClothBendStiffness = 1.0
	ClothStretchStiffness = 1.0
    ClothDamping = 0.5
	ClothFriction = 0.5
    ClothIterations = 2
	ClothHierarchicalIterations = 2

	HardStretchLimitFactor = 1.1

	ClothMovementScaleGenMode=ECMDM_DistToFixedVert

	bUseSimpleLineCollision=true
	bUseSimpleBoxCollision=true
	
	bEnableClothOrthoBendConstraints = FALSE
	bEnableClothSelfCollision = FALSE
	bEnableClothPressure = FALSE
	bEnableClothTwoWayCollision = FALSE
	bForceNoWelding = FALSE
	
	ClothRelativeGridSpacing = 1.0
	ClothPressure = 1.0
	ClothCollisionResponseCoefficient = 0.2
	ClothAttachmentResponseCoefficient = 0.2
	ClothAttachmentTearFactor = 1.5
	ClothSleepLinearVelocity =-1.0

	ClothMetalImpulseThreshold=10.0
	ClothMetalPenetrationDepth=0.0
	ClothMetalMaxDeformationDistance=0.0

	bEnableClothTearing = FALSE
	ClothTearFactor = 3.5
	ClothTearReserve = 128
	
	bEnableValidBounds=FALSE
	ValidBoundsMin=(X=0,Y=0,Z=0)
	ValidBoundsMax=(X=0,Y=0,Z=0)
	
	SoftBodyVolumeStiffness = 1.0;
	SoftBodyStretchingStiffness = 1.0;
	SoftBodyDensity = 1.0;
	SoftBodyParticleRadius = 0.1;
	SoftBodyDamping = 0.5;
	SoftBodySolverIterations = 5;
	SoftBodyFriction = 0.5
	SoftBodyRelativeGridSpacing = 1.0
	SoftBodySleepLinearVelocity = -1.0
	bEnableSoftBodySelfCollision = FALSE
	SoftBodyAttachmentResponse = 0.2;
	SoftBodyCollisionResponse = 0.2;
	
	SoftBodyDetailLevel = 0.5f;
	SoftBodySubdivisionLevel = 4
	bSoftBodyIsoSurface = TRUE
	
	SoftBodyAttachmentThreshold = 0.5;
	bEnableSoftBodyTwoWayCollision = TRUE;

	SoftBodyAttachmentTearFactor = 1.5;

	StreamingDistanceMultiplier = 1.0;
}
