// Needs to be called once waypoints and decoder are assigned, to setup or refresh path data.
internal void FinalizePath(bool isClosedPath, AxisConstraint lockPositionAxes, Vector3 currTargetVal)
{
// Rebuild path to lock eventual axes
if (lockPositionAxes != AxisConstraint.None) {
bool lockX = ((lockPositionAxes & AxisConstraint.X) == AxisConstraint.X);
bool lockY = ((lockPositionAxes & AxisConstraint.Y) == AxisConstraint.Y);
bool lockZ = ((lockPositionAxes & AxisConstraint.Z) == AxisConstraint.Z);
for (int i = 0; i < wps.Length; ++i) {
Vector3 pt = wps[i];
wps[i] = new Vector3(
lockX ? currTargetVal.x : pt.x,
lockY ? currTargetVal.y : pt.y,
lockZ ? currTargetVal.z : pt.z
);
}
}
_decoder.FinalizePath(this, wps, isClosedPath);
isFinalized = true;
}
/// <summary>
/// ProjectHandlebarGivenConstraint internal function to account for axis constraint
/// </summary>
/// <param name="constraint">Enum value describing the axis to which the rotation is constrained/param>
/// <param name="handlebarRotation">A Vector3 describing the rotation of the line connecting the inputSources</param>
/// <param name="manipulationRoot">Transform of gameObject to be two hand manipulated</param>
/// <returns>a Vector3 describing handlebar after constraint is applied</returns>
private Vector3 ProjectHandlebarGivenConstraint(AxisConstraint constraint, Vector3 handlebarRotation, Transform manipulationRoot)
{
Vector3 result = handlebarRotation;
switch (constraint)
{
case AxisConstraint.XAxisOnly:
result.x = 0;
break;
case AxisConstraint.YAxisOnly:
result.y = 0;
break;
case AxisConstraint.ZAxisOnly:
result.z = 0;
break;
}
return(CameraCache.Main.transform.TransformDirection(result));
}
// Token: 0x060001FB RID: 507 RVA: 0x0000B844 File Offset: 0x00009A44
public override void SetChangeValue(TweenerCore <Vector3, Vector3, VectorOptions> t)
{
AxisConstraint axisConstraint = t.plugOptions.axisConstraint;
if (axisConstraint == AxisConstraint.X)
{
t.changeValue = new Vector3(t.endValue.x - t.startValue.x, 0f, 0f);
return;
}
if (axisConstraint == AxisConstraint.Y)
{
t.changeValue = new Vector3(0f, t.endValue.y - t.startValue.y, 0f);
return;
}
if (axisConstraint != AxisConstraint.Z)
{
t.changeValue = t.endValue - t.startValue;
return;
}
t.changeValue = new Vector3(0f, 0f, t.endValue.z - t.startValue.z);
}
// Needs to be called once waypoints and decoder are assigned, to setup or refresh path data.
internal void FinalizePath(bool isClosedPath, AxisConstraint lockPositionAxes, Vector3 currTargetVal)
{
// Rebuild path to lock eventual axes
if (lockPositionAxes != AxisConstraint.None)
{
bool lockX = ((lockPositionAxes & AxisConstraint.X) == AxisConstraint.X);
bool lockY = ((lockPositionAxes & AxisConstraint.Y) == AxisConstraint.Y);
bool lockZ = ((lockPositionAxes & AxisConstraint.Z) == AxisConstraint.Z);
for (int i = 0; i < wps.Length; ++i)
{
Vector3 pt = wps[i];
wps[i] = new Vector3(
lockX ? currTargetVal.x : pt.x,
lockY ? currTargetVal.y : pt.y,
lockZ ? currTargetVal.z : pt.z
);
}
}
_decoder.FinalizePath(this, wps, isClosedPath);
}
public override void SetFrom(TweenerCore <Vector3, Vector3, VectorOptions> t, bool isRelative)
{
Vector3 endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
Vector3 pNewValue = t.endValue;
AxisConstraint axisConstraint = t.plugOptions.axisConstraint;
switch (axisConstraint)
{
case AxisConstraint.X:
pNewValue.x = t.startValue.x;
goto IL_A0;
case (AxisConstraint)3:
break;
case AxisConstraint.Y:
pNewValue.y = t.startValue.y;
goto IL_A0;
default:
if (axisConstraint == AxisConstraint.Z)
{
pNewValue.z = t.startValue.z;
goto IL_A0;
}
break;
}
pNewValue = t.startValue;
IL_A0:
if (t.plugOptions.snapping)
{
pNewValue.x = (float)Math.Round((double)pNewValue.x);
pNewValue.y = (float)Math.Round((double)pNewValue.y);
pNewValue.z = (float)Math.Round((double)pNewValue.z);
}
t.setter(pNewValue);
}
// Token: 0x060001F8 RID: 504 RVA: 0x0000B724 File Offset: 0x00009924
public override void SetFrom(TweenerCore <Vector3, Vector3, VectorOptions> t, bool isRelative)
{
Vector3 endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
Vector3 vector = t.endValue;
AxisConstraint axisConstraint = t.plugOptions.axisConstraint;
if (axisConstraint != AxisConstraint.X)
{
if (axisConstraint != AxisConstraint.Y)
{
if (axisConstraint != AxisConstraint.Z)
{
vector = t.startValue;
}
else
{
vector.z = t.startValue.z;
}
}
else
{
vector.y = t.startValue.y;
}
}
else
{
vector.x = t.startValue.x;
}
if (t.plugOptions.snapping)
{
vector.x = (float)Math.Round((double)vector.x);
vector.y = (float)Math.Round((double)vector.y);
vector.z = (float)Math.Round((double)vector.z);
}
t.setter(vector);
}
protected override void JsonTo(IJsonNode json)
{
if (json.Contains("beginRotate"))
{
BeginRotate = JTweenUtils.JsonToVector3(json.GetNode("beginRotate"));
}
// end if
if (json.Contains("towards"))
{
m_towards = JTweenUtils.JsonToVector3(json.GetNode("towards"));
}
// end if
if (json.Contains("axis"))
{
m_axisConstraint = (AxisConstraint)(int)json.GetInt("axis");
}
// end if
if (json.Contains("up"))
{
m_up = JTweenUtils.JsonToVector3(json.GetNode("up"));
}
// end if
Restore();
}
protected override void JsonTo(JsonData json)
{
if (json.Contains("beginRotate"))
{
BeginRotate = JTweenUtils.JsonToVector3(json["beginRotate"]);
}
// end if
if (json.Contains("towards"))
{
m_towards = JTweenUtils.JsonToVector3(json["towards"]);
}
// end if
if (json.Contains("axis"))
{
m_axisConstraint = (AxisConstraint)(int)json["axis"];
}
// end if
if (json.Contains("up"))
{
m_up = JTweenUtils.JsonToVector3(json["up"]);
}
// end if
Restore();
}
public static Tweener SetOptions(this TweenerCore <Vector3, Vector3, VectorOptions> t, bool snapping) => default; // 0x004D7B80-0x004D7BA0 public static Tweener SetOptions(this TweenerCore <Vector3, Vector3, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false /* Metadata: 0x0060FA31 */) => default; // 0x004D7D90-0x004D7DB0
/// <summary>
/// Initializes twohand system with controller/hand source info:
/// the Dictionary collection already filled with controller/hand info,
/// and the Transform of the GameObject to be manipulated.
/// </summary>
/// <param name="handsPressedMap">Dictionary listing inputSourceStates</param>
/// <param name="manipulationRoot">Transform of gameObject to be two hand manipulated</param>
public void Setup(Dictionary <uint, Vector3> handsPressedMap, Transform manipulationRoot)
{
currentRotationConstraint = rotationConstraint;
previousHandlebarRotation = GetHandlebarDirection(handsPressedMap, manipulationRoot);
}
/// <summary>
/// Adds an X/Y pair of axes to the receiver <see cref="ControllerDefinition"/>, and returns it.
/// The new axes will appear after any that were previously defined.
/// </summary>
/// <param name="nameFormat">format string e.g. <c>"P1 Left {0}"</c> (will be used to interpolate <c>"X"</c> and <c>"Y"</c>)</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddXYPair(this ControllerDefinition def, string nameFormat, AxisPairOrientation pDir, Range <int> rangeBoth, int midBoth, AxisConstraint constraint = null)
=> def.AddXYPair(nameFormat, pDir, rangeBoth, midBoth, rangeBoth, midBoth, constraint);
/// <summary>
/// Adds an axis to the receiver <see cref="ControllerDefinition"/>, and returns it.
/// The new axis will appear after any that were previously defined.
/// </summary>
/// <param name="constraint">pass only for one axis in a pair, by convention the X axis</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddAxis(this ControllerDefinition def, string name, Range <int> range, int mid, bool isReversed = false, AxisConstraint constraint = null)
{
def.Axes.Add(name, new AxisSpec(range, mid, isReversed, constraint));
return(def);
}
/// <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
/// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static Tweener DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
{
#if COMPATIBLE
TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.MoveRotation(x), towards, duration)
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration)
#endif
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
return t;
}
public static TweenerCore <Vector3, Vector3, VectorOptions> ToAxis(DOGetter <Vector3> getter, DOSetter <Vector3> setter, float endValue, float duration, AxisConstraint axisConstraint = AxisConstraint.X)
{
TweenerCore <Vector3, Vector3, VectorOptions> tweenerCore = DOTween.ApplyTo <Vector3, Vector3, VectorOptions>(getter, setter, new Vector3(endValue, endValue, endValue), duration, null);
tweenerCore.plugOptions.axisConstraint = axisConstraint;
return(tweenerCore);
}
public override void Reset()
{
base.Reset();
gameObject = null;
duration = new FsmFloat {
UseVariable = false
};
setSpeedBased = new FsmBool {
UseVariable = false, Value = false
};
pathType = PathType.Linear;
pathMode = PathMode.Full3D;
resolution = new FsmInt {
UseVariable = false, Value = 10
};
gizmoColor = new FsmColor {
UseVariable = false
};
closePath = new FsmBool {
UseVariable = false, Value = false
};
lockPosition = AxisConstraint.None;
lockRotation = AxisConstraint.None;
lookAt = LookAt.nothing;
lookAtPosition = new FsmVector3 {
UseVariable = false, Value = Vector3.zero
};
lookAtTarget = new FsmGameObject {
UseVariable = false, Value = null
};
lookAhead = new FsmFloat {
UseVariable = false, Value = 0
};
forwardDirection = new FsmVector3 {
UseVariable = false, Value = Vector3.forward
};
up = new FsmVector3 {
UseVariable = false, Value = Vector3.up
};
startEvent = null;
finishEvent = null;
finishImmediately = new FsmBool {
UseVariable = false, Value = false
};
startDelay = new FsmFloat {
Value = 0
};
easeType = Ease.Linear;
loops = new FsmInt {
Value = 0
};
loopType = LoopType.Restart;
autoKillOnCompletion = new FsmBool {
Value = true
};
recyclable = new FsmBool {
Value = false
};
updateType = UpdateType.Normal;
isIndependentUpdate = new FsmBool {
Value = false
};
debugThis = new FsmBool {
Value = false
};
}
public void Reset()
{
axisConstraint = AxisConstraint.None;
snapping = false;
}
public static Tweener DOLookAt(this Transform target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3?up = null)
{
TweenerCore <Quaternion, Vector3, QuaternionOptions> tweenerCore = DOTween.To(() => target.rotation, delegate(Quaternion x)
{
target.rotation = x;
}, towards, duration).SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
tweenerCore.plugOptions.axisConstraint = axisConstraint;
tweenerCore.plugOptions.up = ((!up.HasValue) ? Vector3.up : up.Value);
return(tweenerCore);
}
protected PenAction(PathEditorTarget pathEditorTarget, SceneViewModel viewModel)
{
this.viewModel = viewModel;
this.pathEditorTarget = pathEditorTarget;
this.axisConstraint = new AxisConstraint();
}
// Token: 0x06000194 RID: 404 RVA: 0x00008900 File Offset: 0x00006B00
public override void EvaluateAndApply(Vector3ArrayOptions options, Tween t, bool isRelative, DOGetter <Vector3> getter, DOSetter <Vector3> setter, float elapsed, Vector3[] startValue, Vector3[] changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
Vector3 vector = Vector3.zero;
if (t.loopType == LoopType.Incremental)
{
int num = t.isComplete ? (t.completedLoops - 1) : t.completedLoops;
if (num > 0)
{
int num2 = startValue.Length - 1;
vector = (startValue[num2] + changeValue[num2] - startValue[0]) * (float)num;
}
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int num3 = ((t.loopType == LoopType.Incremental) ? t.loops : 1) * (t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
if (num3 > 0)
{
int num4 = startValue.Length - 1;
vector += (startValue[num4] + changeValue[num4] - startValue[0]) * (float)num3;
}
}
int num5 = 0;
float num6 = 0f;
float num7 = 0f;
int num8 = options.durations.Length;
float num9 = 0f;
for (int i = 0; i < num8; i++)
{
num7 = options.durations[i];
num9 += num7;
if (elapsed <= num9)
{
num5 = i;
num6 = elapsed - num6;
break;
}
num6 += num7;
}
float num10 = EaseManager.Evaluate(t.easeType, t.customEase, num6, num7, t.easeOvershootOrAmplitude, t.easePeriod);
AxisConstraint axisConstraint = options.axisConstraint;
Vector3 vector2;
if (axisConstraint == AxisConstraint.X)
{
vector2 = getter();
vector2.x = startValue[num5].x + vector.x + changeValue[num5].x * num10;
if (options.snapping)
{
vector2.x = (float)Math.Round((double)vector2.x);
}
setter(vector2);
return;
}
if (axisConstraint == AxisConstraint.Y)
{
vector2 = getter();
vector2.y = startValue[num5].y + vector.y + changeValue[num5].y * num10;
if (options.snapping)
{
vector2.y = (float)Math.Round((double)vector2.y);
}
setter(vector2);
return;
}
if (axisConstraint != AxisConstraint.Z)
{
vector2.x = startValue[num5].x + vector.x + changeValue[num5].x * num10;
vector2.y = startValue[num5].y + vector.y + changeValue[num5].y * num10;
vector2.z = startValue[num5].z + vector.z + changeValue[num5].z * num10;
if (options.snapping)
{
vector2.x = (float)Math.Round((double)vector2.x);
vector2.y = (float)Math.Round((double)vector2.y);
vector2.z = (float)Math.Round((double)vector2.z);
}
setter(vector2);
return;
}
vector2 = getter();
vector2.z = startValue[num5].z + vector.z + changeValue[num5].z * num10;
if (options.snapping)
{
vector2.z = (float)Math.Round((double)vector2.z);
}
setter(vector2);
}
public static Tweener DOLookAt(Transform target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null, float delay = 0, System.Action doComplete = null)
{
Tweener tweener = target.DOLookAt(towards, duration, axisConstraint, up);
SetTweenerComplete(tweener, delay, doComplete);
return tweener;
}
void Start()
{
Vector3[] path = new[] {
new Vector3(0, 1, 0),
new Vector3(1, 2, 0),
new Vector3(2, 1, 0),
new Vector3(2, 0, 0)
};
TweenParams tp = new TweenParams()
.SetEase(ease)
.SetLoops(-1, loopType);
AxisConstraint lockRotation = lockRotation0 | lockRotation1;
// Relative VS non relative
controller = targets[0].DOPath(path, 3, PathType.CatmullRom, pathMode, pathResolution, pathsColors[0])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(0.1f, forward)
.SetAs(tp)
.SetRelative()
.Pause();
targets[1].DOPath(path, 3, PathType.CatmullRom, pathMode, pathResolution, pathsColors[1])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(targets[2], forward)
.SetAs(tp)
.Pause();
// Linear VS curved
targets[2].DOPath(path, 3, PathType.CatmullRom, pathMode, pathResolution, pathsColors[0])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(new Vector3(3, 0, 0), forward)
.SetAs(tp)
.SetRelative()
.Pause();
targets[3].DOPath(path, 3, PathType.Linear, pathMode, pathResolution, pathsColors[1])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(0.1f, forward)
.SetAs(tp)
.SetRelative()
.Pause();
// Linear VS curved no lookAt
targets[4].DOPath(path, 3, PathType.CatmullRom, pathMode, pathResolution, pathsColors[0])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetAs(tp)
.SetRelative()
.Pause();
targets[5].DOPath(path, 3, PathType.Linear, pathMode, pathResolution, pathsColors[1])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetAs(tp)
.SetRelative()
.Pause();
// Linear VS curved top-down
path = new[] {
new Vector3(0, 0, 1),
new Vector3(1, 0, 2),
new Vector3(2, 0, 1),
new Vector3(2, 0, 0)
};
targets[6].DOPath(path, 3, PathType.CatmullRom, pathMode, pathResolution, pathsColors[0])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(0.1f, forward)
.SetAs(tp)
.SetRelative()
.Pause();
targets[7].DOPath(path, 3, PathType.Linear, pathMode, pathResolution, pathsColors[1])
.SetOptions(closePaths, lockPosition, lockRotation)
.SetLookAt(0.1f, forward)
.SetAs(tp)
.SetRelative()
.Pause();
}
public Tweener DOLookAt(int charIndex, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None,
Vector3?up = null)
{
return(MonitorTransformTween(GetProxyTransform(charIndex).DOLookAt(towards, duration, axisConstraint, up)));
}
public override void Reset()
{
base.Reset();
gameObject = null;
target = null;
duration = new FsmFloat {
UseVariable = false
};
setSpeedBased = new FsmBool {
UseVariable = false, Value = false
};
axisConstraint = AxisConstraint.None;
up = new FsmVector3 {
UseVariable = false, Value = Vector3.up
};
setRelative = new FsmBool {
UseVariable = false, Value = false
};
playInReverse = new FsmBool {
UseVariable = false, Value = false
};
setReverseRelative = new FsmBool {
UseVariable = false, Value = false
};
startEvent = null;
finishEvent = null;
finishImmediately = new FsmBool {
UseVariable = false, Value = false
};
stringAsId = new FsmString {
UseVariable = false
};
tagAsId = new FsmString {
UseVariable = false
};
startDelay = new FsmFloat {
Value = 0
};
selectedEase = DOTweenActionsEnums.SelectedEase.EaseType;
easeType = Ease.Linear;
loops = new FsmInt {
Value = 0
};
loopType = LoopType.Restart;
autoKillOnCompletion = new FsmBool {
Value = true
};
recyclable = new FsmBool {
Value = false
};
updateType = UpdateType.Normal;
isIndependentUpdate = new FsmBool {
Value = false
};
debugThis = new FsmBool {
Value = false
};
}
public float[] durations; // Duration of each segment
public void Reset()
{
axisConstraint = AxisConstraint.None;
snapping = false;
durations = null;
}
public static Tweener DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3?up = default(Vector3?))
{
TweenerCore <Quaternion, Vector3, QuaternionOptions> tweenerCore = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration).SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
tweenerCore.plugOptions.axisConstraint = axisConstraint;
tweenerCore.plugOptions.up = (up.HasValue ? up.Value : Vector3.up);
return(tweenerCore);
}
public static TweenerCore <Vector3, Path, PathOptions> SetOptions(this TweenerCore <Vector3, Path, PathOptions> t, AxisConstraint lockPosition, AxisConstraint lockRotation = AxisConstraint.None)
{
return(t.SetOptions(false, lockPosition, lockRotation));
}
/// <summary>Options for Vector3Array tweens</summary>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener SetOptions(this TweenerCore <Vector3, Vector3[], Vector3ArrayOptions> t, AxisConstraint axisConstraint, bool snapping = false)
{
if (t == null || !t.active)
{
return(t);
}
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.snapping = snapping;
return(t);
}
public static Tweener SetOptions(this TweenerCore <Vector4, Vector4, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
{
if ((t != null) && t.active)
{
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.snapping = snapping;
}
return(t);
}
/// <summary>
/// Adds an X/Y pair of axes to the receiver <see cref="ControllerDefinition"/>, and returns it.
/// The new axes will appear after any that were previously defined.
/// </summary>
/// <param name="nameFormat">format string e.g. <c>"P1 Left {0}"</c> (will be used to interpolate <c>"X"</c> and <c>"Y"</c>)</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddXYPair(this ControllerDefinition def, string nameFormat, AxisPairOrientation pDir, Range <int> rangeX, int midX, Range <int> rangeY, int midY, AxisConstraint constraint = null)
{
var yAxisName = string.Format(nameFormat, "Y");
var finalConstraint = constraint ?? new NoOpAxisConstraint(yAxisName);
return(def.AddAxis(string.Format(nameFormat, "X"), rangeX, midX, ((byte)pDir & 2) != 0, finalConstraint)
.AddAxis(yAxisName, rangeY, midY, ((byte)pDir & 1) != 0));
}
public static TweenerCore <Vector3, Path, PathOptions> SetOptions(this TweenerCore <Vector3, Path, PathOptions> t, bool closePath, AxisConstraint lockPosition = AxisConstraint.None, AxisConstraint lockRotation = AxisConstraint.None)
{
if ((t != null) && t.active)
{
t.plugOptions.isClosedPath = closePath;
t.plugOptions.lockPositionAxis = lockPosition;
t.plugOptions.lockRotationAxis = lockRotation;
}
return(t);
}
/// <summary>Tweens a Transform's rotation so that it will look towards the given position.
/// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
/// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
/// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static Tweener DOLookAt(this Transform target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
{
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, towards, duration)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
return t;
}
public Vector3 up; // Used by SpecialStartupMode SetLookAt, accessed by shortcuts and Modules
public void Reset()
{
rotateMode = RotateMode.Fast;
axisConstraint = AxisConstraint.None;
up = Vector3.zero;
}
/// <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
/// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static TweenerCore <Quaternion, Vector3, QuaternionOptions> DOLookAt(this Rigidbody target,
Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3?up = null)
{
TweenerCore <Quaternion, Vector3, QuaternionOptions> t = DOTween
.To(() => target.rotation, target.MoveRotation, towards, duration)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
return(t);
}
/// <summary>
/// TwoHandRotateLogic Constructor
/// </summary>
/// <param name="constrainRotation">Enum describing to which axis the rotation is constrained</param>
public TwoHandRotateLogic(AxisConstraint constrainRotation)
{
rotationConstraint = constrainRotation;
}
