如何在Lua上使用Dotween【便捷、易读性高】

已于 2025-09-09 10:56:18 修改
阅读量2.8k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Unity Lua 经验总结 文章标签： unity lua
于 2022-05-03 11:14:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Le_Sam/article/details/124552024
本文介绍了如何在Unity中利用DOTween库创建一个名为DoTweenEx的扩展，实现了更简洁易读的动画控制接口。DoTweenEx支持序列化与并行动画，自动关闭，以及各种缓动类型、循环模式、更新方式等功能。同时，提供了Lua绑定，方便在Lua脚本中调用。示例展示了如何进行位移、缩放、旋转、颜色变化等动画操作，并且支持自定义回调函数。

功能介绍：

1.整合Append与Insert接口，支持串行与并行动画

2.支持随物体/界面等销毁而自动关闭动画

3.易读性高，action的写法很直观看出具体操作内容

PS：该文章部分源码依据于此在lua里实现类似unity生命周期的监听事件_Le_Sam的博客-CSDN博客

源码：

c#


namespace Game.Scripts.Common
{
    [XLua.LuaCallCSharp]
    public class DoTweenEx
    {
        private Tweener tweener;
        private Sequence sequence;
        private Tween current;

        public static DoTweenEx Sequence()
        {
            return new DoTweenEx(DOTween.Sequence());
        }

        private DoTweenEx(Sequence sequence)
        {
            this.sequence = sequence;
            current = sequence;
            this.Ease(1); //默认EaseType为DoTweenAction.Linear
        }

        private DoTweenEx(Transform target, Tweener tweener)
        {
            this.tweener = tweener;
            current = tweener;
            this.Ease(1); //默认EaseType为DoTweenAction.Linear
        }

        public DoTweenEx Append(DoTweenEx tweener)
        {
            sequence.Append(tweener.current);
            return this;
        }

        public DoTweenEx Insert(DoTweenEx tweener)
        {
            sequence.Insert(0, tweener.current);
            return this;
        }

        public DoTweenEx Play()
        {
            current.Play();
            return this;
        }

        public DoTweenEx Pause()
        {
            current.Pause();
            return this;
        }

        public DoTweenEx Kill(bool complete)
        {
            current.Kill(complete);
            return this;
        }

        public DoTweenEx Ease(uint ease)
        {
            current.SetEase((Ease)ease);
            return this;
        }

        public DoTweenEx Loop(int loops, uint type)
        {
            loops = loops == -1 ? 99999 : loops; // Temp:循环为-1时，并没有生效，强制改为固定值
            if (sequence != null)
                sequence.SetLoops(loops);
            if (tweener != null)
                tweener.SetLoops(loops, (LoopType)type);
            return this;
        }

        public DoTweenEx Delay(float delay)
        {
            current.SetDelay(delay);
            return this;
        }

        public DoTweenEx Restart()
        {
            current.Restart();
            return this;
        }

        public DoTweenEx OnComplete(LuaFunction func)
        {
            current.OnComplete(delegate() { func.Call(this); });
            return this;
        }

        public DoTweenEx SetUpdate(uint type, bool isAlone)
        {
            current.SetUpdate((UpdateType)type, isAlone);
            return this;
        }

        public DoTweenEx SetPlaySpeed(float speed)
        {
            current.timeScale = speed;
            return this;
        }

        public static DoTweenEx NoneTo(Transform target, float duration)
        {
            return new DoTweenEx(target, DOTween.To(() => 0, v => v = 0, 0, duration + 0.001f));
        }

        public static DoTweenEx LocalMoveTo(Transform target, Vector3 pos, float duration)
        {
            return new DoTweenEx(target, target.DOLocalMove(pos, duration + 0.001f));
        }

        public static DoTweenEx LocalMoveBy(Transform target, Vector3 pos, float duration)
        {
            return new DoTweenEx(target, target.DOBlendableLocalMoveBy(pos, duration + 0.001f));
        }

        public static DoTweenEx MoveTo(Transform target, Vector3 pos, float duration)
        {
            return new DoTweenEx(target, target.DOMove(pos, duration + 0.001f));
        }

        public static DoTweenEx MoveBy(Transform target, Vector3 pos, float duration)
        {
            return new DoTweenEx(target, target.DOBlendableMoveBy(pos, duration + 0.001f));
        }

        public static DoTweenEx RotateTo(Transform target, Vector3 angle, float duration)
        {
            return new DoTweenEx(target, target.DORotate(angle, duration + 0.001f, RotateMode.FastBeyond360));
        }

        public static DoTweenEx RotateBy(Transform target, Vector3 angle, float duration)
        {
            return new DoTweenEx(target, target.DOBlendableRotateBy(angle, duration + 0.001f, RotateMode.FastBeyond360));
        }

        public static DoTweenEx LocalRotateTo(Transform target, Quaternion angle, float duration)
        {
            return new DoTweenEx(target, target.DOLocalRotateQuaternion(angle, duration + 0.001f));
        }

        public static DoTweenEx LocalRotateBy(Transform target, Vector3 angle, float duration)
        {
            return new DoTweenEx(target, target.DOBlendableLocalRotateBy(angle, duration + 0.001f, RotateMode.FastBeyond360));
        }

        public static DoTweenEx ScaleTo(Transform target, Vector3 scale, float duration)
        {
            return new DoTweenEx(target, target.DOScale(scale, duration + 0.001f));
        }

        public static DoTweenEx ScaleBy(Transform target, Vector3 scale, float duration)
        {
            return new DoTweenEx(target, target.DOBlendableScaleBy(scale, duration + 0.001f));
        }

        public static DoTweenEx To(Transform target, int startValue, int endValue, float duration, LuaFunction setter)
        {
            int currValue = startValue;
            return new DoTweenEx(target, DOTween.To(() => startValue, delegate(int v)
            {
                if (currValue != v)
                {
                    currValue = v;
                    setter.Call(v);
                }
            }, endValue, duration + 0.001f));
        }

        public static DoTweenEx FadeTo(Transform target, float alpha, float duration)
        {
            var graphic = target.GetComponent<Graphic>();
            if (graphic != null)
            {
                alpha = alpha > 1 ? 1 : alpha;
                return new DoTweenEx(target, graphic.DOFade(alpha, duration + 0.001f));
            }
            return NoneTo(target, duration);
        }

        public static DoTweenEx FadeToAll(Transform target, float alpha, float duration, bool ignoreTS)
        {
            alpha = alpha > 1 ? 1 : alpha;
            var tween = FadeTo(target, alpha, duration);
            tween.current.OnStart(delegate () {
                Graphic[] graphics = target.GetComponentsInChildren<Graphic>();
                foreach (var g in graphics)
                {
                    g.CrossFadeAlpha(alpha, duration, ignoreTS);
                }
            });
            return tween;
        }

        public static DoTweenEx ColorTo(Transform target, Color color, float duration)
        {
            var graphic = target.GetComponent<Graphic>();
            if (graphic != null)
            {
                return new DoTweenEx(target, graphic.DOColor(color, duration + 0.001f));
            }
            return NoneTo(target, duration);
        }

        public static DoTweenEx ColorToAll(Transform target, Color color, float duration, bool ignoreTS)
        {
            var tween = ColorTo(target, color, duration);
            tween.current.OnStart(delegate()
            {
                Graphic[] graphics = target.GetComponentsInChildren<Graphic>();
                foreach (var g in graphics)
                {
                    g.CrossFadeColor(color, duration, ignoreTS, true);
                }
            });
            return tween;
        }

        public static DoTweenEx ShakeRotation(Transform target, float duration, Vector3 strength, int vibrato, float randomness)
        {
            return new DoTweenEx(target, target.DOShakeRotation(duration, strength, vibrato, randomness));
        }
    }
}

Lua

local DoTweenAction = {}

local DoTweenEx = CS.Game.Scripts.Common.DoTweenEx

DoTweenAction.Linear = 1--默认EaseType
DoTweenAction.InSine = 2
DoTweenAction.OutSine = 3
DoTweenAction.InOutSine = 4
DoTweenAction.InQuad = 5
DoTweenAction.OutQuad = 6
DoTweenAction.InOutQuad = 7
DoTweenAction.InCubic = 8
DoTweenAction.OutCubic = 9
DoTweenAction.InOutCubic = 10
DoTweenAction.InQuart = 11
DoTweenAction.OutQuart = 12
DoTweenAction.InOutQuart = 13
DoTweenAction.InQuint = 14
DoTweenAction.OutQuint = 15
DoTweenAction.InOutQuint = 16
DoTweenAction.InExpo = 17
DoTweenAction.OutExpo = 18
DoTweenAction.InOutExpo = 19
DoTweenAction.InCirc = 20
DoTweenAction.OutCirc = 21
DoTweenAction.InOutCirc = 22
DoTweenAction.InElastic = 23
DoTweenAction.OutElastic = 24
DoTweenAction.InOutElastic = 25
DoTweenAction.InBack = 26
DoTweenAction.OutBack = 27
DoTweenAction.InOutBack = 28
DoTweenAction.InBounce = 29
DoTweenAction.OutBounce = 30
DoTweenAction.InOutBounce = 31
DoTweenAction.Flash = 32
DoTweenAction.InFlash = 33
DoTweenAction.OutFlash = 34
DoTweenAction.InOutFlash = 35

DoTweenAction.LTRestart = 0 -- 默认LoopType
DoTweenAction.LTYoyo = 1
DoTweenAction.LTIncremental = 2

DoTweenAction.UpdateNormal = 0 -- 默认UpdateType
DoTweenAction.UpdateLate = 1
DoTweenAction.UpdateFixed = 2
DoTweenAction.UpdateManual = 3

local Param = {
	ease = function(tween, aEaseType)
		return tween:Ease(aEaseType)
	end,
	loop = function(tween, aTimes, aLoopType)
		return tween:Loop(aTimes, aLoopType or DoTweenAction.LTRestart)
	end,
	delay = function(tween, aSecend)
		return tween:Delay(aSecend)
	end,
	-- DoTween终止回调
	OnEnd = function(tween, ...)
		return DoTweenAction.SetOnComplete(tween, ...)
	end,
}

local Function = {
	-- 并行
	spawn = function(target, ...)
		return DoTweenAction.SequenceAction(target, {...}, "Insert")
	end,
	delay = function(target, delay, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.NoneTo(target, delay), ...)
	end,
	call = function(target, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.NoneTo(target), ...)
	end,
	to = function(target, startValue, endValue, duration, setter, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.To(target, startValue, endValue, duration, setter), ...)
	end,
	localMoveBy = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.LocalMoveBy(target, vec, duration), ...)
	end,
	localMoveTo = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.LocalMoveTo(target, vec, duration), ...)
	end,
	moveBy = function(target, vec, duration, camera, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.MoveBy(target, vec, duration, camera), ...)
	end,
	moveTo = function(target, vec, duration, camera, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.MoveTo(target, vec, duration, camera), ...)
	end,
	rotateBy = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.RotateBy(target, vec, duration), ...)
	end,
	rotateTo = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.RotateTo(target, vec, duration), ...)
	end,
	localRotateBy = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.LocalRotateBy(target, vec, duration), ...)
	end,
	localRotateTo = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.LocalRotateTo(target, vec, duration), ...)
	end,
	scaleBy = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.ScaleBy(target, vec, duration), ...)
	end,
	scaleTo = function(target, vec, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.ScaleTo(target, vec, duration), ...)
	end,	
	fadeTo = function(target, opacity, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.FadeTo(target, opacity, duration), ...)
	end,
	fadeToAll = function(target, opacity, duration, ignoreTS, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.FadeToAll(target, opacity, duration, ignoreTS or true), ...)
	end,
	colorTo = function(target, color, duration, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.ColorTo(target, color, duration), ...)
	end,
	colorToAll = function(target, color, duration, ignoreTS, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.ColorToAll(target, color, duration, ignoreTS or true), ...)
	end,
	shakeRotation = function(target, duration, vec, vibrato, randomness, ...)
		return DoTweenAction.SetOnComplete(DoTweenEx.ShakeRotation(target, duration, vec, vibrato or 10, randomness or 90), ...)
	end,
}

function DoTweenAction.SetCallBack(tween, callback, aFunc, ...)
	if aFunc and type(aFunc) == "function" then
		local args = {...}
		return tween[callback](tween, #args == 0 and aFunc or function()
			aFunc(table.unpack(args))
		end)
	end
	return tween
end

function DoTweenAction.SetOnComplete(tween, aFunc, ...)
	return DoTweenAction.SetCallBack(tween, 'OnComplete', aFunc, ...)
end

function DoTweenAction.SetParam(tween, action, funcName)

	if tween then
		for name, param in pairs(action) do
			if type(name) == "string" then
				assert(Param[name] ~= nil, "DoTweenAction SetParam not find : ".. name);
				if type(param) == "table" then
					Param[name](tween, table.unpack(param))
				else
					Param[name](tween, param)
				end
			end
		end
	else
		logerror("DoTweenAction SetParam not find : ".. funcName)
	end
	return tween
end

function DoTweenAction.SequenceAction(target, action, opt)
	local sequence = DoTweenEx.Sequence()
	for _, act in ipairs(action) do
		if type(act) == "table" then
			if opt == "Append" then
				sequence:Append(DoTweenAction.RunAction(target, act))
			elseif opt == "Insert" then
				sequence:Insert(DoTweenAction.RunAction(target, act))
			end
		end
	end
	return DoTweenAction.SetParam(sequence, action)
end

function DoTweenAction.RunAction(target, action)
	return DoTweenAction.CreateAction(target.transform or target, action, table.unpack(action))
end

function DoTweenAction.CreateAction(target, action, funcName, ...)
	-- 代表一个动作
	if type(funcName) == "string" then
		assert(Function[funcName] ~= nil, "DoTweenAction CreateAction not find : ".. funcName);
		local tween = Function[funcName](target, ...)
		tween = DoTweenAction.SetParam(tween, action, funcName)
		return tween
	-- Action是一个动作数组，需要拆分其动作并组合成数组动作
	elseif type(funcName) == "table" then
		return DoTweenAction.SequenceAction(target, action, "Append")
	-- 表示这个动作只是执行这个function
	elseif type(funcName) == "function" then
		return Function.call(target, funcName, ...)
	end
end


return DoTweenAction


local DoTweenAction = require("DoTweenAction")

local ActionTool = {}

local actionMap = {};
local actionKey = 0;

-- 运行动作
function ActionTool.RunAction(target, action, ignoreTS)

    actionKey = actionKey + 1
    local curKey = actionKey

    local function onDestory()
        ActionTool.StopAction(curKey)
	end

    local function onComplete()
		actionMap[curKey] = nil 
	end

    Helpers.AddDestroyListener(target.transform or target, onDestory)
    actionMap[curKey] = DoTweenAction.RunAction(target, {
        action,
        OnEnd = onComplete,
    })
    ActionTool.ChangeUpdateAction(curKey, DoTweenAction.UpdateNormal, ignoreTS or true) -- 默认忽略Time.timeScale
    return curKey	
end

-- 停止动作
function ActionTool.StopAction(actionKey, complete)
    local action = actionMap[actionKey];
    if action then
        action:Kill(complete or false);
        actionMap[actionKey] = nil;
    end
end

--暂停动作
function ActionTool.PauseAction(actionKey)
    if not actionKey then return end
    if not actionMap[actionKey] then return end
    actionMap[actionKey]:Pause()
end

--恢复动作
function ActionTool.ResumeAction(actionKey)
    if not actionKey then return end
    if not actionMap[actionKey] then return end
    actionMap[actionKey]:Play()
end

-- 改变速度
function ActionTool.ChangeSpeedAction(actionKey, speed)
    if not actionKey then return end
    if not actionMap[actionKey] then return end
    actionMap[actionKey]:SetPlaySpeed(speed)
end

-- 改变Update
function ActionTool.ChangeUpdateAction(actionKey, type, isAlone)
    if not actionKey then return end
    if not actionMap[actionKey] then return end
    actionMap[actionKey]:SetUpdate(type, isAlone)
end

-- 停止所有动作
function ActionTool.StopAllAction(complete)
	for _,v in pairs(actionMap) do
		v:Kill(complete or false);
	end
	actionKey = 0;
	actionMap = {};
end


return ActionTool

示例：

-- View
local UITest = ClassView("UITest")
local ActionTool = require("ActionTool")
local DoTweenAction = require("DoTweenAction")

function UITest:OnCreate() 
    local testTxt = self:FindChild("testUI"):GetComponent("Text")
    -- Test1
    do
        local action = {
            {"spawn", 
                {"localMoveTo", Vector3(-100, 0, 0), 0.25, ease = DoTweenAction.OutQuad},
                {"scaleTo", Vector3(1.1, 1.1, 1.1), 0.15, delay = 0.1, ease = DoTweenAction.OutQuad},
            },
            {"call", function()
                logdebug(string.format("Test1 call ==> testTxt:%s", testTxt))
            end},
            {"delay", 5},
            OnEnd = function()
                logdebug(string.format("Test1 OnEnd ==> testTxt:%s", testTxt))
            end,
        };
        ActionTool.RunAction(testTxt.transform, action) 
    end

    -- Test2
    do
        local maxP = 100
        local centreP = maxP / 2
        local tempColor = Color(1,1,1,1)
        local action = {
            {"to", 1, maxP, 1, function(value)
                local curValue = value >= centreP and value or -value + maxP
                tempColor.a = curValue / maxP
                testTxt.color = tempColor
                end, loop = -1
            },
        };
        ActionTool.RunAction(testTxt.transform, action)
    end

DoTween使用与详解lua、C#、属性详解
Improve_life的博客
07-26 3441
Unity ToLua & LuaFramework_UGUI中使用DoTween 在做一些弹窗动画或Tips以及缩放，渐变震动等效果时，常常会间接引入第三方库，最近就尝试了一下在ToLua & LuaFramework_UGUI中的使用，细心的初学者都会发现，其实LuaFramework框架已经为我们加入了DoTween库的引用，只是开源作者加了一个宏定义限制，我们只要稍微处理...
Unity插件DoTween使用详解
最新发布
qq_44908456的博客
04-20 2042
DoTween支持自定义动画类型，可以通过继承DOTweenAnimation类实现。// 动画时长// 结束值。
LuaDOTween
05-08
Lua DOTween unity tolua 插件 要用DOTween Pro v0.9.69
Lua 调用 dotween
若风
07-12 1194
这里必须要把value传过去，貌似lua的闭包不会传到外边 using DG.Tweening; using UnityEngine; using UnityEngine.UI; public static class DoTweenUtils { public static Tween DoVector2(Vector2 start, Vector2 end, float duration, TweenCallback<Vector2> action) { .
Ulua使用DoTween修正改进脚本
04-29
请下载这个最终版本，图片和文字可以调用透明度颜色动画，RectTransform动画，另外修正了LUA调用旋转的问题。
Unity3D热更新之LuaFramework篇[05]--Lua脚本调用c#以及如何在Lua中使用Dotween
weixin_30642561的博客
06-15 545
在上一篇文章Unity3D热更新之LuaFramework篇[04]--自定义UI监听方法中，我对LuaBehaviour脚本进行了扩展，添加了两个新的UI监听方法，也提到最好能单写一个脚本处理此事。本篇文章就来继续这个工作。 从Lua中调用C#代码 1、创建UI监听脚本 打开之前的工程，在Assets/LuaFrameworks/Scripts/Common下，创...
Ulua使用DoTween改进版
04-29
simpleframework-ugui，可以直接替换使用，比网上其他的教程，ShortcutExtensions46，增加了一个静态类，可以在ULUA中使用图片颜色，文字透明，RectTransform等动画。
Xlua使用C#中第三方库：DoTween
没钱装电脑的程序猿
05-02 6521
lua中加上DOtween = CS.DG.Tweening.DOTween 就可以调用了 如果要使用extension，在这里面 [LuaCallCSharp] public static List LuaCallCSharp = new List() {}需要添加一堆下面这中代码
[Unity热更新]tolua# & LuaFramework(七)：lua使用DOTween
热门推荐
宏哥的博客
04-11 1万+
相关链接： http://blog.csdn.net/u010665359/article/details/50950989 http://blog.csdn.net/u010665359/article/details/51013433 在lua中使用DOTween 1.先下载一些东西：http://pan.baidu.com/s/1pLOSxx5 2.在Ass
Ulua热更新提高 <六> Ulua使用DoTween改进版
我是重阳 的专栏
04-29 4721
原创 Ulua热更新提高 两张其实草稿都在的，但是我感觉还有很多要修改的地方，有些地方我也没有弄透，所以先不发了。最近比较忙，基本没时间写博客，见谅。Ulua里使用DoTween网上能搜索到很多，出自哪里我也不知道了，感谢原作者的努力。全部都是写在LuaFramework框架下的DoTween使用，还有图片和文字的透明度和改变颜色没法使用，有时候经常需要Image改变透明度，很麻烦，今天把代码稍
LuaFrameWork 使用Dotween 报错解决 以LuaFrameWork1.0.7.388 Examples/12_GameObject/TestGameObject 为例
ST_Dark的专栏
01-31 1871
1.加入宏USING_DOTWEENING      此时如下代码就会解锁 2.运行游戏后会调用如下lua代码 3.DoMove的使用是正常的,但是dotween回调方法OnComplete会报错  信息如下 4.说明TweenCallback委托没有注册  因此把DG.Tweening.TweenCallback
Unity热更新_Lua中使用DOTween插件
lizhenxiqnmlgb的博客
08-09 2362
要想在Lua中使用DOTween插件，必须把在 Lua中会使用到的DOTween类型经过下面处理，其实就是增加这么一个类型就行，如果不这样做，则在lua中调用到DOTween Api的时候会出错： using System; using System.Collections.Generic; using System.Linq; using System.Reflection; usin...
DoTween
winzjqwin的专栏
02-22 532
DoTween的缓动动画曲线与效果 DoTween缓动动画速查表 unity+tolua下用lua调用DG.Tweening.DOTween的示例 local sequence = DG.Tweening.DOTween.Sequence() local tween = DG.Tweening.DOTween.To( DG.Tweening.Core.DOSetter_float( ...
lua 基于C#DOTween 插件封装的 utils.animation库 (类似于 animation.css库)
pigsohappy的博客
10-24 661
导语 之前接触过还在做web的时候接触过Animation.css库，在现在转行做Unity之后，lua 代码开发成了一种主流（C#无法被替代），每次针对动画需求就会进行费事费力的动画编辑，我就自己封装了几种常用的动画类型，不用改变一开始就去修改预设体，方便后期的优化，调用方法也是比较方便的，基于DOTween的队列动画思路，分步骤实现动画。 具体实现（需要向动画节点添加一个） --动画第一阶段 ...
unity UGUI + DOTween + lua（xlua）实现跑马灯效果
对酒当歌﹏✍
01-29 5560
目录1、引言2、实现过程2.1、制作预制体2.2、代码实现2.3、效果展现3、结束语 1、引言   上一篇我们给出了cocos的跑马灯实现方法，这里借助上一篇来用unity实现跑马灯效果，具体原理参照上一篇内容，这里是传送门跑马灯原理分析。 2、实现过程   具体实现包括以下步骤。 2.1、制作预制体   这里的素材只需要一张图就可以了。我也上传了吧，需要尝试的同学，可以拿去试一试。 有了背景，我...
cocos creator FairyGUI（Gtween动画的使用）
weixin_44235418的博客
12-17 4801
最近编写剧情，用到了Gtween动画，用于改变透明度、位置、缩放、颜色，还有对Gtween动画的加速和销毁 （1）改变组件透明度 fgui.GTween.to(0, 1, time) .setTarget(this.ui, alpha) .setEase(fgui.EaseType.CubicOut).onComplete(() => { //透明度改变完成 }, this); （2）改变位...
DoTween的使用
weixin_34233618的博客
10-14 140
---恢复内容开始--- 1.butten的时候飞出图片再点击飞回去，要飞回去就的加上圈出的代码 因为飞进来的时候被销毁了，要保存他们 2.使用DOPlayForward()播放 优化了上边的代码 利用暂停不让他销毁 3.FromTween 3.1单个方向的移动 3.2 4.常用的方法 4.1控制动画曲线 4.2循环次数 0是播放一次 4.5动画结束后做什么呢 5.动画...
关于在Xlua中使用DoTween插件的拓展方法（包括UGUI模块方法）
这里是老举温抖的博客，主要面向Unity
12-26 1145
在Xlua中使用Dotween插件，包括UGUI拓展方法
xlua控制物体移动和旋转的两种方法
weixin_45554040的博客
09-08 1830
第一种方法 lua脚本 function e() H=CS.UnityEngine.Input.GetAxis(“Horizontal”) V=CS.UnityEngine.Input.GetAxis(“Vertical”) CS.UnityEngine.GameObject.Find(“Cube”).transform:Rotate(CS.UnityEngine.Vector3(0,H,0)) ...
[转]DOTween教程☀️DOTween的使用教程
小小姑娘
12-26 3370
将某点在一定时间内移动到某点要移动的初始值 目标值 时间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值