C# 클래스 LeanTween, LeanTween

상속: MonoBehaviour
파일 보기 프로젝트 열기: dentedpixel/LeanTween 1 사용 예제들

공개 프로퍼티들

프로퍼티 타입 설명
EVENTS_MAX int
LISTENERS_MAX int
PI_DIV2 float
d LTDescr,
dtActual float
dtEstimated float
dtManual float
punch UnityEngine.AnimationCurve
shake UnityEngine.AnimationCurve
startSearch int
tau float
throwErrors bool

공개 메소드들

메소드 설명
OnLevelWasLoaded ( int lvl ) : void
Update ( ) : void
add ( Vector3 a, Vector3 b ) : Vector3[]
addListener ( GameObject caller, int eventId, System callback ) : void
addListener ( int eventId, System callback ) : void
alpha ( GameObject gameObject, float to, float time ) : LTDescr,
alpha ( LTRect, ltRect, float to, float time ) : LTDescr,
alpha ( RectTransform rectTrans, float to, float time ) : LTDescr,
alphaCanvas ( CanvasGroup canvasGroup, float to, float time ) : LTDescr,
alphaText ( RectTransform rectTransform, float to, float time ) : LTDescr,
alphaVertex ( GameObject gameObject, float to, float time ) : LTDescr,
cancel ( GameObject gameObject ) : void
cancel ( GameObject gameObject, bool callOnComplete ) : void
cancel ( GameObject gameObject, int uniqueId, bool callOnComplete = false ) : void
cancel ( LTRect, ltRect, int uniqueId ) : void
cancel ( RectTransform rect ) : void
cancel ( int uniqueId ) : void
cancel ( int uniqueId, bool callOnComplete ) : void
cancelAll ( ) : void
cancelAll ( bool callComplete ) : void
clerp ( float start, float end, float val ) : float
closestRot ( float from, float to ) : float
color ( GameObject gameObject, Color to, float time ) : LTDescr,
color ( RectTransform rectTrans, Color to, float time ) : LTDescr,
colorText ( RectTransform rectTransform, Color to, float time ) : LTDescr,
delayedCall ( GameObject gameObject, float delayTime, Action callback ) : LTDescr,
delayedCall ( GameObject gameObject, float delayTime, Action callback ) : LTDescr,
delayedCall ( float delayTime, Action callback ) : LTDescr,
delayedCall ( float delayTime, Action callback ) : LTDescr,
delayedSound ( AudioClip audio, Vector3 pos, float volume ) : LTDescr,
delayedSound ( GameObject gameObject, AudioClip audio, Vector3 pos, float volume ) : LTDescr,
descr ( int uniqueId ) : LTDescr,
description ( int uniqueId ) : LTDescr,
descriptions ( GameObject gameObject = null ) : LTDescr[],
destroyAfter ( LTRect, rect, float delayTime ) : LTDescr,
dispatchEvent ( int eventId ) : void
dispatchEvent ( int eventId, object data ) : void
drawBezierPath ( Vector3 a, Vector3 b, Vector3 c, Vector3 d, float arrowSize = 0.0f, Transform arrowTransform = null ) : void
easeInBack ( float start, float end, float val, float overshoot = 1.0f ) : float
easeInBounce ( float start, float end, float val ) : float
easeInCirc ( float start, float end, float val ) : float
easeInCubic ( float start, float end, float val ) : float
easeInElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
easeInExpo ( float start, float end, float val ) : float
easeInOutBack ( float start, float end, float val, float overshoot = 1.0f ) : float
easeInOutBounce ( float start, float end, float val ) : float
easeInOutCirc ( float start, float end, float val ) : float
easeInOutCubic ( float start, float end, float val ) : float
easeInOutElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
easeInOutExpo ( float start, float end, float val ) : float
easeInOutQuad ( float start, float end, float val ) : float
easeInOutQuadOpt ( Vector3 start, Vector3 diff, float ratioPassed ) : Vector3
easeInOutQuadOpt ( float start, float diff, float ratioPassed ) : float
easeInOutQuadOpt2 ( float start, float diffBy2, float val, float val2 ) : float
easeInOutQuart ( float start, float end, float val ) : float
easeInOutQuint ( float start, float end, float val ) : float
easeInOutSine ( float start, float end, float val ) : float
easeInQuad ( float start, float end, float val ) : float
easeInQuadOpt ( float start, float diff, float ratioPassed ) : float
easeInQuart ( float start, float end, float val ) : float
easeInQuint ( float start, float end, float val ) : float
easeInSine ( float start, float end, float val ) : float
easeOutBack ( float start, float end, float val, float overshoot = 1.0f ) : float
easeOutBounce ( float start, float end, float val ) : float
easeOutCirc ( float start, float end, float val ) : float
easeOutCubic ( float start, float end, float val ) : float
easeOutElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
easeOutExpo ( float start, float end, float val ) : float
easeOutQuad ( float start, float end, float val ) : float
easeOutQuadOpt ( float start, float diff, float ratioPassed ) : float
easeOutQuart ( float start, float end, float val ) : float
easeOutQuint ( float start, float end, float val ) : float
easeOutSine ( float start, float end, float val ) : float
init ( ) : void
init ( int maxSimultaneousTweens ) : void
isTweening ( GameObject gameObject = null ) : bool
isTweening ( LTRect, ltRect ) : bool
isTweening ( RectTransform rect ) : bool
isTweening ( int uniqueId ) : bool
linear ( float start, float end, float val ) : float
logError ( string error ) : object
move ( GameObject gameObject, LTBezierPath, to, float time ) : LTDescr,
move ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
move ( GameObject gameObject, Transform to, float time ) : LTDescr,
move ( GameObject gameObject, Vector2 to, float time ) : LTDescr,
move ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
move ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
move ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
moveLocal ( GameObject gameObject, LTBezierPath, to, float time ) : LTDescr,
moveLocal ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
moveLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
moveLocalX ( GameObject gameObject, float to, float time ) : LTDescr,
moveLocalY ( GameObject gameObject, float to, float time ) : LTDescr,
moveLocalZ ( GameObject gameObject, float to, float time ) : LTDescr,
moveMargin ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
moveSpline ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
moveSpline ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
moveSplineLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
moveX ( GameObject gameObject, float to, float time ) : LTDescr,
moveX ( RectTransform rectTrans, float to, float time ) : LTDescr,
moveY ( GameObject gameObject, float to, float time ) : LTDescr,
moveY ( RectTransform rectTrans, float to, float time ) : LTDescr,
moveZ ( GameObject gameObject, float to, float time ) : LTDescr,
moveZ ( RectTransform rectTrans, float to, float time ) : LTDescr,
options ( ) : LTDescr,
options ( LTDescr, seed ) : LTDescr,
pause ( GameObject gameObject ) : void
pause ( int uniqueId ) : void
pauseAll ( ) : void
play ( RectTransform rectTransform, UnityEngine sprites ) : LTDescr,
removeListener ( GameObject caller, int eventId, System callback ) : bool
removeListener ( int eventId, System callback ) : bool
removeTween ( int i ) : void
removeTween ( int i, int uniqueId ) : void
reset ( ) : void
resume ( GameObject gameObject ) : void
resume ( int uniqueId ) : void
resumeAll ( ) : void
rotate ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
rotate ( LTRect, ltRect, float to, float time ) : LTDescr,
rotate ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
rotate ( RectTransform rectTrans, float to, float time ) : LTDescr,
rotateAround ( GameObject gameObject, Vector3 axis, float add, float time ) : LTDescr,
rotateAround ( RectTransform rectTrans, Vector3 axis, float to, float time ) : LTDescr,
rotateAroundLocal ( GameObject gameObject, Vector3 axis, float add, float time ) : LTDescr,
rotateAroundLocal ( RectTransform rectTrans, Vector3 axis, float to, float time ) : LTDescr,
rotateLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
rotateX ( GameObject gameObject, float to, float time ) : LTDescr,
rotateY ( GameObject gameObject, float to, float time ) : LTDescr,
rotateZ ( GameObject gameObject, float to, float time ) : LTDescr,
scale ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
scale ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
scale ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
scaleX ( GameObject gameObject, float to, float time ) : LTDescr,
scaleY ( GameObject gameObject, float to, float time ) : LTDescr,
scaleZ ( GameObject gameObject, float to, float time ) : LTDescr,
size ( RectTransform rectTrans, Vector2 to, float time ) : LTDescr,
spring ( float start, float end, float val ) : float
textAlpha ( RectTransform rectTransform, float to, float time ) : LTDescr,
textColor ( RectTransform rectTransform, Color to, float time ) : LTDescr,
tweenOnCurve ( LTDescr tweenDescr, float ratioPassed ) : float
tweenOnCurveVector ( LTDescr tweenDescr, float ratioPassed ) : Vector3
update ( ) : void
value ( GameObject gameObject, object>.Action callOnUpdate, Color from, Color to, float time ) : LTDescr
value ( GameObject gameObject, Action callOnUpdate, Color from, Color to, float time ) : LTDescr
value ( GameObject gameObject, Action callOnUpdate, Vector2 from, Vector2 to, float time ) : LTDescr
value ( GameObject gameObject, Action callOnUpdate, Vector3 from, Vector3 to, float time ) : LTDescr
value ( GameObject gameObject, float>.Action callOnUpdateRatio, float from, float to, float time ) : LTDescr
value ( GameObject gameObject, object>.Action callOnUpdate, float from, float to, float time ) : LTDescr
value ( GameObject gameObject, Action callOnUpdate, float from, float to, float time ) : LTDescr
value ( GameObject gameObject, Color from, Color to, float time ) : LTDescr
value ( GameObject gameObject, Vector2 from, Vector2 to, float time ) : LTDescr
value ( GameObject gameObject, Vector3 from, Vector3 to, float time ) : LTDescr
value ( GameObject gameObject, float from, float to, float time ) : LTDescr
value ( float from, float to, float time ) : LTDescr

비공개 메소드들

메소드 설명
internalOnLevelWasLoaded ( int lvl ) : void
onLevelWasLoaded54 ( UnityEngine scene, UnityEngine mode ) : void
pause ( GameObject gameObject, int uniqueId ) : void
pushNewTween ( GameObject gameObject, Vector3 to, float time, LTDescr, tween ) : LTDescr,
resume ( GameObject gameObject, int uniqueId ) : void

메소드 상세

OnLevelWasLoaded() 공개 메소드

public OnLevelWasLoaded ( int lvl ) : void
lvl int
리턴 void

Update() 공개 메소드

public Update ( ) : void
리턴 void

add() 공개 정적인 메소드

public static add ( Vector3 a, Vector3 b ) : Vector3[]
a Vector3
b Vector3
리턴 Vector3[]

addListener() 공개 정적인 메소드

public static addListener ( GameObject caller, int eventId, System callback ) : void
caller GameObject
eventId int
callback System
리턴 void

addListener() 공개 정적인 메소드

public static addListener ( int eventId, System callback ) : void
eventId int
callback System
리턴 void

alpha() 공개 정적인 메소드

public static alpha ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

alpha() 공개 정적인 메소드

public static alpha ( LTRect, ltRect, float to, float time ) : LTDescr,
ltRect LTRect,
to float
time float
리턴 LTDescr,

alpha() 공개 정적인 메소드

public static alpha ( RectTransform rectTrans, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

alphaCanvas() 공개 정적인 메소드

public static alphaCanvas ( CanvasGroup canvasGroup, float to, float time ) : LTDescr,
canvasGroup UnityEngine.CanvasGroup
to float
time float
리턴 LTDescr,

alphaText() 공개 정적인 메소드

public static alphaText ( RectTransform rectTransform, float to, float time ) : LTDescr,
rectTransform UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

alphaVertex() 공개 정적인 메소드

public static alphaVertex ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

cancel() 공개 정적인 메소드

public static cancel ( GameObject gameObject ) : void
gameObject GameObject
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( GameObject gameObject, bool callOnComplete ) : void
gameObject GameObject
callOnComplete bool
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( GameObject gameObject, int uniqueId, bool callOnComplete = false ) : void
gameObject GameObject
uniqueId int
callOnComplete bool
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( LTRect, ltRect, int uniqueId ) : void
ltRect LTRect,
uniqueId int
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( RectTransform rect ) : void
rect UnityEngine.RectTransform
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( int uniqueId ) : void
uniqueId int
리턴 void

cancel() 공개 정적인 메소드

public static cancel ( int uniqueId, bool callOnComplete ) : void
uniqueId int
callOnComplete bool
리턴 void

cancelAll() 공개 정적인 메소드

public static cancelAll ( ) : void
리턴 void

cancelAll() 공개 정적인 메소드

public static cancelAll ( bool callComplete ) : void
callComplete bool
리턴 void

clerp() 공개 정적인 메소드

public static clerp ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

closestRot() 공개 정적인 메소드

public static closestRot ( float from, float to ) : float
from float
to float
리턴 float

color() 공개 정적인 메소드

public static color ( GameObject gameObject, Color to, float time ) : LTDescr,
gameObject GameObject
to Color
time float
리턴 LTDescr,

color() 공개 정적인 메소드

public static color ( RectTransform rectTrans, Color to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to Color
time float
리턴 LTDescr,

colorText() 공개 정적인 메소드

public static colorText ( RectTransform rectTransform, Color to, float time ) : LTDescr,
rectTransform UnityEngine.RectTransform
to Color
time float
리턴 LTDescr,

delayedCall() 공개 정적인 메소드

public static delayedCall ( GameObject gameObject, float delayTime, Action callback ) : LTDescr,
gameObject GameObject
delayTime float
callback Action
리턴 LTDescr,

delayedCall() 공개 정적인 메소드

public static delayedCall ( GameObject gameObject, float delayTime, Action callback ) : LTDescr,
gameObject GameObject
delayTime float
callback Action
리턴 LTDescr,

delayedCall() 공개 정적인 메소드

public static delayedCall ( float delayTime, Action callback ) : LTDescr,
delayTime float
callback Action
리턴 LTDescr,

delayedCall() 공개 정적인 메소드

public static delayedCall ( float delayTime, Action callback ) : LTDescr,
delayTime float
callback Action
리턴 LTDescr,

delayedSound() 공개 정적인 메소드

public static delayedSound ( AudioClip audio, Vector3 pos, float volume ) : LTDescr,
audio UnityEngine.AudioClip
pos Vector3
volume float
리턴 LTDescr,

delayedSound() 공개 정적인 메소드

public static delayedSound ( GameObject gameObject, AudioClip audio, Vector3 pos, float volume ) : LTDescr,
gameObject GameObject
audio UnityEngine.AudioClip
pos Vector3
volume float
리턴 LTDescr,

descr() 공개 정적인 메소드

public static descr ( int uniqueId ) : LTDescr,
uniqueId int
리턴 LTDescr,

description() 공개 정적인 메소드

public static description ( int uniqueId ) : LTDescr,
uniqueId int
리턴 LTDescr,

descriptions() 공개 정적인 메소드

public static descriptions ( GameObject gameObject = null ) : LTDescr[],
gameObject GameObject
리턴 LTDescr[],

destroyAfter() 공개 정적인 메소드

public static destroyAfter ( LTRect, rect, float delayTime ) : LTDescr,
rect LTRect,
delayTime float
리턴 LTDescr,

dispatchEvent() 공개 정적인 메소드

public static dispatchEvent ( int eventId ) : void
eventId int
리턴 void

dispatchEvent() 공개 정적인 메소드

public static dispatchEvent ( int eventId, object data ) : void
eventId int
data object
리턴 void

drawBezierPath() 공개 정적인 메소드

public static drawBezierPath ( Vector3 a, Vector3 b, Vector3 c, Vector3 d, float arrowSize = 0.0f, Transform arrowTransform = null ) : void
a Vector3
b Vector3
c Vector3
d Vector3
arrowSize float
arrowTransform Transform
리턴 void

easeInBack() 공개 정적인 메소드

public static easeInBack ( float start, float end, float val, float overshoot = 1.0f ) : float
start float
end float
val float
overshoot float
리턴 float

easeInBounce() 공개 정적인 메소드

public static easeInBounce ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInCirc() 공개 정적인 메소드

public static easeInCirc ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInCubic() 공개 정적인 메소드

public static easeInCubic ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInElastic() 공개 정적인 메소드

public static easeInElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
start float
end float
val float
overshoot float
period float
리턴 float

easeInExpo() 공개 정적인 메소드

public static easeInExpo ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutBack() 공개 정적인 메소드

public static easeInOutBack ( float start, float end, float val, float overshoot = 1.0f ) : float
start float
end float
val float
overshoot float
리턴 float

easeInOutBounce() 공개 정적인 메소드

public static easeInOutBounce ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutCirc() 공개 정적인 메소드

public static easeInOutCirc ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutCubic() 공개 정적인 메소드

public static easeInOutCubic ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutElastic() 공개 정적인 메소드

public static easeInOutElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
start float
end float
val float
overshoot float
period float
리턴 float

easeInOutExpo() 공개 정적인 메소드

public static easeInOutExpo ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutQuad() 공개 정적인 메소드

public static easeInOutQuad ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutQuadOpt() 공개 정적인 메소드

public static easeInOutQuadOpt ( Vector3 start, Vector3 diff, float ratioPassed ) : Vector3
start Vector3
diff Vector3
ratioPassed float
리턴 Vector3

easeInOutQuadOpt() 공개 정적인 메소드

public static easeInOutQuadOpt ( float start, float diff, float ratioPassed ) : float
start float
diff float
ratioPassed float
리턴 float

easeInOutQuadOpt2() 공개 정적인 메소드

public static easeInOutQuadOpt2 ( float start, float diffBy2, float val, float val2 ) : float
start float
diffBy2 float
val float
val2 float
리턴 float

easeInOutQuart() 공개 정적인 메소드

public static easeInOutQuart ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutQuint() 공개 정적인 메소드

public static easeInOutQuint ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInOutSine() 공개 정적인 메소드

public static easeInOutSine ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInQuad() 공개 정적인 메소드

public static easeInQuad ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInQuadOpt() 공개 정적인 메소드

public static easeInQuadOpt ( float start, float diff, float ratioPassed ) : float
start float
diff float
ratioPassed float
리턴 float

easeInQuart() 공개 정적인 메소드

public static easeInQuart ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInQuint() 공개 정적인 메소드

public static easeInQuint ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeInSine() 공개 정적인 메소드

public static easeInSine ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutBack() 공개 정적인 메소드

public static easeOutBack ( float start, float end, float val, float overshoot = 1.0f ) : float
start float
end float
val float
overshoot float
리턴 float

easeOutBounce() 공개 정적인 메소드

public static easeOutBounce ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutCirc() 공개 정적인 메소드

public static easeOutCirc ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutCubic() 공개 정적인 메소드

public static easeOutCubic ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutElastic() 공개 정적인 메소드

public static easeOutElastic ( float start, float end, float val, float overshoot = 1.0f, float period = 0.3f ) : float
start float
end float
val float
overshoot float
period float
리턴 float

easeOutExpo() 공개 정적인 메소드

public static easeOutExpo ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutQuad() 공개 정적인 메소드

public static easeOutQuad ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutQuadOpt() 공개 정적인 메소드

public static easeOutQuadOpt ( float start, float diff, float ratioPassed ) : float
start float
diff float
ratioPassed float
리턴 float

easeOutQuart() 공개 정적인 메소드

public static easeOutQuart ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutQuint() 공개 정적인 메소드

public static easeOutQuint ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

easeOutSine() 공개 정적인 메소드

public static easeOutSine ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

init() 공개 정적인 메소드

public static init ( ) : void
리턴 void

init() 공개 정적인 메소드

public static init ( int maxSimultaneousTweens ) : void
maxSimultaneousTweens int
리턴 void

isTweening() 공개 정적인 메소드

public static isTweening ( GameObject gameObject = null ) : bool
gameObject GameObject
리턴 bool

isTweening() 공개 정적인 메소드

public static isTweening ( LTRect, ltRect ) : bool
ltRect LTRect,
리턴 bool

isTweening() 공개 정적인 메소드

public static isTweening ( RectTransform rect ) : bool
rect UnityEngine.RectTransform
리턴 bool

isTweening() 공개 정적인 메소드

public static isTweening ( int uniqueId ) : bool
uniqueId int
리턴 bool

linear() 공개 정적인 메소드

public static linear ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

logError() 공개 정적인 메소드

public static logError ( string error ) : object
error string
리턴 object

move() 공개 정적인 메소드

public static move ( GameObject gameObject, LTBezierPath, to, float time ) : LTDescr,
gameObject GameObject
to LTBezierPath,
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
gameObject GameObject
to LTSpline,
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( GameObject gameObject, Transform to, float time ) : LTDescr,
gameObject GameObject
to Transform
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( GameObject gameObject, Vector2 to, float time ) : LTDescr,
gameObject GameObject
to Vector2
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
ltRect LTRect,
to Vector2
time float
리턴 LTDescr,

move() 공개 정적인 메소드

public static move ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to Vector3
time float
리턴 LTDescr,

moveLocal() 공개 정적인 메소드

public static moveLocal ( GameObject gameObject, LTBezierPath, to, float time ) : LTDescr,
gameObject GameObject
to LTBezierPath,
time float
리턴 LTDescr,

moveLocal() 공개 정적인 메소드

public static moveLocal ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
gameObject GameObject
to LTSpline,
time float
리턴 LTDescr,

moveLocal() 공개 정적인 메소드

public static moveLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

moveLocalX() 공개 정적인 메소드

public static moveLocalX ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveLocalY() 공개 정적인 메소드

public static moveLocalY ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveLocalZ() 공개 정적인 메소드

public static moveLocalZ ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveMargin() 공개 정적인 메소드

public static moveMargin ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
ltRect LTRect,
to Vector2
time float
리턴 LTDescr,

moveSpline() 공개 정적인 메소드

public static moveSpline ( GameObject gameObject, LTSpline, to, float time ) : LTDescr,
gameObject GameObject
to LTSpline,
time float
리턴 LTDescr,

moveSpline() 공개 정적인 메소드

public static moveSpline ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

moveSplineLocal() 공개 정적인 메소드

public static moveSplineLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

moveX() 공개 정적인 메소드

public static moveX ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveX() 공개 정적인 메소드

public static moveX ( RectTransform rectTrans, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

moveY() 공개 정적인 메소드

public static moveY ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveY() 공개 정적인 메소드

public static moveY ( RectTransform rectTrans, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

moveZ() 공개 정적인 메소드

public static moveZ ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

moveZ() 공개 정적인 메소드

public static moveZ ( RectTransform rectTrans, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

options() 공개 정적인 메소드

public static options ( ) : LTDescr,
리턴 LTDescr,

options() 공개 정적인 메소드

public static options ( LTDescr, seed ) : LTDescr,
seed LTDescr,
리턴 LTDescr,

pause() 공개 정적인 메소드

public static pause ( GameObject gameObject ) : void
gameObject GameObject
리턴 void

pause() 공개 정적인 메소드

public static pause ( int uniqueId ) : void
uniqueId int
리턴 void

pauseAll() 공개 정적인 메소드

public static pauseAll ( ) : void
리턴 void

play() 공개 정적인 메소드

public static play ( RectTransform rectTransform, UnityEngine sprites ) : LTDescr,
rectTransform UnityEngine.RectTransform
sprites UnityEngine
리턴 LTDescr,

removeListener() 공개 정적인 메소드

public static removeListener ( GameObject caller, int eventId, System callback ) : bool
caller GameObject
eventId int
callback System
리턴 bool

removeListener() 공개 정적인 메소드

public static removeListener ( int eventId, System callback ) : bool
eventId int
callback System
리턴 bool

removeTween() 공개 정적인 메소드

public static removeTween ( int i ) : void
i int
리턴 void

removeTween() 공개 정적인 메소드

public static removeTween ( int i, int uniqueId ) : void
i int
uniqueId int
리턴 void

reset() 공개 정적인 메소드

public static reset ( ) : void
리턴 void

resume() 공개 정적인 메소드

public static resume ( GameObject gameObject ) : void
gameObject GameObject
리턴 void

resume() 공개 정적인 메소드

public static resume ( int uniqueId ) : void
uniqueId int
리턴 void

resumeAll() 공개 정적인 메소드

public static resumeAll ( ) : void
리턴 void

rotate() 공개 정적인 메소드

public static rotate ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

rotate() 공개 정적인 메소드

public static rotate ( LTRect, ltRect, float to, float time ) : LTDescr,
ltRect LTRect,
to float
time float
리턴 LTDescr,

rotate() 공개 정적인 메소드

public static rotate ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to Vector3
time float
리턴 LTDescr,

rotate() 공개 정적인 메소드

public static rotate ( RectTransform rectTrans, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

rotateAround() 공개 정적인 메소드

public static rotateAround ( GameObject gameObject, Vector3 axis, float add, float time ) : LTDescr,
gameObject GameObject
axis Vector3
add float
time float
리턴 LTDescr,

rotateAround() 공개 정적인 메소드

public static rotateAround ( RectTransform rectTrans, Vector3 axis, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
axis Vector3
to float
time float
리턴 LTDescr,

rotateAroundLocal() 공개 정적인 메소드

public static rotateAroundLocal ( GameObject gameObject, Vector3 axis, float add, float time ) : LTDescr,
gameObject GameObject
axis Vector3
add float
time float
리턴 LTDescr,

rotateAroundLocal() 공개 정적인 메소드

public static rotateAroundLocal ( RectTransform rectTrans, Vector3 axis, float to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
axis Vector3
to float
time float
리턴 LTDescr,

rotateLocal() 공개 정적인 메소드

public static rotateLocal ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

rotateX() 공개 정적인 메소드

public static rotateX ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

rotateY() 공개 정적인 메소드

public static rotateY ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

rotateZ() 공개 정적인 메소드

public static rotateZ ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

scale() 공개 정적인 메소드

public static scale ( GameObject gameObject, Vector3 to, float time ) : LTDescr,
gameObject GameObject
to Vector3
time float
리턴 LTDescr,

scale() 공개 정적인 메소드

public static scale ( LTRect, ltRect, Vector2 to, float time ) : LTDescr,
ltRect LTRect,
to Vector2
time float
리턴 LTDescr,

scale() 공개 정적인 메소드

public static scale ( RectTransform rectTrans, Vector3 to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to Vector3
time float
리턴 LTDescr,

scaleX() 공개 정적인 메소드

public static scaleX ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

scaleY() 공개 정적인 메소드

public static scaleY ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

scaleZ() 공개 정적인 메소드

public static scaleZ ( GameObject gameObject, float to, float time ) : LTDescr,
gameObject GameObject
to float
time float
리턴 LTDescr,

size() 공개 정적인 메소드

public static size ( RectTransform rectTrans, Vector2 to, float time ) : LTDescr,
rectTrans UnityEngine.RectTransform
to Vector2
time float
리턴 LTDescr,

spring() 공개 정적인 메소드

public static spring ( float start, float end, float val ) : float
start float
end float
val float
리턴 float

textAlpha() 공개 정적인 메소드

public static textAlpha ( RectTransform rectTransform, float to, float time ) : LTDescr,
rectTransform UnityEngine.RectTransform
to float
time float
리턴 LTDescr,

textColor() 공개 정적인 메소드

public static textColor ( RectTransform rectTransform, Color to, float time ) : LTDescr,
rectTransform UnityEngine.RectTransform
to Color
time float
리턴 LTDescr,

tweenOnCurve() 공개 정적인 메소드

public static tweenOnCurve ( LTDescr tweenDescr, float ratioPassed ) : float
tweenDescr LTDescr
ratioPassed float
리턴 float

tweenOnCurveVector() 공개 정적인 메소드

public static tweenOnCurveVector ( LTDescr tweenDescr, float ratioPassed ) : Vector3
tweenDescr LTDescr
ratioPassed float
리턴 Vector3

update() 공개 정적인 메소드

public static update ( ) : void
리턴 void

value() 공개 정적인 메소드

public static value ( GameObject gameObject, object>.Action callOnUpdate, Color from, Color to, float time ) : LTDescr
gameObject GameObject
callOnUpdate object>.Action
from Color
to Color
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Action callOnUpdate, Color from, Color to, float time ) : LTDescr
gameObject GameObject
callOnUpdate Action
from Color
to Color
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Action callOnUpdate, Vector2 from, Vector2 to, float time ) : LTDescr
gameObject GameObject
callOnUpdate Action
from Vector2
to Vector2
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Action callOnUpdate, Vector3 from, Vector3 to, float time ) : LTDescr
gameObject GameObject
callOnUpdate Action
from Vector3
to Vector3
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, float>.Action callOnUpdateRatio, float from, float to, float time ) : LTDescr
gameObject GameObject
callOnUpdateRatio float>.Action
from float
to float
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, object>.Action callOnUpdate, float from, float to, float time ) : LTDescr
gameObject GameObject
callOnUpdate object>.Action
from float
to float
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Action callOnUpdate, float from, float to, float time ) : LTDescr
gameObject GameObject
callOnUpdate Action
from float
to float
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Color from, Color to, float time ) : LTDescr
gameObject GameObject
from Color
to Color
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Vector2 from, Vector2 to, float time ) : LTDescr
gameObject GameObject
from Vector2
to Vector2
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, Vector3 from, Vector3 to, float time ) : LTDescr
gameObject GameObject
from Vector3
to Vector3
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( GameObject gameObject, float from, float to, float time ) : LTDescr
gameObject GameObject
from float
to float
time float
리턴 LTDescr

value() 공개 정적인 메소드

public static value ( float from, float to, float time ) : LTDescr
from float
to float
time float
리턴 LTDescr

프로퍼티 상세

EVENTS_MAX 공개적으로 정적으로 프로퍼티

public static int EVENTS_MAX
리턴 int

LISTENERS_MAX 공개적으로 정적으로 프로퍼티

public static int LISTENERS_MAX
리턴 int

PI_DIV2 공개적으로 정적으로 프로퍼티

public static float PI_DIV2
리턴 float

d 공개적으로 정적으로 프로퍼티

public static LTDescr, d
리턴 LTDescr,

dtActual 공개적으로 정적으로 프로퍼티

public static float dtActual
리턴 float

dtEstimated 공개적으로 정적으로 프로퍼티

public static float dtEstimated
리턴 float

dtManual 공개적으로 정적으로 프로퍼티

public static float dtManual
리턴 float

punch 공개적으로 정적으로 프로퍼티

public static AnimationCurve,UnityEngine punch
리턴 UnityEngine.AnimationCurve

shake 공개적으로 정적으로 프로퍼티

public static AnimationCurve,UnityEngine shake
리턴 UnityEngine.AnimationCurve

startSearch 공개적으로 정적으로 프로퍼티

public static int startSearch
리턴 int

tau 공개적으로 정적으로 프로퍼티

public static float tau
리턴 float

throwErrors 공개적으로 정적으로 프로퍼티

public static bool throwErrors
리턴 bool