엔티티 위치 지정

씬에서 엔티티의 위치, 회전, 크기를 설정하는 방법

다음을 설정할 수 있습니다 위치, 회전 및 스케일 을 어떤 엔티티에든 Transform 컴포넌트를 사용하여 적용할 수 있습니다. 이는 3D 공간의 어떤 엔티티에도 사용할 수 있으며, 엔티티가 렌더링되는 위치에 영향을 줍니다. 여기에는 기본 도형(큐브, 구, 평면 등), 3D 텍스트 도형, NFT 도형, 그리고 3D 모델(GltfContainer).

Creator Hub의 Scene Editor 사용

Scene Editor를 통해 씬에 항목을 추가하면, 암묵적으로 Transform 컴포넌트가 포함됩니다. 그런 다음 엔티티의 위치, 회전 또는 스케일을 변경하여 엔티티의 Transform 컴포넌트 값이 암묵적으로 변경됩니다. 더 정밀하게 값을 지정하려면 Scene Editor의 UI를 사용해 숫자로 값을 입력할 수도 있습니다.

코드 핵심

// 새 엔티티 생성
const ball = engine.addEntity()

// 이 엔티티에 형태를 부여하여 보이게 만들기
MeshRenderer.setSphere(ball)

// 이 엔티티에 Transform 컴포넌트 부여
Transform.create(ball, {
	position: Vector3.create(5, 1, 5),
	scale: Vector3.create(1, 1, 1),
	rotation: Quaternion.Identity(),
})

씬의 엔티티를 일정 기간에 걸쳐 이동, 회전 또는 크기 조정하려면, 이 컴포넌트의 값을 프레임마다 조금씩 변경하세요. 자세한 내용과 모범 사례는 엔티티 이동 를 참조하세요.

📔 참고: Vector3 및 Quaternion 은 다음을 통해 import해야 합니다

import { Vector3, Quaternion } from "@dcl/sdk/math"

다음 항목을 참조하세요 Imports 에서 이를 쉽게 다루는 방법을 확인하세요.

Position

위치 은 3D 벡터이며, 엔티티 중심의 위치를 세 축 모두에 대해 설정합니다, x, y및 z. 다음을 참조하세요 Geometry types 에서 더 자세한 내용을 확인하세요.

// 새 엔티티 생성
const ball = engine.addEntity()

// 미리 정의된 위치로 Transform 생성
Transform.create(ball, {
	  position: Vector3.create(5, 1, 5)
})

// Transform의 변경 가능한 버전 가져오기
const mutableTransform = Transform.getMutable(ball)

// 객체로 위치 설정
mutableTransform.position = { x: 5, y: 1, z: 5 }

// 객체로 위치 설정(대체 구문)
mutableTransform.position = Vector3.create(2, 1, 4)

// 각 축을 개별적으로 설정
mutableTransform.position.x = 3
mutableTransform.position.y = 1
mutableTransform.position.z = 3

위치를 설정할 때는 다음 사항을 염두에 두세요:

위치 벡터의 숫자는 미터 를 나타냅니다(엔티티가 크기 조정된 엔티티의 자식이 아닌 경우).
단일 parcel로 구성된 씬의 크기는 16m x 16m입니다. 씬의 중심(지면 기준)은 x:8, y:0, z:8. 씬이 여러 parcel로 구성된 경우 중심은 배치에 따라 달라집니다.
x:0, y:0, z:0 은 남서쪽 에 있는 씬의 기본 parcel의 모서리를 가리킵니다(지면 기준).
팁: 씬 미리보기를 볼 때, 씬의 (0,0,0) 지점에 각 축의 라벨이 표시된 나침반이 나타납니다.
참고: 씬의 기본 parcel은 다음을 편집하여 변경할 수 있습니다 base 속성의 scene.json.
더 쉽게 방향을 파악하려면 왼손을 사용하세요: 왼쪽 손:
- 검지 손가락(앞을 가리킴)은 z 축
- 중지 손가락(옆을 가리킴)은 x 축
- 엄지손가락(위로 가리킴)은 y 축입니다.
엔티티가 다른 엔티티의 자식이면 x:0, y:0, z:0 은 씬 내 어디에 있든 부모 엔티티의 중심을 가리킵니다.
씬의 모든 엔티티는 항상 자신이 차지하는 parcel의 경계 안에 있어야 합니다. 엔티티가 이 경계를 벗어나면 오류가 발생합니다.
팁: 미리보기 모드에서 씬을 볼 때, 경계를 벗어난 엔티티는 빨간색.
으로 강조 표시됩니다. 씬의 높이도 제한됩니다. 차지하는 parcel 수와 관계없이 모든 씬의 최대 높이는 330미터입니다. 200미터 위에 배치된 엔티티는 멀티플레이어 동기화 문제를 겪을 수 있습니다. 다음을 참조하세요 씬 제한 에서 더 자세한 내용을 확인하세요.

Rotation

회전 은 쿼터니언으로 저장되며, 이는 네 개의 숫자로 이루어진 체계입니다, x, y, z 및 w. 이 숫자들은 각각 -1에서 1 사이의 값을 가집니다. 다음을 참조하세요 Geometry types 에서 더 자세한 내용을 확인하세요.

// 새 엔티티 생성
const cube = engine.addEntity()

// 0의 미리 정의된 회전으로 Transform 생성
Transform.create(cube, {
	  rotation: Quaternion.Identity()
})

// Transform의 변경 가능한 버전 가져오기
const mutableTransform = Transform.getMutable(cube)

// 오일러 각으로 객체를 사용해 회전 설정
mutableTransform.rotation = Quaternion.fromEulerDegrees(0, 90, 0)

// 객체를 사용해 회전 설정
mutableTransform.rotation = { x: 0.1, y: 0.5, z: 0.5, w: 0 }

// 각 축을 개별적으로 설정
mutableTransform.rotation.x = 0
mutableTransform.rotation.y = 1
mutableTransform.rotation.z = 0.3
mutableTransform.rotation.w = 0

회전 필드도 다음을 사용해 설정할 수 있습니다 오일러 각도는 더 일반적인 x, y 및 z 0에서 360까지의 숫자를 사용하는 표기법으로, 대부분의 사람들에게 익숙합니다. 오일러 각을 사용하려면 다음 표기 중 하나를 사용하세요:

// 오일러 각의 미리 정의된 회전으로 Transform 생성
Transform.create(cube, {
	  rotation: Quaternion.fromEulerDegrees(0, 90, 0)
})

// Transform의 변경 가능한 버전 가져오기
const mutableTransform = Transform.getMutable(cube)

// 오일러 각으로 객체를 사용해 회전 설정
mutableTransform.rotation = Quaternion.fromEulerDegrees(0, 90, 0)

다음을 사용할 때 3D 벡터 오일러 각을 나타내는 데 사용하는 x, y 및 z 은 해당 축의 회전을 나타내며, 도 단위로 측정됩니다. 한 바퀴는 360도가 필요합니다.

엔티티의 회전을 가져오면 기본적으로 쿼터니언이 반환됩니다. 이를 오일러 각으로 표현된 회전으로 얻으려면 다음을 사용하세요 Quaternion.toEulerAngles():

// Transform의 읽기 전용 버전 가져오기
const transform = Transform.get(cube)

// 오일러 각으로 표현된 회전 얻기
const eulerAngle = Quaternion.toEulerAngles(transform.rotation)

엔티티의 전역 위치 및 회전 가져오기

다음 함수는 getWorldPosition 및 getWorldRotation 엔티티의 전역 위치와 회전을 반환합니다. 즉, 부모 계층 구조는 무시하고 플레이어가 보게 될 항목의 인식된 위치 또는 회전을 반환한다는 뜻입니다.

getWorldPosition(engine, entity: Entity): Vector3Type: 이 함수는 엔티티 자체가 자식 엔티티를 가지고 있는지 여부를 고려하여 부모 엔티티들의 모든 위치를 반영한 엔티티의 월드 위치를 반환하며, {x: 0, y: 0, z: 0} 엔티티에 Transform이 없으면 이 값을 반환합니다.

const worldPos = getWorldPosition(engine, childEntity)
console.log(`월드 위치: ${worldPos.x}, ${worldPos.y}, ${worldPos.z}`)

getWorldRotation(engine, entity: Entity): QuaternionType: 이 함수는 엔티티 자체에 자식이 있는 경우 부모 엔티티들의 모든 회전을 고려하여 엔티티의 월드 회전을 반환합니다. 이 함수는 Quaternion 타입을 반환하며, 항등 쿼터니언을 반환합니다 {x: 0, y: 0, z: 0, w: 1} 엔티티에 Transform이 없으면 이 값을 반환합니다.

const worldRot = getWorldRotation(engine, childEntity)
console.log(`월드 회전: ${worldRot.x}, ${worldRot.y}, ${worldRot.z}, ${worldRot.w}`)

참고: 전역 위치와 전역 회전은 Genesis City가 아니라 씬 내부의 좌표를 기준으로 합니다.

플레이어를 바라보게 하기

다음을 추가하세요 Billboard 컴포넌트를 엔티티에 추가하면 항상 플레이어를 향해 회전합니다.

Billboard는 90년대 3D 게임에서 흔히 사용되던 기법으로, 대부분의 엔티티가 항상 플레이어를 향하는 2D 평면이었습니다. 같은 아이디어는 3D 모델을 회전시키는 데도 사용할 수 있습니다.

// 새 엔티티 생성
const cube = engine.addEntity()

// 엔티티에 보이는 형태 부여
MeshRenderer.setBox(cube)

// 미리 정의된 위치로 Transform 생성
Transform.create(cube, {
	  position: Vector3.create(5, 1, 5)
})

// 엔티티에 Billboard 컴포넌트 부여
Billboard.create(cube, {})

다음 매개변수로 billboard의 동작을 설정할 수 있습니다:

billboardMode: 다음 값 중 하나를 사용합니다 BillboardMode 를 사용하여 어느 회전 축이 자동으로 플레이어를 향해 회전할지 설정합니다:
- BillboardMode.BM_ALL: 엔티티가 모든 회전 축에서 플레이어를 향해 회전합니다. 플레이어가 엔티티보다 훨씬 위에 있으면 엔티티가 위를 향하게 됩니다.
- BillboardMode.BM_NONE: 엔티티는 전혀 회전하지 않습니다.
- BillboardMode.BM_X: 엔티티는 자신의 x 회전 축에서만 회전합니다.
- BillboardMode.BM_Y: 엔티티는 자신의 y 회전 축입니다. 좌우로만 회전하고 위아래로는 회전하지 않습니다. 플레이어가 엔티티의 위나 아래에 있어도 지면에 수직인 상태를 유지합니다.
- BillboardMode.BM_Z: 엔티티는 자신의 z 회전 축에서만 회전합니다.
targetEntity: (선택 사항) 플레이어의 카메라 대신 billboard가 바라보도록 회전할 엔티티입니다. 참조된 엔티티가 존재하지 않으면(예: 아직 생성되지 않았거나 제거된 경우), billboard는 회전을 멈추고 엔티티가 다시 존재할 때까지 마지막 방향을 유지합니다. 이를 engine.CameraEntity 로 설정하는 것은 비워 두는 것과 같습니다.

// 평면 billboard
const perpendicularPlane = engine.addEntity()

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

MeshRenderer.setPlane(perpendicularPlane)

Billboard.create(perpendicularPlane, {
	billboardMode: BillboardMode.BM_Y,
})

// 텍스트 라벨
const textLabel = engine.addEntity()

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

TextShape.create(textLabel, {
	text: '이 텍스트는 항상 읽을 수 있습니다',
})

Billboard.create(textLabel)

// 플레이어 대신 다른 엔티티를 향하는 표지판
const sphere = engine.addEntity()

Transform.create(sphere, {
	position: Vector3.create(4, 2, 4),
})

MeshRenderer.setSphere(sphere)

const sign = engine.addEntity()

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

TextShape.create(sign, {
	text: '구를 바라보는 중',
})

Billboard.create(sign, {
	targetEntity: sphere,
})

💡 팁: Billboard는 다음에 추가하기에 매우 유용합니다 텍스트 엔티티에 추가하면 항상 읽기 쉽게 만들 수 있습니다.

다음 함수는 회전 엔티티의 Transform 컴포넌트 값은 billboard가 플레이어를 따라 움직여도 변하지 않습니다.

엔티티에 Billboard 컴포넌트와 Transform 컴포넌트가 함께 있고 회전 값이 있다면, 플레이어는 해당 엔티티가 billboard로 회전하는 것을 보게 됩니다. billboard가 모든 축에 영향을 주지 않는 경우, 나머지 축은 Transform 컴포넌트에 따라 회전됩니다.

📔 참고: 여러 플레이어가 동시에 존재하면 각 플레이어는 자신을 향한 billboard 모드의 엔티티를 보게 됩니다. billboard 회전은 각 플레이어별로 로컬에서 계산되며 다른 플레이어가 보는 것에는 영향을 주지 않습니다. 이는 targetEntity의 billboard에는 적용되지 않습니다: 대상의 위치가 씬의 일부이므로 모든 플레이어가 같은 방향을 향한 billboard를 보게 됩니다.

좌표 집합을 바라보게 하기

엔티티 A가 엔티티 B를 바라보게 하려면:

1) 엔티티 A의 위치를 엔티티 B의 위치에서 빼서 둘 사이의 거리를 나타내는 벡터를 구합니다.
2) 그 벡터를 정규화하여 방향은 유지한 채 길이가 1이 되게 합니다.
3) `Quaternion.lookRotation`을 사용해 그 방향으로 회전하는 Quaternion 회전을 얻습니다.
4) 그 Quaternion을 엔티티 A의 회전으로 설정합니다

export function turn(entity: Entity, target: Vector3.ReadonlyVector3) {
	const transform = Transform.getMutable(entity)
	const difference = Vector3.subtract(target, transform.position)
	const normalizedDifference = Vector3.normalize(difference)
	transform.rotation = Quaternion.lookRotation(normalizedDifference)
}

Scale

스케일 도 또한 3D 벡터이며, Vector3 객체로 저장됩니다. 여기에는 x, y 및 z 축의 스케일 계수도 포함됩니다. 엔티티의 형태는 기본 도형이든 3D 모델이든 이에 맞게 조정됩니다.

기본 스케일은 1이므로, 1보다 큰 값을 지정하면 엔티티가 늘어나고 1보다 작은 값을 지정하면 작아집니다.

// 새 엔티티 생성
const ball = engine.addEntity()

// 미리 정의된 위치로 Transform 생성
Transform.create(ball, {
	  scale: Vector3.create(5, 5, 5)
})

// Transform의 변경 가능한 버전 가져오기
const mutableTransform = Transform.getMutable(ball)

// Vector3로 스케일 설정

mutableTransform.scale = Vector3.create(2, 2, 2)

// 객체로 위치 설정
mutableTransform.scale = { x: 5, y: 1, z: 5 }

// 각 축을 개별적으로 설정
mutableTransform.scale.x = 3
mutableTransform.scale.y = 3
mutableTransform.scale.z = 2

부모로부터 변형 상속

엔티티가 다른 엔티티 안에 중첩되면, 자식 엔티티는 부모의 컴포넌트를 상속합니다. 즉, 부모 엔티티가 위치, 스케일 또는 회전되어 있으면 그 자식도 영향을 받습니다. 자식 엔티티의 위치, 회전, 스케일 값은 부모의 값을 덮어쓰지 않고, 대신 이것들이 합성됩니다.

엔티티를 다른 엔티티의 부모로 지정하려면 자식 엔티티의 parent 필드에 설정합니다 Transform 컴포넌트에 따라 회전됩니다.

부모 엔티티가 스케일되면 자식의 모든 위치 값도 함께 스케일됩니다.

// 엔티티 생성
const parentEntity = engine.addEntity()
const childEntity = engine.addEntity()

// 부모에 대한 Transform 생성
Transform.create(parentEntity, {
	position: Vector3.create(3, 1, 1),
	scale: Vector3.create(0.5, 0.5, 0.5),
})

// 자식에 대한 Transform을 만들고 자식으로 지정
Transform.create(childEntity, {
	position: Vector3.create(0, 1, 0),
	parent: parentEntity,
})

이 예에서 자식 엔티티는 부모가 해당 스케일을 가지므로 0.5로 축소됩니다. 자식 엔티티의 위치도 부모를 기준으로 상대적으로 계산됩니다. 부모의 위치에 자식의 위치를 더해야 합니다. 이 경우 부모가 절반 크기로 스케일되었기 때문에 자식의 변형도 비례하여 축소됩니다. 절대값으로는 자식이 다음 위치에 배치됩니다 { x: 3, y: 1.5, z: 1 }. 부모에 회전가 있었다면, 이는 자식이 이동되는 축을 변경하므로 자식의 최종 위치에도 영향을 줍니다.

자식 엔티티에 위치 가 Transform에 없으면 기본값은 0,0,0이며, 이 경우 부모와 같은 위치에 놓입니다.

보이지 않는 엔티티를 shape 컴포넌트가 없는 부모로 사용하여 다른 엔티티 집합을 감쌀 수 있습니다. 이 엔티티는 렌더링된 씬에서는 보이지 않지만, 자식들을 그룹화하고 모두에 변형을 적용하는 데 사용할 수 있습니다.

📔 참고: 계층 구조에서 엔티티가 자신의 조상이 되는 루프를 만들지 않도록 하세요. SDK는 이러한 루프를 감지하고 관련 엔티티 이름을 포함한 경고를 기록합니다. 부모 지정 문제를 수정하기 전까지 영향을 받은 엔티티는 올바르게 배치되지 않습니다.

아바타에 엔티티 연결하기

엔티티를 플레이어에 연결하는 방법은 세 가지입니다:

이를 다음의 자식으로 만드세요 아바타 엔티티
이를 다음의 자식으로 만드세요 카메라 엔티티
다음을 사용하세요 AvatarAttach 컴포넌트

엔티티를 아바타에 연결하는 가장 간단한 방법은 부모를 예약된 엔티티 engine.PlayerEntity로 설정하는 것입니다. 그러면 엔티티가 플레이어의 위치와 함께 이동합니다.

let childEntity = engine.addEntity()

MeshRenderer.setCylinder(childEntity)

Transform.create(childEntity, {
	scale: Vector3.create(0.2, 0.2, 0.2),
	position: Vector3.create(0, 0.4, 0),
	parent: engine.PlayerEntity,
})

엔티티를 예약된 엔티티 engine.CameraEntity로 설정할 수도 있습니다. 1인칭에서 카메라 엔티티를 사용할 때 연결된 엔티티는 카메라의 움직임을 따라갑니다. 이는 항상 무언가를 화면에 보이게 유지하는 데 이상적입니다. 예를 들어 카메라가 위를 향하더라도 총의 3D 모델이 항상 보이게 유지할 수 있습니다.

let childEntity = engine.addEntity()

MeshRenderer.setCylinder(childEntity)

Transform.create(childEntity, {
	scale: Vector3.create(0.2, 0.2, 0.2),
	position: Vector3.create(0, 0.4, 0),
	parent: engine.CameraEntity,
})

오브젝트를 아바타의 뼈대 중 하나에 연결하고 아바타의 애니메이션과 함께 움직이게 하려면 엔티티에 AvatarAttach 컴포넌트를 추가하세요.

아바타에서 서로 다른 앵커 포인트를 선택할 수 있으며, 이들 대부분은 플레이어의 골격에 연결되어 플레이어의 애니메이션을 따릅니다. 예를 들어 오른손 앵커 포인트를 사용하면, 연결된 엔티티는 달리는 동안 아바타가 손을 흔들거나 팔을 휘두를 때 움직이며, 마치 플레이어가 손에 엔티티를 들고 있는 것처럼 동작합니다.

// avatarId가 설정되지 않으면 기본적으로 engine.PlayerEntity가 사용되므로 메인 플레이어에 연결
AvatarAttach.create(myEntity, {
	anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG,
})

// ID로 플레이어에 연결
AvatarAttach.create(myEntity, {
	avatarId: '0xAAAAAAAAAAAAAAAAA',
	anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG,
})

다음을 생성할 때 AvatarAttach 컴포넌트, 다음 데이터를 가진 객체를 전달하세요:

avatarId: 선택 사항 연결할 플레이어의 ID입니다. 이는 이더리움 지갑에 연결된 플레이어의 경우 플레이어의 이더리움 주소와 동일합니다. 지정하지 않으면 로컬 플레이어의 아바타에 엔티티가 연결됩니다.
anchorPointId: 엔티티를 아바타 스켈레톤의 어느 앵커 포인트에 연결할지 지정합니다. 열거형 AvatarAnchorPointType.

📔 참고: 씬의 모든 플레이어가 동일한 플레이어에 연결된 오브젝트를 보게 하려면, 예를 들어 Player A가 오브젝트를 집어 들어 왼손에 들고 있는 것을 모두가 보게 하려면 avatarId값을 제공해야 합니다. 지정하지 않으면 모든 플레이어는 자신의 아바타에 연결된 오브젝트를 보게 됩니다.

다음 예제는 특정 아바타에 연결된 엔티티를 배치하여 다른 모든 플레이어가 같은 아바타에 연결된 것으로 보게 합니다.

import { getPlayer } from '@dcl/sdk/src/players'
import { AvatarAnchorPointType, AvatarAttach, engine, Entity } from '@dcl/sdk/ecs'
import { syncEntity } from '@dcl/sdk/network'

async function attachToPlayer(){

 let userData = await getPlayer()
 console.log(userData)

 if (!userData || !userData.wearables) return

  let entity = engine.addEntity()

  AvatarAttach.create(entity, {
    avatarId: userData.userId,
    anchorPointId: AvatarAnchorPointType.AAPT_RIGHT_HAND,
  })

  // 기타 컴포넌트

  syncEntity(entity, [AvatarAttach.componentId])

}

다음 앵커 포인트를 사용할 수 있습니다. AvatarAnchorPointType 열거형:

AAPT_RIGHT_HAND: 플레이어의 오른손에 고정됩니다
AAPT_LEFT_HAND: 플레이어의 왼손에 고정됩니다
AAPT_HEAD: 플레이어 머리 중심에 고정됩니다.
AAPT_NECK: 플레이어의 목 아래쪽에 고정됩니다.
AAPT_SPINE: 척추 상단 부분에 고정됩니다.
AAPT_SPINE1: 척추 중간 부분에 고정됩니다.
AAPT_SPINE2: 척추 하단 부분에 고정됩니다.
AAPT_HIP: 고관절 뼈에 고정됩니다.
AAPT_LEFT_SHOULDER: 왼쪽 어깨에 고정됩니다.
AAPT_LEFT_ARM: 어깨 높이의 왼쪽 첫 번째 팔 뼈에 고정됩니다.
AAPT_LEFT_FOREARM: 왼쪽 팔뚝 뼈에 고정됩니다.
AAPT_LEFT_HAND_INDEX: 왼손 검지 끝에 고정됩니다.
AAPT_RIGHT_SHOULDER: 오른쪽 어깨에 고정됩니다.
AAPT_RIGHT_ARM: 어깨 높이의 오른쪽 첫 번째 팔 뼈에 고정됩니다.
AAPT_RIGHT_FOREARM: 오른쪽 팔뚝 뼈에 고정됩니다.
AAPT_RIGHT_HAND_INDEX: 오른손 검지 끝에 고정됩니다.
AAPT_LEFT_UP_LEG: 왼쪽 다리의 허벅지 뼈에 고정됩니다.
AAPT_LEFT_LEG: 왼쪽 다리의 아래쪽 다리 뼈에 고정됩니다.
AAPT_LEFT_FOOT: 왼쪽 다리의 발목에 고정됩니다.
AAPT_LEFT_TOE_BASE: 왼쪽 다리의 발가락 끝에 고정됩니다.
AAPT_RIGHT_UP_LEG: 오른쪽 다리의 허벅지 뼈에 고정됩니다.
AAPT_RIGHT_LEG: 오른쪽 다리의 아래쪽 다리 뼈에 고정됩니다.
AAPT_RIGHT_FOOT: 오른쪽 다리의 발목에 고정됩니다.
AAPT_RIGHT_TOE_BASE: 오른쪽 다리의 발가락 끝에 고정됩니다.
.AAPT_NAME_TAG: 플레이어의 이름표 바로 위에 떠 있으며, 플레이어의 애니메이션에는 영향을 받지 않습니다.
참고: 이름표 높이는 플레이어가 착용한 착용 아이템의 높이에 따라 동적으로 조정됩니다. 따라서 키가 큰 모자를 쓴 플레이어의 이름표는 다른 플레이어보다 약간 더 높게 표시됩니다.
AAPT_POSITION 사용 중단됨: 플레이어의 전체 위치입니다. 이는 플레이어 발에서 0.8 높이에 표시됩니다.

> **📔 참고**: `AAPT_POSITION`은 사용 중단되었습니다. 플레이어의 전체 위치를 따라가게 하려면 엔티티를 Avatar Entity의 자식으로 만드는 것이 가장 좋습니다. 예시는 이 섹션의 시작 부분을 참조하세요. >

💡 팁: 이러한 값을 사용하려면 AvatarAnchorPointType. 를 작성하면 VS Code가 드롭다운에 전체 옵션 목록을 표시합니다.

엔티티 렌더링은 씬의 각 인스턴스마다 로컬에서 결정됩니다. 한 플레이어에 엔티티를 붙여도 그 플레이어를 보는 다른 플레이어에게는 보이지 않습니다. 엔티티가 기본 로컬 플레이어에 붙어 있으면, 각 플레이어는 그 엔티티가 자신의 아바타에 붙어 있는 것으로 경험하게 됩니다.

📔 참고: 아바타에 붙은 엔티티는 렌더링되려면 씬 경계 안에 있어야 합니다. 플레이어가 씬 밖으로 나가면, 붙어 있는 엔티티는 플레이어가 다시 들어올 때까지 렌더링이 중지됩니다. 스마트 웨어러블은 이 제한이 없습니다.

다음 함수는 AvatarAttach 컴포넌트는 Transform 컴포넌트의 값을 덮어씁니다. Transform 컴포넌트에 넣은 값은 플레이어의 Transform에 대한 엔티티의 상대 위치로 대체되며, 이 값들은 플레이어가 움직이고 애니메이션할 때 프레임마다 업데이트됩니다.

아바타의 앵커 포인트에서 오프셋을 두거나 다른 회전 또는 크기로 엔티티를 배치해야 한다면, 부모 엔티티를 통해 수행하세요.

다음만 포함된 보이지 않는 엔티티를 만드세요. Transform 및 AvatarAttach 컴포넌트. 해당 Transform 값은 플레이어가 움직일 때 덮어써집니다
부모의 자식으로 첨부하려는 엔티티를 설정하세요. 그 Transform 값은 앵커 포인트로부터의 오프셋을 설명할 수 있습니다.

// 부모 엔티티 생성
const parentEntity = engine.addEntity()

// 부모 엔티티를 플레이어에 첨부
AvatarAttach.create(parentEntity, {
	anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG,
})

// 자식 엔티티 생성
let childEntity = engine.addEntity()

MeshRenderer.setCylinder(childEntity)

Transform.create(childEntity, {
	scale: Vector3.create(0.2, 0.2, 0.2),
	position: Vector3.create(0, 0.4, 0),
	parent: parentEntity,
})

📔 참고: 첨부된 엔티티에 콜라이더가 있으면, 이 콜라이더가 플레이어의 이동을 막거나 떨림 현상을 일으킬 수 있습니다. 첨부된 엔티티의 콜라이더 물리 레이어를 비활성화하는 것이 좋을 수 있습니다. 참조: 충돌 레이어

📔 참고: 자식 엔티티가 있고 그 전역 위치 및/또는 회전을 알고 싶다면 getWorldPosition 및 getWorldRotation 함수를 사용할 수 있습니다. 전역 위치 및 회전 가져오기 섹션에서 확인할 수 있습니다.

다른 플레이어에 첨부

엔티티를 다른 플레이어에 첨부하려면 AvatarAttach 컴포넌트를 사용할 수 있습니다. 이를 위해서는 플레이어의 ID를 알아야 합니다.

다른 플레이어의 아바타에 엔티티를 첨부하려면 필드 avatarId에 사용자의 ID를 제공해야 합니다. 다양한 방법이 이 데이터를 얻는 데 사용됩니다.

📔 참고: Ethereum 지갑에 연결된 플레이어의 경우, 그들의 userId 는 Ethereum 주소와 동일합니다.

다음을 가져오세요. userId 를 다른 주변 플레이어 전부에 대해 getPlayer()

executeTask(async () => {
	for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) {
		console.log('Player id: ', data.address)
	}
})

이것을 AvatarAttach와 함께 사용하면, 다음 코드를 사용해 씬의 다른 모든 플레이어의 머리 위에 떠 있는 큐브를 추가할 수 있습니다:

executeTask(async () => {
        for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) {
            const myEntity = engine.addEntity()
            MeshRenderer.setBox(myEntity)
            AvatarAttach.create(myEntity, {
                anchorPointId: AvatarAnchorPointType.AAPT_LEFT_HAND,
                avatarId: data.address,
            })
        }
    })

다른 사용자의 ID를 가져오는 다른 방법은 플레이어 데이터 가져오기.

씬 경계

씬의 모든 엔티티는 씬 경계 안에 들어가야 합니다. 그 경계 밖은 다른 플레이어가 소유한 땅이기 때문입니다.

미리 보기 실행 시 모델의 일부가 이러한 한계를 넘어가면, 넘어간 부분은 잘려 나가 렌더링되지 않으며, 미리 보기와 게시된 씬 모두에서 동일합니다.

씬 내 엔티티의 위치는 이동하는 동안 지속적으로 확인되며, 엔티티가 씬을 벗어났다 다시 들어오면 제거된 뒤 다시 정상적으로 렌더링됩니다.

씬 바닥의 격자는 씬의 한계를 보여주며, 기본적으로 범위는 0에서 16까지 x 및 z 축과, 20까지 y 축입니다. 엔티티를 지하에, 즉 y 축입니다.

💡 팁보다 아래에 배치할 수도 있습니다. 씬에 더 많은 parcel이 필요하다면 프로젝트의 scene.json 파일에 추가할 수 있습니다. 참조: 씬 메타데이터 의 지침을 따르세요. 추가한 후에는 격자가 확장되어 추가된 parcel을 덮는 것을 볼 수 있습니다.

이전색상 유형

다음조명

마지막 업데이트 10일 전