> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-ko/sdk7/3d/move-entities.md).

# 엔티티 이동

점진적인 변경을 통해 엔티티를 시간에 따라 서서히 이동, 회전, 크기 조정하는 방법.

장면에서 엔티티를 일정 시간 동안 이동, 회전 또는 크기 조정하려면 `Tween`  컴포넌트를 사용하세요. 엔진은 지정한 시간이 끝날 때까지 매 프레임 업데이트를 표시하며 원하는 변환을 부드럽게 수행합니다. 또한 장면 코드에서 필요한 경우 근접 여부를 확인할 수 있도록 영향을 받는 엔티티의 `Transform` 컴포넌트 값도 실시간으로 업데이트됩니다.

{% hint style="info" %}
**💡 팁**: [Creator Hub의 Scene Editor](https://docs.decentraland.org/creator/content-creator-ko/scene-editor/get-started/about-editor.md)에서는 코드 없이 **작업**을 통해 엔티티를 이동할 수 있습니다. 자세한 내용은 [모든 항목을 스마트하게 만들기](https://docs.decentraland.org/creator/content-creator-ko/scene-editor/interactivity/make-any-item-smart.md).
{% endhint %}

Tween 컴포넌트에는 다음 함수가 있습니다.

* `setMove`: 두 점 사이에서 이동
* `setRotate`: 두 방향 사이에서 회전
* `setScale`: 두 크기 사이에서 크기 조정
* `setMoveRotateScale`: 세 매개변수를 동시에 전환
* `setMoveContinuous`: 같은 방향으로 계속 이동
* `setRotateContinuous`: 같은 방향으로 계속 회전
* `setTextureMove`: 재질의 텍스처를 두 위치 사이에서 오프셋
* `setTextureMoveContinuous`: 재질의 텍스처를 같은 방향으로 계속 오프셋

## 두 점 사이에서 이동

두 점 사이에서 엔티티를 이동하려면 `Tween` 컴포넌트를 만들고 `setMove` 함수를 사용합니다.

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)

Tween.setMove(myEntity, 
	Vector3.create(1, 1, 1), 
	Vector3.create(8, 1, 8), 
	2000
)
```

이동 트윈에는 다음 정보가 필요합니다.

* `entity`: 이동할 엔티티
* `start`: 시작 위치를 나타내는 Vector3
* `end`: 끝 위치를 나타내는 Vector3
* `duration`: 두 위치 사이를 이동하는 데 걸리는 시간(밀리초)

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `easingFunction`: 사용할 이징 함수입니다. 자세한 내용은 [비선형 트윈](#non-linear-tweens)

## 두 방향 사이에서 회전하기

엔티티를 두 지점 사이에서 회전시키려면 다음을 사용해 `Tween` 컴포넌트를 만들고 `setRotate` 함수를 호출합니다.

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)

Tween.setRotate(myEntity, 
	Quaternion.fromEulerDegrees(0, 0, 0), 
	Quaternion.fromEulerDegrees(0, 170, 0), 
	700
)
```

회전 트윈에는 다음 정보가 필요합니다:

* `start`: 시작 회전을 나타내는 Quaternion
* `end`: 종료 회전을 나타내는 Quaternion
* `duration`: 두 위치 사이를 이동하는 데 걸리는 시간(밀리초)

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `easingFunction`: 사용할 이징 함수입니다. 자세한 내용은 [비선형 트윈](#non-linear-tweens)

### 피벗 지점을 기준으로 회전하기

엔티티를 회전할 때 회전은 항상 엔티티 중심 좌표를 기준으로 합니다. 다른 좌표를 피벗 지점으로 사용해 엔티티를 회전하려면 피벗 지점을 위치로 하는 두 번째(보이지 않는) 엔티티를 만들고, 회전하려는 엔티티의 부모로 지정합니다.

부모 엔티티를 회전하면 모든 자식 엔티티는 부모의 위치를 피벗 지점으로 삼아 함께 회전합니다. 자식 엔티티의 `position` 은 부모 엔티티를 기준으로 한다는 점에 유의하세요.

```ts
const pivotEntity = engine.addEntity()
Transform.create(pivotEntity, {
	position: Vector3.create(4, 1, 4),
})

const childEntity = engine.addEntity()
Transform.create(childEntity, {
	position: Vector3.create(1, 0, 0),
	parent: pivotEntity,
})
MeshRenderer.setBox(childEntity)

Tween.setRotate(pivotEntity, 
	Quaternion.fromEulerDegrees(0, 0, 0), 
	Quaternion.fromEulerDegrees(0, 170, 0), 
	700
)
```

이 예제에서는 시스템이 다음 엔티티를 회전합니다. `pivotEntity` 이 엔티티는 다음 엔티티의 부모입니다. `childEntity` .

## 두 크기 사이에서 스케일 변경하기

엔티티의 스케일을 두 크기 사이에서 변경하려면 다음을 사용해 `Tween` 컴포넌트를 만들고 `setScale` 함수를 호출합니다.

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)

Tween.setScale(myEntity, 
	Vector3.create(1, 1, 1), 
	Vector3.create(4, 4, 4), 
	2000
)	

```

스케일 트윈에는 다음 정보가 필요합니다:

* `start`: 시작 크기를 나타내는 Vector3
* `end`: 종료 크기를 나타내는 Vector3
* `duration`: 두 위치 사이를 이동하는 데 걸리는 시간(밀리초)

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `easingFunction`: 사용할 이징 함수입니다. 자세한 내용은 [비선형 트윈](#non-linear-tweens)

## 현재 위치에서 이동

트윈이 활성화되어 있는 동안 엔진은 `Transform` 엔티티의 컴포넌트 값을 실시간으로 업데이트합니다. 즉, 언제든지 엔티티의 현재 위치를 해당 `Transform` 컴포넌트에서 읽고 그 값을 새 트윈의 `start` 로 사용할 수 있습니다. 그러면 엔티티는 지금까지 어떤 경로로 왔든 관계없이 현재 위치에서 목표 지점까지 이동합니다.

```ts
pointerEventsSystem.onPointerDown(
	{
		entity: myEntity,
		opts: { button: InputAction.IA_POINTER, hoverText: 'Move' },
	},
	() => {
		Tween.setMove(myEntity, 
			Transform.get(myEntity).position, 
			Vector3.create(8, 1, 8), 
			2000,
			EasingFunction.EF_EASEOUTQUAD
		)
	}
)
```

{% hint style="warning" %}
**📔 참고**: 항상 명시적으로 `start` 값을 전달하세요. 이 `start` 매개변수를 설정하지 않으면 *(0, 0, 0)*&#xB85C; 처리되므로, 이동하기 전에 엔티티가 씬의 원점으로 순간 이동합니다. 마찬가지로 엔티티의 현재 위치와 일치하지 않는 하드코딩된 `start` 값을 전달하면, 이동하기 전에 엔티티가 해당 위치로 눈에 띄게 순간 이동합니다. 이 섹션의 예제처럼 엔티티가 현재 있는 위치에서 이동을 시작하게 하려면 엔티티의 `Transform` 컴포넌트에서 현재 위치를 읽으세요.
{% endhint %}

### 이동 중 목표 변경

이미 트윈이 실행 중인 엔티티에 `setMove` (또는 다른 트윈 함수)를 호출하면 실행 중인 트윈이 새 트윈으로 대체됩니다. 새 트윈의 `start` 값은 엔티티의 실시간 위치에서 가져오므로, 이동 중인 엔티티의 경로를 부드럽게 바꿀 수 있습니다. 순간 이동 없이 그 시점의 위치에서 방향을 바꿉니다.

아래 예제에서는 플레이어가 클릭한 패드로 엔티티를 이동합니다. 엔티티가 이동 중인 동안 플레이어가 다른 패드를 클릭하면 엔티티는 새 목표를 향해 부드럽게 방향을 바꿉니다.

```ts
function moveTo(target: Vector3) {
	Tween.setMove(shipEntity, 
		Transform.get(shipEntity).position, 
		target, 
		2000,
		EasingFunction.EF_EASEOUTQUAD
	)
}

pointerEventsSystem.onPointerDown(
	{
		entity: padA,
		opts: { button: InputAction.IA_POINTER, hoverText: 'Move here' },
	},
	() => moveTo(Vector3.create(2, 1, 2))
)

pointerEventsSystem.onPointerDown(
	{
		entity: padB,
		opts: { button: InputAction.IA_POINTER, hoverText: 'Move here' },
	},
	() => moveTo(Vector3.create(14, 1, 14))
)
```

엔티티가 목적지에 도착했을 때 로직을 실행하려면 [트윈 완료 시](#on-tween-finished).

{% hint style="warning" %}
**📔 참고**: 이 방법으로 목표를 변경하는 것은 클릭이나 웨이포인트 도달처럼 간헐적으로 발생하는 이벤트에만 사용하세요. 플레이어를 따라가는 엔티티처럼 목표가 계속 바뀌는 경우에는 매 프레임 새 트윈을 만들지 마세요. 엔티티가 눈에 띄게 덜컥거리며 움직입니다. 자세한 내용은 [움직이는 목표 따라가기](#follow-a-moving-target).
{% endhint %}

## 비선형 트윈

트윈에는 시간에 따른 변화율을 조절하는 다양한 **이징 함수** 를 사용할 수 있습니다. 예를 들어 **선형** 함수는 시작부터 끝까지 변화 속도가 일정합니다. 시작 부분이나 끝 부분 또는 양쪽 모두에서 속도가 얼마나 느려지는지에 따라 서로 다른 곡선을 만드는 다양한 옵션이 있습니다. 그중 **easeinexpo** 곡선은 초반에는 느리고 후반에는 빠르며 속도가 기하급수적으로 증가합니다. 반대로 **easeoutexpo** 곡선은 빠르게 시작해 느리게 끝납니다.

{% hint style="info" %}
**💡 팁**: 다양한 움직임 곡선을 실험해 보세요. 차이는 미묘한 경우가 많지만, 우리는 사물이 움직이는 방식에서 무게감, 마찰력, 심지어 성격까지 무의식적으로 파악합니다.
{% endhint %}

```ts
Tween.setScale(myEntity, 
	Vector3.create(1, 1, 1), 
	Vector3.create(4, 4, 4), 
	2000,
	EasingFunction.EF_EASEOUTBOUNCE
)

```

선택적 `easingFunction` 매개변수에는 다음 옵션을 제공하는 `EasingFunction` 열거형의 값을 지정합니다.

* `EF_EASEBACK`
* `EF_EASEBOUNCE`
* `EF_EASECIRC`
* `EF_EASECUBIC`
* `EF_EASEELASTIC`
* `EF_EASEEXPO`
* `EF_EASEINBACK`
* `EF_EASEINBOUNCE`
* `EF_EASEINCIRC`
* `EF_EASEINCUBIC`
* `EF_EASEINELASTIC`
* `EF_EASEINEXPO`
* `EF_EASEINQUAD`
* `EF_EASEINQUART`
* `EF_EASEINQUINT`
* `EF_EASEINSINE`
* `EF_EASEOUTBACK`
* `EF_EASEOUTBOUNCE`
* `EF_EASEOUTCIRC`
* `EF_EASEOUTCUBIC`
* `EF_EASEOUTELASTIC`
* `EF_EASEOUTEXPO`
* `EF_EASEOUTQUAD`
* `EF_EASEOUTQUART`
* `EF_EASEOUTQUINT`
* `EF_EASEOUTSINE`
* `EF_EASEQUAD`
* `EF_EASEQUART`
* `EF_EASEQUINT`
* `EF_EASESINE`
* `EF_LINEAR`

## 일정한 회전

엔티티를 계속 회전시키려면 `Tween` 컴포넌트에서 `setRotateContinuous` 함수를 사용합니다.

```ts
Tween.setRotateContinuous(myEntity, 
	Quaternion.fromEulerDegrees(0, -1, 0), 
	45
)
```

연속 회전 트윈에는 다음 정보를 지정해야 합니다.

* `entity`: 회전시킬 엔티티
* `direction`: 회전축을 결정하는 Quaternion입니다. 이 회전에서는 축만 중요하며, 각도의 크기는 무시됩니다. 예를 들어, `Quaternion.fromEulerDegrees(0, -1, 0)` 와 `Quaternion.fromEulerDegrees(0, -90, 0)` 는 동일하게 작동하며, 둘 다 *y* 축을 음의 방향으로 회전합니다.
* `speed`: 엔티티가 초당 회전할 각도입니다. 음수 값은 반대 방향으로 회전합니다.

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `duration`: 회전을 지속할 시간(밀리초)입니다. 이 시간이 지나면 회전이 멈춥니다.

## 일정한 움직임

엔티티를 같은 방향으로 계속 이동시키려면 다음을 사용하세요. `Tween` 컴포넌트와 다음 `setMoveContinuous` 함수를 함께 사용합니다.

```ts
Tween.setMoveContinuous(myEntity, 
	Vector3.create(0, 0, 1), 
	0.7
)
```

연속 이동 트윈에는 다음 정보가 필요합니다.

* `entity`: 이동할 엔티티
* `direction`: 이동 방향을 나타내는 Vector3
* `speed`: 엔티티가 초당 이동할 거리(미터)

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `duration`: 이동을 지속할 시간(밀리초)입니다. 이 시간이 지나면 이동이 멈춥니다.

연속 이동 트윈에는 다음 정보가 필요합니다.

### 움직이는 대상 따라가기

`setMoveContinuous` 는 목적지가 계속 바뀌는 경우에도 적합합니다. 예를 들어 플레이어를 따라가는 엔티티가 이에 해당합니다. 대신 매 프레임마다 플레이어의 최신 위치를 목표로 새 `setMove` 트윈을 만드는 방법을 생각할 수도 있지만, 그렇게 하면 눈에 띄는 끊김이 발생합니다.

그 이유는 트윈이 적용된 엔티티의 `Transform` 컴포넌트에서 읽는 위치가 엔진이 씬에 마지막으로 전달한 위치이기 때문입니다. 따라서 실제 엔티티 위치보다 몇 프레임 뒤처집니다. 이 값을 새 트윈의 `start` 로 전달하면 엔진이 즉시 적용하고, 엔티티는 몇 프레임 전 위치로 되돌아갑니다. 한 번의 보정은 알아차리기 어렵지만, 이를 초당 여러 번 반복하면 눈에 띕니다.

`setMoveContinuous` 는 시작점 대신 방향과 속도를 지정하므로 이 문제를 완전히 방지합니다. 엔진은 엔티티의 실제 위치를 계속 사용하기 때문에 방향을 바꾸려고 트윈을 교체해도 엔티티가 갑자기 이동하지 않습니다.

```ts
const CHASE_SPEED = 3
const STOP_DISTANCE = 1

engine.addSystem(() => {
	const playerPosition = Transform.get(engine.PlayerEntity).position
	const myPosition = Transform.get(myEntity).position

	if (Vector3.distance(myPosition, playerPosition) <= STOP_DISTANCE) {
		// 충분히 가까움: 연속 트윈에는 목적지가 없으므로 직접 중지해야 합니다
		if (Tween.has(myEntity)) {
			Tween.deleteFrom(myEntity)
		}
		반환
	}

	const direction = Vector3.subtract(playerPosition, myPosition)
	direction.y = 0 // 플레이어가 점프해도 지면에 머물도록 합니다

	Tween.setMoveContinuous(myEntity, Vector3.normalize(direction), CHASE_SPEED)
})
```

{% hint style="warning" %}
**📔 참고**: 연속 트윈은 저절로 끝나지 않으므로, 엔터티는 다음을 제거할 때까지 계속 이동합니다. `Tween` 컴포넌트를 다음으로 제거하거나 `Tween.deleteFrom()`, 선택 사항인 `duration` 이 끝날 때까지 계속 이동합니다. 또한 매 프레임마다 조준을 다시 설정하면 매 프레임 엔진에 업데이트가 전송된다는 점에 유의하세요. 이를 방지하려면 방향이 충분히 크게 바뀐 경우에만 `setMoveContinuous` 를 다시 호출하세요.
{% endhint %}

## 트윈 시퀀스

엔터티가 여러 트윈을 차례로 실행하게 하려면 `TweenSequence` 컴포넌트를 사용하세요. 이 컴포넌트에는 다음 두 필드가 필요합니다.

* `sequence`: 순차적으로 실행할 여러 트윈 정의가 담긴 배열입니다. 배열이 비어 있으면 현재 트윈만 재생합니다.
* `loop` *(선택 사항)*: 지정하지 않으면 시퀀스는 한 번만 재생됩니다. 이 필드를 지정하면 값은 `TweenLoop` 열거형의 값이어야 합니다. 허용되는 값은 다음과 같습니다.
  * `TL_RESTART`: 시퀀스가 끝나면 처음부터 다시 시작합니다. 마지막 상태가 첫 번째 상태와 다르면 엔터티가 한 상태에서 다른 상태로 즉시 이동합니다.
  * `TL_YOYO`: 시퀀스가 끝나면 모든 트윈을 역순으로 실행하며 시작 지점까지 되돌아갑니다. 그런 다음 다시 시작합니다.

### 앞뒤로 이동

플랫폼이 두 위치 사이를 계속 왕복하게 하려면 `sequence` 배열을 비워 두고 `loop` 을 `TweenLoop.TL_YOYO`

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)

Tween.setMove(myEntity, 
	Vector3.create(1, 1, 1), 
	Vector3.create(8, 1, 8), 
	2000
)

TweenSequence.create(myEntity, { sequence: [], loop: TweenLoop.TL_YOYO })
```

엔터티는 시작 지점과 끝 지점 사이를 양방향으로 이동하며, 양방향에서 동일한 지속 시간과 이징 함수를 사용합니다.

### 경로 따라가기

엔터티가 여러 지점을 거치는 더 복잡한 경로를 따라가게 하려면 `sequence` 에 트윈 정의 목록을 지정하세요. 이 필드는 `TweenSequence` 컴포넌트에 포함됩니다.

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)

Tween.setMove(myEntity, 
	Vector3.create(6.5, 7, 4), 
	Vector3.create(6.5, 7, 12), 
	4000
)

TweenSequence.create(myEntity, {
	sequence: [
		{
			duration: 2000,
			easingFunction: EasingFunction.EF_LINEAR,
			mode: Tween.Mode.Move({
				start: Vector3.create(6.5, 7, 12),
				end: Vector3.create(6.5, 10.5, 12),
			}),
		},
		{
			duration: 3000,
			easingFunction: EasingFunction.EF_LINEAR,
			mode: Tween.Mode.Move({
				start: Vector3.create(6.5, 10.5, 12),
				end: Vector3.create(6.5, 10.5, 4),
			}),
		},
		{
			duration: 3000,
			easingFunction: EasingFunction.EF_LINEAR,
			mode: Tween.Mode.Move({
				start: Vector3.create(6.5, 10.5, 4),
				end: Vector3.create(6.5, 7, 4),
			}),
		},
	],
	loop: TweenLoop.TL_RESTART,
})
```

TweenSequence 내에서 트윈을 정의할 때는 다음과 같은 더 자세한 형식을 사용해야 합니다. `Tween.Mode.Move`, 또는 `Tween.Mode.Rotate`, 또는 `Tween.Mode.Scale` 를 사용해 트윈을 정의합니다. 이 더 자세한 형식에서는 다음을 지정해야 합니다.

* `duration`: 두 위치 사이를 이동하는 데 걸리는 시간(밀리초)
* `easingFunction`: 사용할 이징 함수입니다. 자세한 내용은 [비선형 트윈](#non-linear-tweens)을 참조하세요. 이 형식에서는 값을 반드시 지정해야 합니다.
* `mode`: 트윈 모드이며, 다음 중 하나를 사용할 수 있습니다. `Tween.Mode.Move`, `Tween.Mode.Rotate`, 또는 `Tween.Mode.Scale`.

그리고 `mode` 필드에서 다음을 지정해야 합니다.

* `start`: 트윈의 시작 값
* `end`: 트윈의 종료 값

## 트윈 완료 시

다음 항목을 사용합니다. `tweenSystem.tweenCompleted` 를 사용하면 트윈이 완료된 시점을 감지할 수 있습니다. 트윈이 끝날 때 동작을 수행할 때 유용하며, 예를 들어 엘리베이터 문을 열 수 있습니다.

```ts
engine.addSystem(() => {
	const tweenCompleted = tweenSystem.tweenCompleted(myEntity)
	if (tweenCompleted) {
		//play sound
	}
})
```

## 동시 트윈

엔티티를 초기 상태에서 종료 상태로 이동, 회전 및 크기 조정하려면 다음을 사용해 `Tween` 컴포넌트를 만들고 `setMoveRotateScale` 함수를 사용합니다. 이 함수는 세 매개변수 중 원하는 조합에 사용할 수도 있습니다.

```ts
const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(14, 1, 2),
})
MeshRenderer.setBox(myEntity)

Tween.setMoveRotateScale(myEntity, {
	position: { start: Vector3.create(14, 1, 2), end: Vector3.create(14, 3, 2) },
	rotation: { start: Quaternion.fromEulerDegrees(0, 0, 0), end: Quaternion.fromEulerDegrees(0, 180, 90) },
	scale: { start: Vector3.One(), end: Vector3.create(2, 0.5, 2) },
	duration: 2000
})
```

이동 트윈에는 다음 정보가 필요합니다.

* `entity`: 이동할 엔티티
* `params`: 다음 매개변수가 포함된 객체
  * `position`: *(선택 사항)* 다음과 같은 `start` 및 `end` 값을 포함하는 객체이며, 두 값 모두 `Vector3`.
  * `rotation`: *(선택 사항)* 다음과 같은 `start` 및 `end` 값을 포함하는 객체이며, 두 값 모두 `Quaternion`.
  * `scale`: *(선택 사항)* 다음과 같은 `start` 및 `end` 값을 포함하는 객체이며, 두 값 모두 `Vector3`. 최소한 다음 중 하나를 지정해야 합니다. `position`, `rotation` 또는 `scale` 을 지정해야 합니다.
  * `duration`: *(필수)* 두 값 집합 간 전환에 걸리는 시간(밀리초)
  * `easingFunction`: *(선택 사항)* 사용할 이징 함수를 지정합니다. 자세한 내용은 다음을 참조하세요. [비선형 트윈](#non-linear-tweens)

엔티티에는 `Tween` 컴포넌트를 하나만 포함할 수 있으며, 각 트윈 컴포넌트는 한 번에 하나의 변환만 수행할 수 있습니다. setMoveRotateScale `setMoveRotateScale` 트윈 유형을 사용하면 엔티티를 옆으로 이동하면서 동시에 회전시킬 수 있지만, 두 동작은 동일한 타임라인을 따릅니다. 서로 독립적으로 전환해야 한다면 부모-자식 엔티티를 사용하는 방법이 있습니다. 예를 들어, 보이지 않는 부모 엔티티를 옆으로 이동시키고, 그 아래에 보이는 자식 엔티티를 두어 회전시킬 수 있습니다.

다음 코드 조각에서는 부모 엔티티가 회전하는 동안 자식 엔티티의 크기가 커집니다.

```ts
const parentEntity = engine.addEntity()
Transform.create(parentEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(parentEntity)
Tween.setRotate(parentEntity, 
	Quaternion.fromEulerDegrees(0, 0, 0), 
	Quaternion.fromEulerDegrees(0, 170, 0), 
	5000
)

const childEntity = engine.addEntity()
Transform.create(childEntity, {
	position: Vector3.create(0, 0, 0),
	parent: parentEntity,
})
MeshRenderer.setBox(childEntity)
Tween.setScale(childEntity, 
	Vector3.create(1, 1, 1), 
	Vector3.create(4, 4, 4), 
	2000
)
```

## 트윈 일시 중지

트윈을 일시 중지하려면 `playing` 속성을 false로 변경합니다. 다시 시작하려면 true로 변경합니다.

```ts
pointerEventsSystem.onPointerDown(
	{
		entity: button,
		opts: { button: InputAction.IA_POINTER, hoverText: 'pause' },
	},
	() => {
		let tweenData = Tween.getMutable(myEntity)
		tweenData.playing = !tweenData.playing
	}
)
```

더 이상 이어서 실행할 필요가 없는 트윈을 종료하려면 엔티티에서 `Tween` 컴포넌트를 삭제합니다. 엔티티에서 `TweenSequence` 컴포넌트도 사용 중이었다면 이것도 삭제합니다.

```ts
pointerEventsSystem.onPointerDown(
	{
		entity: button,
		opts: { button: InputAction.IA_POINTER, hoverText: 'pause' },
	},
	() => {
		if( Tween.has(myEntity)){
			Tween.deleteFrom(myEntity)
		}
		if( TweenSequence.has(myEntity)){
			TweenSequence.deleteFrom(myEntity)
		}
	}
)
```

## 시스템을 기반으로 트윈 만들기

Tween 컴포넌트를 사용해 엔진이 변환을 처리하게 하는 대신, 씬의 [시스템](https://docs.decentraland.org/creator/content-creator-ko/sdk7/architecture/systems.md) 을 통해 프레임마다 조금씩 엔티티를 이동하면서 전환을 단계적으로 처리할 수도 있습니다.

한편으로는 매 프레임 이동을 다시 계산할 수 있어 제어력이 높아집니다. 다른 한편으로는 코드가 더 복잡해지고, 성능이 낮은 기기를 사용하는 플레이어에게 트윈이 끊기는 것처럼 보일 수 있습니다. 이 경우 이동이 단계적으로 이루어지는 것을 알아차릴 수 있습니다.

### 시스템을 통해 이동하기

엔티티를 이동하는 가장 쉬운 방법은 *위치* 값을 점진적으로 수정하는 것입니다. 이 값은 `Transform` 컴포넌트에 저장됩니다.

```ts
function SimpleMove() {
	let transform = Transform.getMutable(myEntity)
	transform.position = Vector3.add(
		transform.position,
		Vector3.scale(Vector3.Forward(), 0.05)
	)
}

engine.addSystem(SimpleMove)

const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)
```

이 예시에서는 게임 루프가 한 번 실행될 때마다 엔티티를 0.05미터씩 이동합니다.

`Vector3.Forward()` 는 앞으로 향하고 길이가 1미터인 벡터를 반환합니다. 이 예시에서는 `Vector3.scale()`을 사용해 이 벡터의 길이를 1/20로 줄입니다. 이동 속도는 프레임 속도에 따라 달라집니다. 초당 60프레임으로 실행되는 기기에서는 엔티티가 초당 3미터 이동하지만, 초당 30프레임으로 실행되는 기기에서는 초당 1.5미터만 이동합니다.

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-de7e8eb38ec395b56d54f34952ac73ba3db30f38%2Fmove.webp?alt=media)

### 시스템을 통해 회전하기

엔티티를 회전하는 가장 쉬운 방법은 시스템 함수의 일부로 실행되는 코드를 통해 Transform 컴포넌트의 값을 조금씩 변경하는 것입니다.

```ts
function SimpleRotate() {
	let transform = Transform.getMutable(myEntity)
	transform.rotation = Quaternion.multiply(
		transform.rotation,
		Quaternion.fromAngleAxis(1, Vector3.Up())
	)
}

engine.addSystem(SimpleRotate)

const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)
```

현재 회전에 각 증분을 더하기 위해 `Quaternion.multiply`. 쿼터니언 수학에서는 두 회전을 더하는 것이 아니라 곱해서 결합합니다. 한 쿼터니언에 다른 쿼터니언을 곱한 결과는 먼저 한 회전을 수행한 다음 다른 회전을 수행한 것과 동일한 최종 회전입니다.

이 예시에서는 게임 루프의 각 틱마다 엔티티를 위쪽 방향으로 1도 회전합니다.

{% hint style="info" %}
**💡 팁**: 엔티티가 항상 플레이어를 향하도록 회전시키려면 [`Billboard` 컴포넌트를 추가하면 됩니다.](https://docs.decentraland.org/creator/content-creator-ko/sdk7/3d/entity-positioning.md#face-the-player).
{% endhint %}

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-10d76a54ac0c67a5501158d19b45d077174403cf%2Frotate.webp?alt=media)

### 시스템에서 피벗점을 기준으로 회전하기

엔티티를 회전할 때 회전은 항상 엔티티 중심 좌표를 기준으로 합니다. 다른 좌표를 피벗 지점으로 사용해 엔티티를 회전하려면 피벗 지점을 위치로 하는 두 번째(보이지 않는) 엔티티를 만들고, 회전하려는 엔티티의 부모로 지정합니다.

부모 엔티티를 회전하면 모든 자식 엔티티는 부모의 위치를 피벗 지점으로 삼아 함께 회전합니다. 자식 엔티티의 `position` 은 부모 엔티티를 기준으로 한다는 점에 유의하세요.

```ts
function SimpleRotate() {
	let transform = Transform.getMutable(pivotEntity)
	transform.rotation = Quaternion.multiply(
		transform.rotation,
		Quaternion.fromAngleAxis(1, Vector3.Up())
	)
}

engine.addSystem(SimpleRotate)

const pivotEntity = engine.addEntity()
Transform.create(pivotEntity, {
	position: Vector3.create(4, 1, 4),
})

const childEntity = engine.addEntity()
Transform.create(childEntity, {
	position: Vector3.create(1, 0, 0),
	parent: pivotEntity,
})
MeshRenderer.setBox(childEntity)
```

이 예제에서는 시스템이 다음 엔티티를 회전합니다. `pivotEntity` 이 엔티티는 다음 엔티티의 부모입니다. `childEntity` .

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-23bbd404133e9b16c55c8191c0df62e85ac20e77%2Fpivot-rotate.webp?alt=media)

### 시간 지연에 맞춰 이동 조정하기

씬을 방문한 플레이어가 프레임 속도를 따라가기 어려워한다고 가정해 보겠습니다. 프레임 간격이 모두 일정하지 않은데도 매 프레임 엔티티를 같은 거리만큼 이동시키면 움직임이 끊겨 보일 수 있습니다.

이처럼 불균일한 타이밍을 보정하려면 `dt` 매개변수를 사용해 이동량을 조정할 수 있습니다.

```ts
function SimpleMove(dt: number) {
	let transform = Transform.getMutable(myEntity)
	transform.position = Vector3.add(
		transform.position,
		Vector3.scale(Vector3.Forward(), dt)
	)
}

engine.addSystem(SimpleMove)

const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})
MeshRenderer.setBox(myEntity)
```

위 예시에서는 프레임 속도와 관계없이 엔티티가 초당 1미터의 일정한 속도로 이동합니다. 초당 60프레임으로 실행할 때 `dt` 의 값은 1/60이고, 초당 30프레임에서는 1/30입니다. 다른 속도로 이동하려면 `dt` 에 초당 이동 거리(미터)를 곱하면 됩니다. 예를 들어, `Vector3.scale(Vector3.Forward(), 3 * dt)` 는 엔티티를 초당 3미터의 속도로 이동시킵니다.

회전량에 `dt`.

### 시스템에서 두 지점 사이를 이동하기

엔티티를 두 지점 사이에서 부드럽게 이동시키려면 *lerp* (선형 보간) 알고리즘을 사용하세요. 이 알고리즘은 매우 유용해 게임 개발에서 널리 알려져 있습니다.

lerp() `lerp()` 함수는 다음 세 가지 매개변수를 받습니다.

* 시작 위치를 나타내는 벡터
* 목표 위치를 나타내는 벡터
* 이동할 비율을 나타내는 0\~1 사이의 값

```ts
const originVector = Vector3.Zero()
const targetVector = Vector3.Forward()

let newPos = Vector3.lerp(originVector, targetVector, 0.6)
```

선형 보간 알고리즘은 지정한 비율에 해당하는 두 벡터 사이 경로의 중간 지점을 찾습니다.

예를 들어, 시작 벡터가 *(0, 0, 0)* 이고 목표 벡터가 *(10, 0, 10)*:

* 비율을 0으로 설정하면 다음 값이 반환됩니다. *(0, 0, 0)*
* 비율을 0.3으로 설정하면 다음 값이 반환됩니다. *(3, 0, 3)*
* 비율을 1로 설정하면 다음 값이 반환됩니다. *(10, 0, 10)*

씬에서 이 `lerp()` 를 구현하려면 필요한 정보를 저장할 [사용자 지정 컴포넌트](https://docs.decentraland.org/creator/content-creator-ko/sdk7/architecture/custom-components.md) 를 만들 것을 권장합니다. 또한 매 프레임 점진적으로 이동하도록 구현하는 시스템도 정의해야 합니다.

```ts
// 사용자 지정 컴포넌트 정의
const MoveTransportData = {
	start: Schemas.Vector3,
	end: Schemas.Vector3,
	fraction: Schemas.Float,
	speed: Schemas.Float,
}

export const LerpTransformComponent = engine.defineComponent(
	'LerpTransformComponent',
	MoveTransportData
)

// 시스템 정의
function LerpMove(dt: number) {
	let transform = Transform.getMutable(myEntity)
	let lerp = LerpTransformComponent.getMutable(myEntity)
	if (lerp.fraction < 1) {
		lerp.fraction += dt * lerp.speed
		transform.position = Vector3.lerp(lerp.start, lerp.end, lerp.fraction)
	}
}

engine.addSystem(LerpMove)

// 엔터티 생성
const myEntity = engine.addEntity()

Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})

MeshRenderer.setBox(myEntity)

LerpTransformComponent.create(myEntity, {
	start: Vector3.create(4, 1, 4),
	end: Vector3.create(8, 1, 8),
	fraction: 0,
	speed: 1,
})
```

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a2059f7ebd97343d7176f5565a1b943c4af4af08%2Flerp-move.webp?alt=media)

### 시스템을 통해 움직이는 대상을 부드럽게 따라가기

플레이어를 따라다니는 반려동물처럼 계속 움직이는 대상에 개체가 부드럽게 접근하게 하려면, 매 프레임마다 남은 거리의 일부만큼 개체를 이동하세요. 다음과 같이 프레임마다 고정된 비율을 사용하지 마세요. `Vector3.lerp(current, target, 0.1)`이렇게 하면 결과가 프레임 속도에 따라 달라져, 느린 컴퓨터보다 빠른 컴퓨터에서 개체가 더 빨리 따라잡게 됩니다. 비율을 다음과 같이 `dt` 를 사용해 계산하세요.

```ts
const follower = engine.addEntity()
Transform.create(follower, { position: Vector3.create(8, 1, 8) })
MeshRenderer.setBox(follower)

const RATE = 5 // 값이 클수록 더 빨리 따라잡습니다

function FollowSystem(dt: number) {
	const transform = Transform.getMutable(follower)
	const target = Transform.get(engine.PlayerEntity).position
	// 모든 프레임 속도에서 동일한 스무딩
	const t = 1 - Math.exp(-RATE * dt)
	transform.position = Vector3.lerp(transform.position, target, t)
}

engine.addSystem(FollowSystem)
```

회전에도 동일한 공식을 사용할 수 있으며, `Quaternion.slerp()`.

### 시스템을 통해 두 각도 사이를 회전하기

두 각도 사이를 부드럽게 회전하려면 다음을 사용하세요. *구면 선형 보간(slerp)* (*구면* 선형 보간) 알고리즘입니다. 이 알고리즘은 다음과 매우 유사합니다. *선형 보간(lerp)*. 하지만 쿼터니언 회전을 처리합니다.

해당 `slerp()` 함수는 세 개의 매개변수를 받습니다:

* 해당 [쿼터니언](https://en.wikipedia.org/wiki/Quaternion) 원점 회전의 각도
* 해당 [쿼터니언](https://en.wikipedia.org/wiki/Quaternion) 대상 회전의 각도
* 이동할 비율을 나타내는 0\~1 사이의 값

{% hint style="info" %}
**💡 팁**: 회전 값을 [오일러](https://en.wikipedia.org/wiki/Euler_angles) 각도(0\~360도)로 전달하려면 `Quaternion.fromEulerDegrees()`.
{% endhint %}

```ts
const originRotation = Quaternion.fromEulerDegrees(0, 90, 0)
const targetRotation = Quaternion.fromEulerDegrees(0, 0, 0)

let newRotation = Quaternion.slerp(originRotation, targetRotation, 0.6)
```

씬에서 이를 구현하려면 `Slerp()` 함수에 전달되는 데이터를 [사용자 지정 컴포넌트](https://docs.decentraland.org/creator/content-creator-ko/sdk7/architecture/custom-components.md)에 저장하는 것을 권장합니다. 또한 매 프레임 점진적으로 회전하는 시스템을 정의해야 합니다.

```ts
// 사용자 지정 컴포넌트 정의
const RotateSlerpData = {
	start: Schemas.Quaternion,
	end: Schemas.Quaternion,
	fraction: Schemas.Float,
	speed: Schemas.Float,
}

export const SlerpData = engine.defineComponent('SlerpData', RotateSlerpData)

// 시스템 정의
function SlerpRotate(dt: number) {
	let transform = Transform.getMutable(myEntity)
	let slerpData = SlerpData.getMutable(myEntity)
	if (slerpData.fraction < 1) {
		slerpData.fraction += dt * slerpData.speed
		transform.rotation = Quaternion.slerp(
			slerpData.start,
			slerpData.end,
			slerpData.fraction
		)
	}
}

engine.addSystem(SlerpRotate)

// 엔터티 생성
const myEntity = engine.addEntity()

Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
})

MeshRenderer.setBox(myEntity)

SlerpData.create(myEntity, {
	start: Quaternion.fromEulerDegrees(0, 0, 0),
	end: Quaternion.fromEulerDegrees(0, 180, 0),
	fraction: 0,
	speed: 0.3,
})
```

{% hint style="warning" %}
**📔 참고**: 대신 오일러 각도를 `Vector3` 값으로 나타내고 `Lerp()` 함수를 사용할 수도 있지만, 매 프레임 `Vector3` 에서 `Quaternion` 으로 변환해야 합니다. 회전 값은 내부적으로 `Transform` 컴포넌트에서 쿼터니언으로 저장되므로, 씬에서 쿼터니언을 사용하면 더 효율적입니다.
{% endhint %}

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a3fddc2e8e2cf6cc5fa617cadd7fba6a65d0a802%2Flerp-rotate.webp?alt=media)

더 간단하지만 효율성은 떨어지는 방법으로 `Quaternion.rotateTowards` 함수를 활용하면 사용자 지정 컴포넌트를 사용하지 않아도 됩니다.

```ts
function SimpleRotate(dt: number) {
	let transform = Transform.getMutable(myEntity)
	transform.rotation = Quaternion.rotateTowards(
		transform.rotation,
		Quaternion.fromEulerDegrees(90, 0, 0),
		dt * 10
	)
	if (
		Quaternion.angle(transform.rotation, Quaternion.fromEulerDegrees(90, 0, 0)) < 0.01
	) {
		console.log('done')
		engine.removeSystem(SimpleRotate)
	}
}

engine.addSystem(SimpleRotate)

const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: Vector3.create(4, 1, 4),
	rotation: Quaternion.fromEulerDegrees(0, 0, 90),
})

MeshRenderer.setBox(myEntity)
```

위 예제에서 `Quaternion.rotateTowards` 는 세 개의 인수를 받습니다. 초기 회전, 원하는 최종 회전, 프레임당 최대 증가량입니다. 이 경우 최대 증가량이 `dt * 10` 도이므로 회전은 약 9초에 걸쳐 수행됩니다.

또한 시스템은 회전이 완료되었는지 확인하고, 완료된 경우 엔진에서 시스템을 제거합니다. 그렇지 않으면 회전이 완료된 후에도 매 프레임마다 계속 계산을 수행하게 됩니다.

### 시스템을 통해 두 크기 사이를 보간하기

엔티티의 비율을 유지하면서 크기를 부드럽게 변경하려면 *lerp* (linear interpolation, 선형 보간) 알고리즘을 `Scalar` 객체에서 사용하세요.

그렇지 않고 각 축의 비율을 다르게 변경하려면 `Vector3` 를 사용해 시작 크기와 목표 크기를 나타낸 다음, *lerp* 함수를 `Vector3`.

의 `lerp()` 함수는 `Scalar` 객체에서 세 개의 매개변수를 받습니다.

* 시작 크기를 나타내는 숫자
* 목표 크기를 나타내는 숫자
* 보간량입니다. 0부터 1까지의 값으로, 크기 변경을 얼마나 적용할지 나타냅니다.

```ts
const originScale = 1
const targetScale = 10

let newScale = Scalar.lerp(originScale, targetScale, 0.6)
```

장면에서 이 lerp를 구현하려면 필요한 정보를 저장할 사용자 지정 컴포넌트를 만드는 것이 좋습니다. 또한 매 프레임마다 점진적으로 크기를 조정하는 시스템을 정의해야 합니다.

```ts
// 사용자 지정 컴포넌트 정의
const ScaleTransportData = {
	start: Schemas.Number,
	end: Schemas.Number,
	fraction: Schemas.Float,
	speed: Schemas.Float,
}

export const ScaleTransformComponent = engine.defineComponent(
	'ScaleTransformComponent',
	ScaleTransportData
)

// 시스템 정의
function LerpMove(dt: number) {
	let transform = Transform.getMutable(myEntity)
	let lerp = ScaleTransformComponent.getMutable(myEntity)
	if (lerp.fraction < 1) {
		lerp.fraction += dt * lerp.speed
		const newScale = Scalar.lerp(lerp.start, lerp.end, lerp.fraction)
		transform.scale = Vector3.create(newScale, newScale, newScale)
	}
}

engine.addSystem(LerpMove)

// 엔터티 생성
const myEntity = engine.addEntity()

Transform.create(myEntity, {
	position: { x: 4, y: 1, z: 4 },
})

MeshRenderer.setBox(myEntity)

ScaleTransformComponent.create(myEntity, {
	start: 1,
	end: 2,
	fraction: 0,
	speed: 1,
})

Vector3.create(1, 1, 1)
```

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a430afcd10636fc6852e1b7b5e5157e0dcd9944f%2Flerp-scale.webp?alt=media)

### 시스템을 통해 두 지점 사이를 불규칙한 속도로 이동하기

lerp 메서드를 사용할 때 이동 속도를 비선형으로 만들 수 있습니다. 앞선 예제에서는 매 프레임마다 지정된 양만큼 lerp 값을 증가시켰지만, 수학 함수를 사용해 값을 기하급수적으로 증가시키거나 이동 속도를 다르게 만드는 다른 방식을 사용할 수도 있습니다.

사인 함수처럼 반복되는 결과를 내는 함수를 사용해 오고 가는 움직임을 표현할 수도 있습니다.

이러한 비선형 전환은 장면에 생동감을 크게 더해 주는 경우가 많습니다. 곡선을 따라 점점 빨라지거나 서서히 느려지는 움직임은 물체나 캐릭터의 특성을 잘 드러낼 수 있습니다. 탄력 있는 효과를 더하는 수학 함수를 활용할 수도 있습니다.

```ts
// 사용자 지정 컴포넌트 정의
const MoveTransportData = {
	start: Schemas.Vector3,
	end: Schemas.Vector3,
	fraction: Schemas.Float,
	speed: Schemas.Float,
}

export const LerpTransformComponent = engine.defineComponent(
	'LerpTransformComponent',
	MoveTransportData
)

// 시스템 정의
function LerpMove(dt: number) {
	let transform = Transform.getMutable(myEntity)
	let lerp = LerpTransformComponent.getMutable(myEntity)
	if (lerp.fraction < 1) {
		lerp.fraction += dt * lerp.speed
		const interpolatedValue = interpolate(lerp.fraction)
		transform.position = Vector3.lerp(lerp.start, lerp.end, interpolatedValue)
	}
}

// map the lerp fraction to an exponential curve
function interpolate(t: number) {
	return t * t
}

engine.addSystem(LerpMove)

// 엔터티 생성
const myEntity = engine.addEntity()

Transform.create(myEntity, {
	position: { x: 4, y: 1, z: 4 },
})

MeshRenderer.setBox(myEntity)

LerpTransformComponent.create(myEntity, {
	start: Vector3.create(4, 1, 4),
	end: Vector3.create(8, 1, 8),
	fraction: 0,
	speed: 1,
})
```

위 예제는 앞서 살펴본 선형 lerp 예제와 거의 같지만, `fraction` 필드를 매 틱마다 비선형 값에 매핑합니다. 이 비선형 값을 사용해 `lerp` 함수를 계산하면 지수 곡선을 따르는 움직임이 만들어집니다.

위에서 설명한 것처럼 선형 전환을 곡선에 매핑하면 회전이나 크기 전환에도 같은 방식을 적용할 수 있습니다.

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-40e98a0199aaec74e734625a0ccf464a7a92f238%2Flerp-speed-up.webp?alt=media)

### 시스템을 통해 경로 따라가기

엔티티가 벡터 배열을 순회하면서 각 벡터 사이를 lerp로 이동하게 하면 더 복잡한 경로를 따라가도록 할 수 있습니다.

```ts
// 사용자 지정 컴포넌트 정의
const PathTransportData = {
	path: Schemas.Array(Schemas.Vector3),
	start: Schemas.Vector3,
	end: Schemas.Vector3,
	fraction: Schemas.Float,
	speed: Schemas.Float,
	pathTargetIndex: Schemas.Int,
}

export const LerpTransformComponent = engine.defineComponent(
	'LerpTransformComponent',
	PathTransportData
)

// 시스템 정의
function PathMove(dt: number) {
	let transform = Transform.getMutable(myEntity)
	let lerp = LerpTransformComponent.getMutable(myEntity)
	if (lerp.fraction < 1) {
		lerp.fraction += dt * lerp.speed
		transform.position = Vector3.lerp(lerp.start, lerp.end, lerp.fraction)
	} else {
		lerp.pathTargetIndex += 1
		if (lerp.pathTargetIndex >= lerp.path.length) {
			lerp.pathTargetIndex = 0
		}
		lerp.start = lerp.end
		lerp.end = lerp.path[lerp.pathTargetIndex]
		lerp.fraction = 0
	}
}

engine.addSystem(PathMove)

// 엔터티 생성
const myEntity = engine.addEntity()

Transform.create(myEntity, {
	position: Vector3.create(1, 1, 1),
})

MeshRenderer.setBox(myEntity)

const point1 = Vector3.create(1, 1, 1)
const point2 = Vector3.create(8, 1, 3)
const point3 = Vector3.create(8, 4, 7)
const point4 = Vector3.create(1, 1, 7)

const myPath = [point1, point2, point3, point4]

LerpTransformComponent.create(myEntity, {
	path: myPath,
	start: Vector3.create(4, 1, 4),
	end: Vector3.create(8, 1, 8),
	fraction: 0,
	speed: 1,
	pathTargetIndex: 1,
})
```

위 예제는 네 개의 3D 벡터로 이루어진 3D 경로를 정의합니다. `PathTransportData` 사용자 지정 컴포넌트는 위의 *lerp* 예제의 사용자 지정 컴포넌트와 동일한 데이터를 보유하지만, 경로의 모든 지점을 담은 `path` 배열과 현재 어떤 경로 구간을 사용 중인지 추적하는 `pathTargetIndex` 필드가 추가되어 있습니다.

이 시스템은 *lerp* 예제의 시스템과 매우 비슷하지만, lerp 동작이 완료되면 다음을 설정합니다. `target` 및 `origin` 필드를 새 값으로 설정합니다. 경로의 끝에 도달하면 경로의 첫 번째 값으로 돌아갑니다.

![](https://3980763956-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-9d92296f54da83a76e256668dda043ecf2b8be30%2Flerp-path.webp?alt=media)

## 텍스처 트윈

텍스처를 부드럽게 이동하려면 `Tween` 컴포넌트와 `setTextureMove` 함수를 사용합니다.

```ts
Tween.setTextureMove(myEntity, 
	Vector2.create(0, 0), 
	Vector2.create(1, 0), 
	2000
)
```

텍스처 트윈에는 다음 정보가 필요합니다.

* `entity`: 텍스처를 이동할 엔티티
* `start`: 시작 위치를 나타내는 Vector2
* `end`: 끝 위치를 나타내는 Vector2
* `duration`: 두 위치 사이를 이동하는 데 걸리는 시간(밀리초)

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `movementType`: (선택 사항) 이동을 오프셋 필드에서 수행할지 타일링 필드에서 수행할지 지정합니다. 기본값은 오프셋입니다.
* `easingFunction`: 사용할 이징 함수입니다. 자세한 내용은 [비선형 트윈](#non-linear-tweens).

## 일정한 텍스처 이동

텍스처를 일정하게 이동하려면 `Tween` 컴포넌트와 `setTextureMoveContinuous` 함수를 사용합니다.

```ts
Tween.setTextureMoveContinuous(myEntity, 
	Vector2.create(0, 1), 
	0.7
)
```

텍스처 연속 트윈에는 다음 정보가 필요합니다.

* `entity`: 텍스처를 이동할 엔티티
* `direction`: 이동 방향을 나타내는 Vector2
* `speed`: 엔티티가 초당 이동하는 단위 수

다음과 같은 선택적 매개변수도 사용할 수 있습니다:

* `movementType`: 이동을 오프셋 필드에서 수행할지 타일링 필드에서 수행할지 지정합니다. 기본값은 오프셋입니다.
* `duration`: 이동을 지속할 시간(밀리초)입니다. 이 시간이 지나면 이동이 멈춥니다.

텍스처 트윈에 관한 자세한 내용은 [텍스처 트윈](https://docs.decentraland.org/creator/content-creator-ko/sdk7/3d/materials.md#texture-tweens) 섹션을 참조하세요.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-ko/sdk7/3d/move-entities.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
