LookAtModifier3D

public int Bone { get; set; }

Index of the LookAtModifier3D.BoneName in the parent Skeleton3D.

public string BoneName { get; set; }

The bone name of the Skeleton3D that the modification will operate on.

public float Duration { get; set; }

The duration of the time-based interpolation. Interpolation is triggered at the following cases:

• When the target node is changed
• When an axis is flipped due to angle limitation Note: The flipping occurs when the target is outside the angle limitation and the internally computed secondary rotation axis of the forward vector is flipped. Visually, it occurs when the target is outside the angle limitation and crosses the plane of the LookAtModifier3D.ForwardAxis and LookAtModifier3D.PrimaryRotationAxis.

public Tween.EaseType EaseType { get; set; }

The ease type of the time-based interpolation. See also Tween.EaseType.

public SkeletonModifier3D.BoneAxis ForwardAxis { get; set; }

The forward axis of the bone. This SkeletonModifier3D modifies the bone so that this axis points toward the target_node.

public int OriginBone { get; set; }

Index of the LookAtModifier3D.OriginBoneName in the parent Skeleton3D.

public string OriginBoneName { get; set; }

If LookAtModifier3D.OriginFrom is LookAtModifier3D.OriginFromEnum.SpecificBone, the bone global pose position specified for this is used as origin.

public EntityPath OriginExternalEntity { get; set; }

If LookAtModifier3D.OriginFrom is LookAtModifier3D.OriginFromEnum.ExternalNode, the global position of the Entity3D specified for this is used as origin.

public LookAtModifier3D.OriginFromEnum OriginFrom { get; set; }

This value determines from what origin is retrieved for use in the calculation of the forward vector.

public Vector3 OriginOffset { get; set; }

The offset of the bone pose origin. Matching the origins by offset is useful for cases where multiple bones must always face the same direction, such as the eyes. Note: This value indicates the local position of the object set in LookAtModifier3D.OriginFrom.

public float OriginSafeMargin { get; set; }

If the target passes through too close to the origin than this value, time-based interpolation is used even if the target is within the angular limitations, to prevent the angular velocity from becoming too high.

public float PrimaryDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.PrimaryLimitAngle. It provides non-linear (b-spline) interpolation, let it feel more resistance the more it rotate to the edge limit. This is useful for simulating the limits of human motion. If 1.0, no damping is performed. If 0.0, damping is always performed.

public float PrimaryLimitAngle { get; set; }

The limit angle of the primary rotation when LookAtModifier3D.SymmetryLimitation is true, in radians.

public float PrimaryNegativeDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.PrimaryNegativeLimitAngle.

public float PrimaryNegativeLimitAngle { get; set; }

The limit angle of negative side of the primary rotation when LookAtModifier3D.SymmetryLimitation is false, in radians.

public float PrimaryPositiveDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.PrimaryPositiveLimitAngle.

public float PrimaryPositiveLimitAngle { get; set; }

The limit angle of positive side of the primary rotation when LookAtModifier3D.SymmetryLimitation is false, in radians.

public Vector3.Axis PrimaryRotationAxis { get; set; }

The axis of the first rotation. This SkeletonModifier3D works by compositing the rotation by Euler angles to prevent to rotate the LookAtModifier3D.ForwardAxis. Note: Since LookAtModifier3D never modifies the twist when LookAtModifier3D.UseSecondaryRotation is false and LookAtModifier3D.Relative is true, the twist is not fixed even if LookAtModifier3D.UseRestForLimitation is true.

public bool Relative { get; set; }

The relative option. If true, the rotation is applied relative to the pose. If false, the rotation is applied relative to the rest. It means to replace the current pose with the LookAtModifier3D's result.

public float SecondaryDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.SecondaryLimitAngle.

public float SecondaryLimitAngle { get; set; }

The limit angle of the secondary rotation when LookAtModifier3D.SymmetryLimitation is true, in radians.

public float SecondaryNegativeDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.SecondaryNegativeLimitAngle.

public float SecondaryNegativeLimitAngle { get; set; }

The limit angle of negative side of the secondary rotation when LookAtModifier3D.SymmetryLimitation is false, in radians.

public float SecondaryPositiveDampThreshold { get; set; }

The threshold to start damping for LookAtModifier3D.SecondaryPositiveLimitAngle.

public float SecondaryPositiveLimitAngle { get; set; }

The limit angle of positive side of the secondary rotation when LookAtModifier3D.SymmetryLimitation is false, in radians.

public bool SymmetryLimitation { get; set; }

If true, the limitations are spread from the bone symmetrically. If false, the limitation can be specified separately for each side of the reference pose. In here, the reference pose is the bone pose immediately before processing this modifier.

public EntityPath TargetEntity { get; set; }

The EntityPath to the node that is the target for the look at modification. This node is what the modification will rotate the bone to.

public Tween.TransitionType TransitionType { get; set; }

The transition type of the time-based interpolation. See also Tween.TransitionType.

public bool UseAngleLimitation { get; set; }

If true, limits the amount of rotation. For example, this helps to prevent a character's neck from rotating 360 degrees. Note: As with AnimationTree blending, interpolation is provided that favors Skeleton3D.GetBoneRest or Skeleton3D.GetBonePose depends on the LookAtModifier3D.Relative option. This means that interpolation does not select the shortest path in some cases. Note: Some values for LookAtModifier3D.TransitionType (such as Tween.TransitionType.Back, Tween.TransitionType.Elastic, and Tween.TransitionType.Spring) may exceed the limitations. If interpolation occurs while overshooting the limitations, the result might not respect the bone rest.

public bool UseRestForLimitation { get; set; }

If true, the angle limitation and the rotation axes are applied based on the Skeleton3D.GetBoneRest. If false, the angle limitation is applied based on the reference pose. In here, the reference pose is the bone pose immediately before processing this modifier. Note: The limitation is applied to the rotation computed by this modifier. If the reference pose is rotated around the same axis, the limitation behaves as if it also limits the rotation of the reference pose. A rotation that this modifier does not change, such as the twist, is not limited.

public bool UseSecondaryRotation { get; set; }

If true, provides rotation by two axes.

public float GetInterpolationRemaining();

Returns the remaining seconds of the time-based interpolation.

public bool IsInterpolating();

Returns true if time-based interpolation is running. If false, it is equivalent to LookAtModifier3D.GetInterpolationRemaining returning 0.0. This is useful to determine whether a LookAtModifier3D can be removed safely.

public bool IsTargetWithinLimitation();

Returns whether the target is within the angle limitations. It is useful for unsetting the target_node when the target is outside of the angle limitations. Note: The value is updated after SkeletonModifier3D._ProcessModification. To retrieve this value correctly, we recommend using the signal SkeletonModifier3D.ModificationProcessed.