1
0
KF2-Dev-Scripts/Engine/Classes/InterpTrackMove.uc
2020-12-13 18:01:13 +03:00

360 lines
14 KiB
Ucode

class InterpTrackMove extends InterpTrack
native(Interpolation);
/**
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
*
* Track containing data for moving an actor around over time.
* There is no UpdateTrack function. In the game, its the PHYS_Interpolating physics mode which
* updates the position based on the interp track.
*/
cpptext
{
// UObject interface
virtual void PostLoad();
virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent);
virtual void PostEditImport();
// InterpTrack interface
virtual INT GetNumKeyframes() const;
virtual void GetTimeRange(FLOAT& StartTime, FLOAT& EndTime) const;
virtual FLOAT GetTrackEndTime() const;
virtual FLOAT GetKeyframeTime(INT KeyIndex) const;
virtual INT AddKeyframe(FLOAT Time, UInterpTrackInst* TrInst, EInterpCurveMode InitInterpMode);
/**
* Adds a keyframe to a child track
*
* @param ChildTrack The child track where the keyframe should be added
* @param Time What time the keyframe is located at
* @param TrackInst The track instance of the parent track(this track)
* @param InitInterpMode The initial interp mode for the keyframe?
*/
virtual INT AddChildKeyframe(class UInterpTrack* ChildTrack, FLOAT Time, UInterpTrackInst* TrackInst, EInterpCurveMode InitInterpMode);
virtual void UpdateKeyframe(INT KeyIndex, UInterpTrackInst* TrInst);
/**
* Updates a child track keyframe
*
* @param ChildTrack The child track with keyframe to update
* @param KeyIndex The index of the key to be updated
* @param TrackInst The track instance of the parent track(this track)
*/
virtual void UpdateChildKeyframe( class UInterpTrack* ChildTrack, INT KeyIndex, UInterpTrackInst* TrackInst );
virtual INT SetKeyframeTime(INT KeyIndex, FLOAT NewKeyTime, UBOOL bUpdateOrder=true);
virtual void RemoveKeyframe(INT KeyIndex);
virtual INT DuplicateKeyframe(INT KeyIndex, FLOAT NewKeyTime);
virtual UBOOL GetClosestSnapPosition(FLOAT InPosition, TArray<INT> &IgnoreKeys, FLOAT& OutPosition);
virtual void ConditionalPreviewUpdateTrack(FLOAT NewPosition, class UInterpTrackInst* TrInst);
virtual void PreviewUpdateTrack(FLOAT NewPosition, UInterpTrackInst* TrInst);
virtual class UMaterial* GetTrackIcon() const;
virtual FColor GetKeyframeColor(INT KeyIndex) const;
virtual void DrawTrack( FCanvas* Canvas, UInterpGroup* Group, const FInterpTrackDrawParams& Params );
virtual void Render3DTrack(UInterpTrackInst* TrInst, const FSceneView* View, FPrimitiveDrawInterface* PDI, INT TrackIndex, const FColor& TrackColor, TArray<class FInterpEdSelKey>& SelectedKeys);
virtual void SetTrackToSensibleDefault();
// FCurveEdInterface interface
virtual INT GetNumKeys();
virtual INT GetNumSubCurves() const;
/**
* Provides the color for the sub-curve button that is present on the curve tab.
*
* @param SubCurveIndex The index of the sub-curve. Cannot be negative nor greater or equal to the number of sub-curves.
* @param bIsSubCurveHidden Is the curve hidden?
* @return The color associated to the given sub-curve index.
*/
virtual FColor GetSubCurveButtonColor(INT SubCurveIndex, UBOOL bIsSubCurveHidden) const;
virtual FLOAT GetKeyIn(INT KeyIndex);
virtual FLOAT GetKeyOut(INT SubIndex, INT KeyIndex);
virtual void GetInRange(FLOAT& MinIn, FLOAT& MaxIn);
virtual void GetOutRange(FLOAT& MinOut, FLOAT& MaxOut);
/**
* Provides the color for the given key at the given sub-curve.
*
* @param SubIndex The index of the sub-curve
* @param KeyIndex The index of the key in the sub-curve
* @param[in] CurveColor The color of the curve
* @return The color that is associated the given key at the given sub-curve
*/
virtual FColor GetKeyColor(INT SubIndex, INT KeyIndex, const FColor& CurveColor);
virtual BYTE GetKeyInterpMode(INT KeyIndex);
virtual void GetTangents(INT SubIndex, INT KeyIndex, FLOAT& ArriveTangent, FLOAT& LeaveTangent);
virtual FLOAT EvalSub(INT SubIndex, FLOAT InVal);
virtual INT CreateNewKey(FLOAT KeyIn);
virtual void DeleteKey(INT KeyIndex);
virtual INT SetKeyIn(INT KeyIndex, FLOAT NewInVal);
virtual void SetKeyOut(INT SubIndex, INT KeyIndex, FLOAT NewOutVal);
virtual void SetKeyInterpMode(INT KeyIndex, EInterpCurveMode NewMode);
virtual void SetTangents(INT SubIndex, INT KeyIndex, FLOAT ArriveTangent, FLOAT LeaveTangent);
/** Returns TRUE if this curve uses legacy tangent/interp algorithms and may be 'upgraded' */
virtual UBOOL UsingLegacyInterpMethod() const;
/** 'Upgrades' this curve to use the latest tangent/interp algorithms (usually, will 'bake' key tangents.) */
virtual void UpgradeInterpMethod();
// InterpTrackMove interface
virtual FName GetLookupKeyGroupName(INT KeyIndex);
virtual void SetLookupKeyGroupName(INT KeyIndex, const FName &NewGroupName);
virtual void ClearLookupKeyGroupName(INT KeyIndex);
/**
* Replacement for the PosTrack eval function that uses GetKeyframePosition. This is so we can replace keyframes that get their information from other tracks.
*
* @param TrInst TrackInst to use for looking up groups.
* @param Time Time to evaluate position at.
* @return Final position at the specified time.
*/
FVector EvalPositionAtTime(UInterpTrackInst* TrInst, FLOAT Time);
/**
* Replacement for the EulerTrack eval function that uses GetKeyframeRotation. This is so we can replace keyframes that get their information from other tracks.
*
* @param TrInst TrackInst to use for looking up groups.
* @param Time Time to evaluate rotation at.
* @return Final rotation at the specified time.
*/
FVector EvalRotationAtTime(UInterpTrackInst* TrInst, FLOAT Time);
/**
* Gets the position of a keyframe given its key index. Also optionally retrieves the Arrive and Leave tangents for the key.
* This function respects the LookupTrack.
*
* @param TrInst TrackInst to use for lookup track positions.
* @param KeyIndex Index of the keyframe to get the position of.
* @param OutTime Final time of the keyframe.
* @param OutPos Final position of the keyframe.
* @param OutArriveTangent Pointer to a vector to store the arrive tangent in, can be NULL.
* @param OutLeaveTangent Pointer to a vector to store the leave tangent in, can be NULL.
*/
void GetKeyframePosition(UInterpTrackInst* TrInst, INT KeyIndex, FLOAT& OutTime, FVector &OutPos, FVector *OutArriveTangent, FVector *OutLeaveTangent);
/**
* Gets the rotation of a keyframe given its key index. Also optionally retrieves the Arrive and Leave tangents for the key.
* This function respects the LookupTrack.
*
* @param TrInst TrackInst to use for lookup track rotations.
* @param KeyIndex Index of the keyframe to get the rotation of.
* @param OutTime Final time of the keyframe.
* @param OutRot Final rotation of the keyframe.
* @param OutArriveTangent Pointer to a vector to store the arrive tangent in, can be NULL.
* @param OutLeaveTangent Pointer to a vector to store the leave tangent in, can be NULL.
*/
void GetKeyframeRotation(UInterpTrackInst* TrInst, INT KeyIndex, FLOAT& OutTime, FVector &OutRot, FVector *OutArriveTangent, FVector *OutLeaveTangent);
/**
* Computes the world space coordinates for a key; handles keys that use IMF_RelativeToInitial, basing, etc.
*
* @param MoveTrackInst An instance of this movement track
* @param RelativeSpacePos Key position value from curve
* @param RelativeSpaceRot Key rotation value from curve
* @param OutPos Output world space position
* @param OutRot Output world space rotation
*/
void ComputeWorldSpaceKeyTransform( UInterpTrackInstMove* MoveTrackInst,
const FVector& RelativeSpacePos,
const FRotator& RelativeSpaceRot,
FVector& OutPos,
FRotator& OutRot );
virtual void GetKeyTransformAtTime(UInterpTrackInst* TrInst, FLOAT Time, FVector& OutPos, FRotator& OutRot);
virtual UBOOL GetLocationAtTime(UInterpTrackInst* TrInst, FLOAT Time, FVector& OutPos, FRotator& OutRot);
virtual FMatrix GetMoveRefFrame(UInterpTrackInstMove* MoveTrackInst);
/**
* Find Best Matching Time From Position
* This function simply try to find Time from input Position using simple Lerp
*
* @param : Pos - input position
* @param : StartKeyIndex - optional
*
* @return : Interp Time
*/
FLOAT FindBestMatchingTimefromPosition(UInterpTrackInst* TrInst, const FVector& Pos, INT StartKeyIndex=0, EAxis WeightAxis = AXIS_XY);
INT CalcSubIndex(UBOOL bPos, INT InIndex) const;
/**
* Creates and adds subtracks to this track
*
* @param bCopy If subtracks are being added as a result of a copy
*/
virtual void CreateSubTracks( UBOOL bCopy );
/**
* Splits this movment track in to seperate tracks for translation and rotation
*/
void SplitTranslationAndRotation();
/**
* Reduce Keys within Tolerance
*
* @param bIntervalStart start of the key to reduce
* @param bIntervalEnd end of the key to reduce
* @param Tolerance tolerance
*/
virtual void ReduceKeys( FLOAT IntervalStart, FLOAT IntervalEnd, FLOAT Tolerance );
}
/** Actual position keyframe data. */
var InterpCurveVector PosTrack;
/** Actual rotation keyframe data, stored as Euler angles in degrees, for easy editing on curve. */
var InterpCurveVector EulerTrack;
/**
* Array of group names to retrieve position and rotation data from instead of using the datastored in the keyframe.
* A value of NAME_None means to use the PosTrack and EulerTrack data for the keyframe.
* There needs to be the same amount of elements in this array as there are keyframes.
*/
struct native InterpLookupPoint
{
var name GroupName;
var float Time;
};
struct native InterpLookupTrack
{
structcpptext
{
/** Add a new keypoint to the LookupTrack. Returns the index of the new key.*/
INT AddPoint( const FLOAT InTime, FName &InGroupName )
{
INT PointIdx=0;
for( PointIdx=0; PointIdx<Points.Num() && Points(PointIdx).Time < InTime; PointIdx++);
Points.Insert(PointIdx);
Points(PointIdx).Time = InTime;
Points(PointIdx).GroupName = InGroupName;
return PointIdx;
}
/** Move a keypoint to a new In value. This may change the index of the keypoint, so the new key index is returned. */
INT MovePoint( INT PointIndex, FLOAT NewTime )
{
if( PointIndex < 0 || PointIndex >= Points.Num() )
{
return PointIndex;
}
FName GroupName = Points(PointIndex).GroupName;
Points.Remove(PointIndex);
const INT NewPointIndex = AddPoint( NewTime, GroupName );
return NewPointIndex;
}
}
var array<InterpLookupPoint> Points;
};
var InterpLookupTrack LookupTrack;
/** When using IMR_LookAtGroup, specifies the Group which this track should always point its actor at. */
var() name LookAtGroupName;
/** Controls the tightness of the curve for the translation path. */
var() float LinCurveTension;
/** Controls the tightness of the curve for the rotation path. */
var() float AngCurveTension;
/**
* Use a Quaternion linear interpolation between keys.
* This is robust and will find the 'shortest' distance between keys, but does not support ease in/out.
*/
var() bool bUseQuatInterpolation;
/** In the editor, show a small arrow at each keyframe indicating the rotation at that key. */
var() bool bShowArrowAtKeys;
/** Disable previewing of this track - will always position Actor at Time=0.0. Useful when keyframing an object relative to this group. */
var() bool bDisableMovement;
/** If false, when this track is displayed on the Curve Editor in Matinee, do not show the Translation tracks. */
var() bool bShowTranslationOnCurveEd;
/** If false, when this track is displayed on the Curve Editor in Matinee, do not show the Rotation tracks. */
var() bool bShowRotationOnCurveEd;
/** If true, 3D representation of this track in the 3D viewport is disabled. */
var() bool bHide3DTrack;
/** Use just the raw Location/Rotation of the base actor instead of calculating the initial offset (makes IMF_RelativeToInitial behave more like you would expect). */
var() bool bUseRawActorTMforRelativeToInitial;
enum EInterpTrackMoveFrame
{
/** Track should be fixed relative to the world. */
IMF_World,
/** Track should move relative to the initial position of the actor when the interp sequence was started. */
IMF_RelativeToInitial
};
/** Indicates what the movement track should be relative to. */
var() editconst EInterpTrackMoveFrame MoveFrame;
enum EInterpTrackMoveRotMode
{
/** Should take orientation from the . */
IMR_Keyframed,
/** Point the X-Axis of the controlled Actor at the group specified by LookAtGroupName. */
IMR_LookAtGroup,
/** Should look along the direction of the translation path, with Z always up. */
// IMR_LookAlongPath // TODO!
/** Do not change rotation. Ignore it. */
IMR_Ignore
};
var() EInterpTrackMoveRotMode RotMode;
defaultproperties
{
TrackInstClass=class'Engine.InterpTrackInstMove'
bOnePerGroup=true
TrackTitle="Movement"
LinCurveTension=0.0
AngCurveTension=0.0
MoveFrame=IMF_World
RotMode=IMR_Keyframed
bShowTranslationOnCurveEd=true
bShowRotationOnCurveEd=false
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="X", GroupIndex=0) )
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="Y", GroupIndex=0) )
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="Z", GroupIndex=0) )
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="X", GroupIndex=1 ) )
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="Y", GroupIndex=1 ) )
SupportedSubTracks.Add( (SupportedClass=class'Engine.InterpTrackMoveAxis', SubTrackName="Z", GroupIndex=1 ) )
`if(`isdefined(CHAIR_INTERNAL))
// The default behavior for UDK is false, but we always want this true for ChAIR games
bUseRawActorTMforRelativeToInitial=true
`endif
}