public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <ScreenSpaceReflections>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case ScreenSpaceReflectionsCommand.MaximumMarchDistance:
setting.maximumMarchDistance.overrideState = automaticOverride;
return(DOTween.To(() => setting.maximumMarchDistance.value, x => setting.maximumMarchDistance.value = x, to, duration));
case ScreenSpaceReflectionsCommand.DistanceFade:
setting.distanceFade.overrideState = automaticOverride;
return(DOTween.To(() => setting.distanceFade.value, x => setting.distanceFade.value = x, to, duration));
case ScreenSpaceReflectionsCommand.Vignette:
setting.vignette.overrideState = automaticOverride;
return(DOTween.To(() => setting.vignette.value, x => setting.vignette.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find a Screen Space Reflections to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Rigidbody rb = (Rigidbody)GetComponent(uniTweenTarget);
switch (command)
{
case RigidbodyCommand.Move:
return(rb.DOMove(vector3, duration, snapping));
case RigidbodyCommand.MoveX:
return(rb.DOMoveX(to, duration, snapping));
case RigidbodyCommand.MoveY:
return(rb.DOMoveY(to, duration, snapping));
case RigidbodyCommand.MoveZ:
return(rb.DOMoveZ(to, duration, snapping));
case RigidbodyCommand.Jump:
return(rb.DOJump(vector3, jumpPower, numJumps, duration, snapping));
case RigidbodyCommand.Rotate:
return(rb.DORotate(vector3, duration, mode: rotateMode));
case RigidbodyCommand.LookAt:
return(rb.DOLookAt(vector3, duration, axisConstraint: constraint));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <Grain>();
if (setting != null)
{
setting.colored.value = colored;
setting.active = automaticOverride;
switch (command)
{
case GrainCommand.Intensity:
setting.intensity.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensity.value, x => setting.intensity.value = x, to, duration));
case GrainCommand.Size:
setting.size.overrideState = automaticOverride;
return(DOTween.To(() => setting.size.value, x => setting.size.value = x, to, duration));
case GrainCommand.LuminanceContribution:
setting.lumContrib.overrideState = automaticOverride;
return(DOTween.To(() => setting.lumContrib.value, x => setting.lumContrib.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find a Grain to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <DepthOfField>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case DepthOfFieldCommand.FocusDistance:
setting.focusDistance.overrideState = automaticOverride;
return(DOTween.To(() => setting.focusDistance.value, x => setting.focusDistance.value = x, to, duration));
case DepthOfFieldCommand.Aperture:
setting.aperture.overrideState = automaticOverride;
return(DOTween.To(() => setting.aperture.value, x => setting.aperture.value = x, to, duration));
case DepthOfFieldCommand.FocalLength:
setting.focalLength.overrideState = automaticOverride;
return(DOTween.To(() => setting.focalLength.value, x => setting.focalLength.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find a Depth Of Field to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <AmbientOcclusion>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case AmbientOcclusionCommand.Intensity:
setting.intensity.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensity.value, x => setting.intensity.value = x, to, duration));
case AmbientOcclusionCommand.Radius:
setting.radius.overrideState = automaticOverride;
return(DOTween.To(() => setting.radius.value, x => setting.radius.value = x, to, duration));
case AmbientOcclusionCommand.Color:
setting.color.overrideState = automaticOverride;
return(DOTween.To(() => setting.color.value, x => setting.color.value = x, color, duration));
}
}
else
{
Debug.Log("UniTween could not find an Ambient Occlusion to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <AutoExposure>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case AutoExposureCommand.Filtering:
setting.filtering.overrideState = automaticOverride;
return(DOTween.To(() => setting.filtering.value, x => setting.filtering.value = x, filtering, duration));
case AutoExposureCommand.MinimumEV:
setting.minLuminance.overrideState = automaticOverride;
return(DOTween.To(() => setting.minLuminance.value, x => setting.minLuminance.value = x, to, duration));
case AutoExposureCommand.MaximumEV:
setting.maxLuminance.overrideState = automaticOverride;
return(DOTween.To(() => setting.maxLuminance.value, x => setting.maxLuminance.value = x, to, duration));
case AutoExposureCommand.ExposureCompensation:
setting.keyValue.overrideState = automaticOverride;
return(DOTween.To(() => setting.keyValue.value, x => setting.keyValue.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find an Auto Exposure to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <MotionBlur>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case MotionBlurCommand.ShutterAngle:
setting.shutterAngle.overrideState = automaticOverride;
return(DOTween.To(() => setting.shutterAngle.value, x => setting.shutterAngle.value = x, to, duration));
case MotionBlurCommand.SampleCount:
setting.sampleCount.overrideState = automaticOverride;
return(DOTween.To(() => setting.sampleCount.value, x => setting.sampleCount.value = x, count, duration));
}
}
else
{
Debug.Log("UniTween could not find a Motion Blur to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Image img = (Image)GetComponent(uniTweenTarget);
switch (command)
{
case ImageCommand.Color:
return(img.DOColor(color, duration));
case ImageCommand.Fade:
return(img.DOFade(to, duration));
case ImageCommand.FillAmount:
return(img.DOFillAmount(to, duration));
case ImageCommand.GradientColor:
return(img.DOGradientColor(gradient, duration));
case ImageCommand.BlendableColor:
return(img.DOBlendableColor(color, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Rigidbody2D rb = (Rigidbody2D)GetComponent(uniTweenTarget);
switch (command)
{
case Rigidbody2DCommand.Move:
return(rb.DOMove(vector2, duration, snapping));
case Rigidbody2DCommand.MoveX:
return(rb.DOMoveX(to, duration, snapping));
case Rigidbody2DCommand.MoveY:
return(rb.DOMoveY(to, duration, snapping));
case Rigidbody2DCommand.Jump:
return(rb.DOJump(vector2, jumpPower, numJumps, duration, snapping));
case Rigidbody2DCommand.Rotate:
return(rb.DORotate(to, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
CanvasGroup canvasGroup = (CanvasGroup)GetComponent(uniTweenTarget);
switch (command)
{
case CanvasGroupCommand.Fade:
return(canvasGroup.DOFade(value, duration));
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
MeshRenderer meshRenderer = (MeshRenderer)GetComponent(uniTweenTarget);
Material mat = useSharedMaterial ? meshRenderer.sharedMaterial : meshRenderer.material;
switch (command)
{
case MaterialCommand.Color:
return(mat.DOColor(color, duration));
case MaterialCommand.ColorProperty:
return(mat.DOColor(color, property, duration));
case MaterialCommand.Fade:
return(mat.DOFade(to, duration));
case MaterialCommand.FadeProperty:
return(mat.DOFade(to, property, duration));
case MaterialCommand.Float:
return(mat.DOFloat(to, property, duration));
case MaterialCommand.GradientColor:
return(mat.DOGradientColor(gradient, duration));
case MaterialCommand.GradientColorProperty:
return(mat.DOGradientColor(gradient, property, duration));
case MaterialCommand.Offset:
return(mat.DOOffset(vector2, duration));
case MaterialCommand.OffsetProperty:
return(mat.DOOffset(vector2, property, duration));
case MaterialCommand.Tiling:
return(mat.DOTiling(vector2, duration));
case MaterialCommand.TilingProperty:
return(mat.DOTiling(vector2, property, duration));
case MaterialCommand.Vector:
return(mat.DOVector(vector4, property, duration));
case MaterialCommand.BlendableColor:
return(mat.DOBlendableColor(color, duration));
case MaterialCommand.BlendableColorProperty:
return(mat.DOBlendableColor(color, property, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
LineRenderer line = (LineRenderer)GetComponent(uniTweenTarget);
switch (command)
{
case LineRendererCommand.Color:
return(line.DOColor(new Color2(startColorA, startColorB), new Color2(endColorA, endColorB), duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
AudioMixer mixer = (AudioMixer)GetComponent(uniTweenTarget);
switch (command)
{
case AudioMixerCommand.SetFloat:
return(mixer.DOSetFloat(floatName, to, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Slider slider = (Slider)GetComponent(uniTweenTarget);
switch (command)
{
case SliderCommand.Value:
return(slider.DOValue(to, duration, snapping));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Outline outline = (Outline)GetComponent(uniTweenTarget);
switch (command)
{
case OutlineCommand.Color:
return(outline.DOColor(color, duration));
case OutlineCommand.Fade:
return(outline.DOFade(to, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
TrailRenderer trail = (TrailRenderer)GetComponent(uniTweenTarget);
switch (command)
{
case TrailCommand.Resize:
return(trail.DOResize(toStartWidth, toEndWidth, duration));
case TrailCommand.Time:
return(trail.DOTime(to, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
AudioSource source = (AudioSource)GetComponent(uniTweenTarget);
switch (command)
{
case AudioSourceCommand.Fade:
return(source.DOFade(to, duration));
case AudioSourceCommand.Pitch:
return(source.DOPitch(to, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <Bloom>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case BloomCommand.Intensity:
setting.intensity.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensity.value, x => setting.intensity.value = x, to, duration));
case BloomCommand.Threshold:
setting.threshold.overrideState = automaticOverride;
return(DOTween.To(() => setting.threshold.value, x => setting.threshold.value = x, to, duration));
case BloomCommand.SoftKnee:
setting.softKnee.overrideState = automaticOverride;
return(DOTween.To(() => setting.softKnee.value, x => setting.softKnee.value = x, to, duration));
case BloomCommand.Diffusion:
setting.diffusion.overrideState = automaticOverride;
return(DOTween.To(() => setting.diffusion.value, x => setting.diffusion.value = x, to, duration));
case BloomCommand.AnamorphicRatio:
setting.anamorphicRatio.overrideState = automaticOverride;
return(DOTween.To(() => setting.anamorphicRatio.value, x => setting.anamorphicRatio.value = x, to, duration));
case BloomCommand.Color:
setting.color.overrideState = automaticOverride;
return(DOTween.To(() => setting.color.value, x => setting.color.value = x, color, duration));
case BloomCommand.DirtinessIntensity:
setting.dirtIntensity.overrideState = automaticOverride;
return(DOTween.To(() => setting.dirtIntensity.value, x => setting.dirtIntensity.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find a Bloom to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
switch (command)
{
case PPVolumeCommand.Weigth:
return(DOTween.To(() => volume.weight, x => volume.weight = x, to, duration));
case PPVolumeCommand.Priority:
return(DOTween.To(() => volume.priority, x => volume.priority = x, to, duration));
case PPVolumeCommand.BlendDistance:
return(DOTween.To(() => volume.blendDistance, x => volume.blendDistance = x, to, duration));
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
RectTransform rect = (RectTransform)GetComponent(uniTweenTarget);
switch (command)
{
case RectCommand.AnchorPosY:
return(rect.DOAnchorPosY(value.y, duration, snapping));
case RectCommand.AnchorPosX:
return(rect.DOAnchorPosX(value.x, duration, snapping));
case RectCommand.AnchorPos:
return(rect.DOAnchorPos(value, duration, snapping));
case RectCommand.AnchorMin:
return(rect.DOAnchorMin(value, duration, snapping));
case RectCommand.AnchorMax:
return(rect.DOAnchorMax(value, duration, snapping));
case RectCommand.JumpAnchorPos:
return(rect.DOJumpAnchorPos(value, jumpPower, numJumps, duration, snapping));
case RectCommand.Pivot:
return(rect.DOPivot(value, duration));
case RectCommand.PivotX:
return(rect.DOPivotX(value.x, duration));
case RectCommand.PivotY:
return(rect.DOPivotY(value.y, duration));
case RectCommand.PunchAnchorPos:
return(rect.DOPunchAnchorPos(value, duration, snapping: snapping));
case RectCommand.ShakeAnchorPos:
return(rect.DOShakeAnchorPos(duration, snapping: snapping));
case RectCommand.SizeDelta:
return(rect.DOSizeDelta(value, duration, snapping));
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Graphic graphic = (Graphic)GetComponent(uniTweenTarget);
switch (command)
{
case GraphicCommand.Color:
return(graphic.DOColor(color, duration));
case GraphicCommand.Fade:
return(graphic.DOFade(to, duration));
case GraphicCommand.BlendableColor:
return(graphic.DOBlendableColor(color, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
ScrollRect scroll = (ScrollRect)GetComponent(uniTweenTarget);
switch (command)
{
case ScrollRectCommand.NormalizedPos:
return(scroll.DONormalizedPos(pos, duration, snapping));
case ScrollRectCommand.HorizontalNormalizedPos:
return(scroll.DOHorizontalNormalizedPos(to, duration, snapping));
case ScrollRectCommand.VerticalPos:
return(scroll.DOVerticalNormalizedPos(to, duration, snapping));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
LayoutElement element = (LayoutElement)GetComponent(uniTweenTarget);
switch (command)
{
case LayoutElementCommand.FlexibleSize:
return(element.DOFlexibleSize(to, duration, snapping));
case LayoutElementCommand.MinSize:
return(element.DOMinSize(to, duration, snapping));
case LayoutElementCommand.PreferredSize:
return(element.DOPreferredSize(to, duration, snapping));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
PostProcessVolume volume = (PostProcessVolume)GetComponent(uniTweenTarget);
var setting = volume.profile.GetSetting <LensDistortion>();
if (setting != null)
{
setting.active = automaticOverride;
switch (command)
{
case LensDistortionCommand.Intensity:
setting.intensity.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensity.value, x => setting.intensity.value = x, to, duration));
case LensDistortionCommand.YMultiplier:
setting.intensityY.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensityY.value, x => setting.intensityY.value = x, to, duration));
case LensDistortionCommand.XMultiplier:
setting.intensityX.overrideState = automaticOverride;
return(DOTween.To(() => setting.intensityX.value, x => setting.intensityX.value = x, to, duration));
case LensDistortionCommand.CenterX:
setting.centerX.overrideState = automaticOverride;
return(DOTween.To(() => setting.centerX.value, x => setting.centerX.value = x, to, duration));
case LensDistortionCommand.CenterY:
setting.centerY.overrideState = automaticOverride;
return(DOTween.To(() => setting.centerY.value, x => setting.centerY.value = x, to, duration));
case LensDistortionCommand.Scale:
setting.scale.overrideState = automaticOverride;
return(DOTween.To(() => setting.scale.value, x => setting.scale.value = x, to, duration));
}
}
else
{
Debug.Log("UniTween could not find a Lens Distortion to tween. Be sure to add it on your Post Process Volume component");
}
return(null);
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Camera cam = (Camera)GetComponent(uniTweenTarget);
switch (command)
{
case CameraCommand.Aspect:
return(cam.DOAspect(to, duration));
case CameraCommand.Color:
return(cam.DOColor(color, duration));
case CameraCommand.FarClipPlane:
return(cam.DOFarClipPlane(to, duration));
case CameraCommand.FieldOfView:
return(cam.DOFieldOfView(to, duration));
case CameraCommand.NearClipPlane:
return(cam.DONearClipPlane(to, duration));
case CameraCommand.OrthoSize:
return(cam.DOOrthoSize(to, duration));
case CameraCommand.PixerRect:
return(cam.DOPixelRect(rect, duration));
case CameraCommand.Rect:
return(cam.DORect(rect, duration));
case CameraCommand.ShakePosition:
return(cam.DOShakePosition(duration, strength, vibrato, randomness, fadeOut));
case CameraCommand.ShakeRotation:
return(cam.DOShakeRotation(duration, strength, vibrato, randomness, fadeOut));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
SpriteRenderer sr = (SpriteRenderer)GetComponent(uniTweenTarget);
switch (command)
{
case SpriteRendererCommand.Color:
return(sr.DOColor(color, duration));
case SpriteRendererCommand.Fade:
return(sr.DOFade(to, duration));
case SpriteRendererCommand.GradientColor:
return(sr.DOGradientColor(gradient, duration));
case SpriteRendererCommand.BlendableColor:
return(sr.DOBlendableColor(color, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Text text = (Text)GetComponent(uniTweenTarget);
switch (command)
{
case TextCommand.Color:
return(text.DOColor(color, duration));
case TextCommand.Fade:
return(text.DOFade(to, duration));
case TextCommand.Text:
return(text.DOText(newText, duration, richText, scrambleMode));
case TextCommand.BlendableColor:
return(text.DOBlendableColor(color, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Light light = (Light)GetComponent(uniTweenTarget);
switch (command)
{
case LightCommand.Color:
return(light.DOColor(color, duration));
case LightCommand.Intensity:
return(light.DOIntensity(to, duration));
case LightCommand.ShadowStrength:
return(light.DOShadowStrength(to, duration));
case LightCommand.BlendableColor:
return(light.DOBlendableColor(color, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
Transform transform = (Transform)GetComponent(uniTweenTarget);
switch (command)
{
case TransformCommand.Move:
return(transform.DOMove(value, duration, snapping));
case TransformCommand.MoveX:
return(transform.DOMoveX(value.x, duration, snapping));
case TransformCommand.MoveY:
return(transform.DOMoveY(value.y, duration, snapping));
case TransformCommand.MoveZ:
return(transform.DOMoveZ(value.z, duration, snapping));
case TransformCommand.LocalMove:
return(transform.DOLocalMove(value, duration, snapping));
case TransformCommand.LocalMoveX:
return(transform.DOLocalMoveX(value.x, duration, snapping));
case TransformCommand.LocalMoveY:
return(transform.DOLocalMoveY(value.y, duration, snapping));
case TransformCommand.LocalMoveZ:
return(transform.DOLocalMoveZ(value.z, duration, snapping));
case TransformCommand.Jump:
return(transform.DOJump(value, jumpPower, numJumps, duration, snapping));
case TransformCommand.LocalJump:
return(transform.DOLocalJump(value, jumpPower, numJumps, duration, snapping));
case TransformCommand.Rotate:
return(transform.DORotate(value, duration, rotateMode));
case TransformCommand.RotateQuaternion:
return(transform.DORotateQuaternion(quaternion, duration));
case TransformCommand.LocalRotate:
return(transform.DOLocalRotate(value, duration, rotateMode));
case TransformCommand.LocalRotateQuaternion:
return(transform.DOLocalRotateQuaternion(quaternion, duration));
case TransformCommand.LookAt:
return(transform.DOLookAt(value, duration));
case TransformCommand.Scale:
return(transform.DOScale(value, duration));
case TransformCommand.ScaleX:
return(transform.DOScaleX(value.x, duration));
case TransformCommand.ScaleY:
return(transform.DOScaleY(value.y, duration));
case TransformCommand.ScaleZ:
return(transform.DOScaleZ(value.z, duration));
case TransformCommand.PunchPosition:
return(transform.DOPunchPosition(value, duration, vibrato, snapping: snapping));
case TransformCommand.PunchRotation:
return(transform.DOPunchRotation(value, duration, vibrato));
case TransformCommand.PunchScale:
return(transform.DOPunchScale(value, duration, vibrato));
case TransformCommand.ShakePosition:
return(transform.DOShakePosition(duration, strength, vibrato, randomness, snapping: snapping));
case TransformCommand.ShakeRotation:
return(transform.DOShakeRotation(duration, strength, vibrato, randomness));
case TransformCommand.ShakeScale:
return(transform.DOShakeScale(duration, strength, vibrato, randomness));
case TransformCommand.Path:
return(transform.DOPath(waypoints, duration, pathType, pathMode));
case TransformCommand.LocalPath:
return(transform.DOLocalPath(waypoints, duration, pathType, pathMode));
case TransformCommand.BlendableMoveBy:
return(transform.DOBlendableMoveBy(value, duration, snapping));
case TransformCommand.BlendableLocalMoveBy:
return(transform.DOBlendableLocalMoveBy(value, duration, snapping));
case TransformCommand.BlendableRotateBy:
return(transform.DOBlendableRotateBy(value, duration, rotateMode));
case TransformCommand.BlendableLocalRotateBy:
return(transform.DOBlendableLocalRotateBy(value, duration, rotateMode));
case TransformCommand.BlendableScaleBy:
return(transform.DOBlendableScaleBy(value, duration));
default:
return(null);
}
}
public override Tween GetTween(UniTween.UniTweenTarget uniTweenTarget)
{
TextMeshPro text = (TextMeshPro)GetComponent(uniTweenTarget);
switch (command)
{
case TextMeshCommand.Scale:
return(DOTween.To(() => text.fontSize, x => text.fontSize = x, text.fontSize * to, duration));
case TextMeshCommand.Color:
return(DOTween.To(() => text.color, x => text.color = x, color, duration));
case TextMeshCommand.FaceColor:
return(text.fontMaterial.DOColor(color, "_FaceColor", duration));
case TextMeshCommand.FaceFade:
return(DOTween.To(() => text.faceColor, x => text.faceColor = x, new Vector4(text.faceColor.r, text.faceColor.g, text.faceColor.b, to), duration));
case TextMeshCommand.Fade:
return(DOTween.To(() => text.alpha, x => text.alpha = x, to, duration));
case TextMeshCommand.FontSize:
return(DOTween.To(() => text.fontSize, x => text.fontSize = x, to, duration));
case TextMeshCommand.GlowColor:
return(text.fontMaterial.DOColor(color, "_GlowColor", duration));
case TextMeshCommand.MaxVisibleCharacters:
return(DOTween.To(() => text.maxVisibleCharacters, x => text.maxVisibleCharacters = x, characters, duration));
case TextMeshCommand.OutlineColor:
return(text.fontMaterial.DOColor(color, "_OutlineColor", duration));
case TextMeshCommand.Text:
Sequence sqText = DOTween.Sequence();
if (customEase)
{
sqText.SetEase(curve);
}
else
{
sqText.SetEase(ease);
}
sqText.AppendCallback(() => text.richText = richTextEnabled);
sqText.Append(DOTween.To(() => text.text, x => text.text = x, newText, duration));
return(sqText);
case TextMeshCommand.ColorProperty:
return(text.fontMaterial.DOColor(color, property, duration));
case TextMeshCommand.FloatProperty:
return(text.fontMaterial.DOFloat(to, property, duration));
case TextMeshCommand.TilingProperty:
return(text.fontMaterial.DOTiling(tiling, property, duration));
case TextMeshCommand.VectorProperty:
return(text.fontMaterial.DOVector(vector, property, duration));
}
return(null);
}
