들어가며

Unity의 Physics.Raycast는 직선을 씬에 투영하여 대상에 적중되면 true를 리턴하는 물리 함수다. Raycast 함수는 캐스팅 성공 실패에 따른 결과만 리턴하는 간단한 형태에서 부터 대상과 Ray의 충돌에 관련된 자세한 정보를(직선과 객체의 교차 정보. 거리, 위치, 캐스팅에 검출 된 객체의 Transform에 대한 참조 등) 리턴하는 다양한 버전이 제공 되고 있다.

이번 포스트에서는 Raycast 함수를 사용하기 위해 알아야할 필수적인 요소들을 살펴 보는 시간을 갖도록 하겠다.

Unity에서 Raycast를 사용하는 법

Unity 2020.3 버전 기준으로 Physics.Raycast는 아래와 같이 다양한 버전으로 오버로드 되어 제공되고 있다. 

bool Raycast(Vector3 origin, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);
bool Raycast(Vector3 origin, Vector3 direction, out RaycastHit hitInfo, float maxDistance, int layerMask, QueryTriggerInteraction queryTriggerInteraction);
bool Raycast(Ray ray, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);
bool Raycast(Ray ray, out RaycastHit hitInfo, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);

파라메터가 많아 복잡해 보이지만 디폴트 파라메터들을 제외하고 보면 결국 Raycast 함수의 핵심은 아래 세가지 정도로 요약 된다.

  • Ray 변수 : 직선의 시작점(origin)과 방향(direction)을 가지고 있는 구조체다.
  • RaycastHit 변수 :  객체와 Ray의 충돌에 대한 결과 정보를 저장하는 구조체
  • Raycast 함수 

Ray 구조체 사용법

Ray는 직선의 시작점(origin)과 방향(direction)을 가지고 있는 단순한 구조체다.

시작점(origin)은 Vector3 타입의 월드 포지션이며 방향(direction)은 직선의 방향을 나타낼 Vector3 타입의 법선 벡터다. 

Unity에서 Ray를 생성성할 수 있는 방법은 여러가지가 있다. 먼저 new를 이용해 직접 생성하는 방법이다.

// Creates a Ray from this object, moving forward
Ray ray = new Ray(transform.position, transform.forward);

카메라 뷰포트 중앙에서 시작하는 Ray와 같은 경우 헬퍼 함수를 이용해 아래와 같이 Ray를 자동으로 생성 할 수 있다.

// Creates a Ray from the center of the viewport
// 아래에서 0.5f 값은 뷰포트의 중간값을 나타낸다.
Ray ray = Camera.main.ViewportPointToRay(new Vector3 (0.5f, 0.5f, 0));

스크린의 마우스 위치로 부터 Ray를 만들어 낼수도 있다.

// Creates a Ray from the mouse position
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

이런 헬퍼 함수들을 사용하여 월드의 특정 지점에서 부터 쉽게 Ray를 만들수 있다.

여기서 주의해야 할 부분은 Ray는 사용할 때 마다 업데이트 되어야만 한다는 것이다. 예를 들어 Ray의 시작점과 방향이 매 프레임마다 달라지는 경우 Ray도 매 프레임 마다 갱신되어야 한다.

Ray ray;
void Update() {
    ray = transform.position, transform.forward;
}

이렇게 Ray가 시작되는 위치와 방향을 결정했으면 Ray로 부터 얻은 데이터를 RaycastHit 변수에 저장한다.

RaycastHit 구조체 사용법

RaycastHit은 객체와 Ray의 충돌에 대한 결과 정보를 저장하는 구조체다. Raycast 함수의 out 파라메터로 사용되며 월드에서 레이캐스팅 히트가 발생한 위치, Ray가 충돌한 물체, Ray의 원점에서 얼마나 떨어져있는지 등의 정보를 저장하여 돌려준다.

Variables

barycentricCoordinate 충돌한 triangle의 무게중심 좌표
collider 충돌한 collider
distance Ray의 origin으로부터 충돌 지점까지의 거리
lightmapCoord 충돌 지점의 uv lightmap 좌표
normal Ray가 충돌한 surface의 normal
point Ray가 충돌한 Collider의 충돌 지점 (world 좌표 사용)
rigidbody 충돌한 collider의 rigidbody (rigidbody가 없는 경우 null 반환)
textureCoord 충돌 위치에서의 uv texture 좌표
textureCoord2 충돌 위치에서의 2차 uv texture 좌표
transform 충돌한 Transform의 Rigidbody 또는 Collider
triangleIndex 충돌한 triangle의 index

RaycastHit를 사용하기 위해선 다음과 같이 선언한다.

// Container for hit data
RaycastHit hitData;

그리고 Raycast 함수를 통해 씬에 Ray를 발사하면 캐스팅 결과에 따라 충돌에 대한 정보를 RaycastHit 변수에 저장한다. 여러분은 RaycastHit에 저장된 정보들을 아래와 같이 접근할 수 있다.

먼저 RaycastHit.point를 이용하여 월드에서 레이캐스팅이 감지된 위치를 얻을 수 있다.

Vector3 hitPosition = hitData.point;

또는 RaycastHit.distance를 사용하여 Ray의 원점에서 충돌 지점까지의 거리를 구할수 있다.

float hitDistance = hitData.distance;

Tag와 같은 히트 된 대상 객체의 Collider 세부 정보를 얻을수도 있다.

// Reads the Collider tag
string tag = hitData.collider.tag;

RaycastHit.transform을 사용하여 충돌 객체의 Transform에 대한 참조를 얻을 수도 있다.

// Gets a Game Object reference from its Transform
GameObject hitObject = hitData.transform.gameObject;

Ray와 RaycastHit 변수는 Ray가 어디로 발사되고, 그에 따른 충돌 정보가 어떻게 저장 될지를 정의하지만 이 두 가지로는 아무것도 할 수 없다. 그래서 실제 씬에서 Ray를 발사하고 충돌이 있는지 확인하기 위해서는 Raycast 함수를 사용해야 한다. Raycast 함수를 사용하는 방법은 다음과 같다.

Raycast 함수 사용법

Unity의 Raycast 함수를 사용하면 Ray가 씬의 다른 객체와 충돌하는지 여부를 알 수 있으며 충돌할 경우 충돌 정보를 RaycastHit 변수에 저장할 수 있다.

여러 버전의 Raycast함수가 있지만, Raycast를 사용하는 가장 일반적인 방법 중 하나는 Ray의 객체에 대한 히트여부에 따라 true 또는 false를 리턴하고, out 파라메터로 RaycastHit를 리턴하는 버전을 사용하는 것이다.

// public static bool Raycast(Ray ray, out RaycastHit hitInfo);
void FireRay(){
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hitData;
    Physics.Raycast(ray, out hitData);
}

위와 같이 하면 생성된 Ray가 씬으로 발사되고 Ray에 충돌한 어떤 것이든 그것에 관한 충돌 정보가 RaycastHit 변수에 저장된다.

앞에서 Physics.Raycast 함수의 리턴 타입은 bool이라고 했다. Ray에 어떠한 오브젝트라도 걸리면 true를 리턴한다. 이는 if 문을 이용하여 raycasting이 성공했을때 그에 대한 처리를 추가 할 수 있다는 뜻이다.

 
void Update() {
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hitData;
    if (Physics.Raycast(ray, out hitData)){
        // The Ray hit something!
    }
}

위와 같은 방법으로 Ray가 실제로 무엇인가에 충돌 했을 때만 if 문 내의 코드가 실행되도록 할 수 있다. 이는 RaycastHit 변수에 실제 충돌 정보가 저장 되었을 때만 RaycastHit을 사용하도록 제한 할 수 있다는 뜻이다. 

그리고 위 예제 코드에서는 간략한 소개를 위해 생략 되었지만 Raycast함수는 추가 디폴트 인자를 가지고 있다[여기]. 이 인자들을 이용해 Ray의 충돌 탐지 거리 제한, 특정 레이어 또는 트리거 콜라이더 무시하기 등의 제약사항을 추가할 수 있다. 이러한 세팅들은 어떤 오버로드 된 레이케스트 함수를 사용하느냐에 따라 달라진다.

Raycast 함수의 다양한 기능들

Unity에는 다양한 버전의 Raycast함수가 있으며 각각은 서로 약간 다른 기능을 제공하고 있다. 일부 버전은 몇가지 인자만 사용하여 간단한 기능만 수행하지만 다른 오버로드된 버전은 더 복잡한 인자들을 받아들이고 더 복잡한 작업을 한다.

예를들어 가장 기본적인 버전의 Physics.Raycast는 인자로 Ray 변수 하나만 받는다.

if (Physics.Raycast(ray)) { 
    // The Ray hit something
}

다른 오버로드 된 버전의 Physics.Raycast는 Ray, RaycastHit, MaxDistance, LayerMask(특정 레이어가 포함되거나 제외 되는 것을 지정) 및 TriggerCollider를 사용할 수 있는지 여부를 결정하는 QueryTriggerInteraction을 설정할 수 있다.

public LayerMask layerMask;
void Update() {
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hitData;

    if (Physics.Raycast(ray, out hitData, 10, layerMask, QueryTriggerInteraction.Ignore))
    {
        // The Ray hit something less than 10 Units away,
        // It was on the a certain Layer
        // But it wasn't a Trigger Collider
    }
}

이제 부터 Raycast 함수들이 제공하는 기능들에 대해 살펴 보도록 하자.

최대거리를 지정하여 Raycast 범위 제한

대부분의 오버로드 된 Physics.Raycast에서는 아래와 같이 레이캐스팅 최대 거리를 제한 할 수 있다.

Ray ray = new Ray(transform.position, transform.forward);
if (Physics.Raycast(ray, 10)) { 
    // Hit Something closer than 10 units away
}

최대 거리를 제한하므로써 최대 사거리가 있는 발사 무기의 명중 판정이라던지, 단순히 씬 전체를 무한히 가로질러 발생할 수 있는 다양한 문제를 예방할 수 있다.

하지만 거리 제한만으로 충분 할까? 아니다. 제한된 거리 내에서도 다양한 충돌 객체가 감지될 수 있다. 어떤 객체가 충돌에 감지 되어야 하고 그렇지 않은지를 결정하는 것은 전적으로 여러분에게 달려 있다. 이제 부터 알아 볼 것은 충돌이감지 되었을 때 어떻게 구분하여 별도의 처리를 해줄 수 있는지를 살펴 보도록하겠다.

Raycast에 Layer Mask 사용하기

Raycast 함수의 유용한 기능 중의 하나는 레이어에 따라 충돌체를 필터링하는 기능이다. 이를 통해 레이캐스팅에서 무시해야하는 객체를 쉽게 구분할 수 있다. 만일 당신이 아주 커다란 씬에서 엄청나게 많은 객체들이 있고 각각의 객체들이 서로 다양한 타입을 가지고 있다고 상상해보자. 이 기능은 이럴때 당신에게 필요한 특정 몇몇 객체들에 대해서만 레이캐스팅을 진행할 수 있게 해주는 아주 유용한 도구다.

예를 들어 지금 'world'라는 레이어가 있고 해당 레이어의 객체들만 레이캐스팅을 이용해 감지하려고 한다고 가정해보자. 당신이 가장 먼저 해야할 일은 퍼블릭 LayerMask 변수를 생성하는 것이다.

public class CameraRay : MonoBehaviour {
    public LayerMask worldLayer;
    // ...
}

이렇게 public으로 선언된 LayerMask 변수는 인스펙터에서 셋팅이 가능하다.

이제 스크립트에서 아래와 같이 Raycast 함수에 LayerMask 변수를 넘겨 주기만 하면 된다.

public class CameraRay : MonoBehaviour {
    public LayerMask worldLayer;
    void FireLaser() {
        Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
        if (Physics.Raycast(ray, 10, worldLayer)) {
            Debug.Log("You hit a wall, good job!");
        }
    }
}

이렇게 하면 오직 "world" 레이어에 속한 객체들에 대해서만 레이캐스팅 검사를 진행하게 된다.

LayerMask를 사용할 때 레이어 번호를 직접 입력하는 방법

public 변수를 이용해 LayerMask를 선언하고 인스펙터에서 레이어를 지정하는 방법은 분명히 간단하면서도 쉬운 방법이지만 우리는 때로 스크립트에서 레이어 마스크를 동적으로 지정해야할 필요가 있을 때도 있다.

public static bool Raycast(Vector3 origin, Vector3 direction, float maxDistance = Mathf.Infinity, int layerMask = DefaultRaycastLayers, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.UseGlobal);

레이어 마스크를 인자로 받는 Raycast 함수를 살펴 보면 int 타입을 요구하기 때문에 혹시 여러분 중에서 인스펙터의 레이어 번호를 인자로 넘기면 될것이라고 생각하는 사람이 있을 수도 있다. 아래 그림을 예로 들어 설명하면 'Server' 레이어를 선택하기 위해 9를 넘기면 될것이라 생각할 수 있다. 결론 부터 말하자면 그렇게하면 안된다.

유니티에서는 총 32개의 레이어를 지원하며 각 레이어를 구분하기 위해 32bit 비트 마스크를 사용한다. 레이어는 0부터 시작하며 31이 마지막 레이어 번호다.

9번 레이어를 선택하고 싶다면, layerMask인자로 9를 넘겨주는 것이아니라 9번 레이어는 오른쪽에서 부터 0을 포함해 10번째 이므로 아래와 같은 비트 마스크를 만들어야 한다.

그럼 정수를 이용해 유니티가 사용하는 이진값을 만들기 위해서는 어떻게 해야 하는가? 이진수는 오른쪽에서 왼쪽으로 계산되며 한칸씩 왼쪽으로 이동할때 마다 2배씩 증가한다. 예를 들어 숫자 8은 이진수로 1000이다. 

반면 9는 아래와 같이 마스킹 된다.

만일 여러분이 9번 레이어를 선택하기 위해 9를 넘기게 되면 결과적으로 위 그림과 같이 마스킹 되어 0번, 3번 레이어가 선택 되게 된다. 여러분이 9번 레이어를 선택하기 위해서는 9가 아닌 512를 넘겨 주어야 한다.

if (Physics.Raycast(ray, 10, 512)) {
    // Layer 9 was hit!
}

만일 9번과 4번 레이어를 동시에 선택하고 싶다면 아래와 같이 528을 넘겨야 한다.

if (Physics.Raycast(ray, 10, 528)) {
    // Layer 9 or 4 was hit!
}

정수를 LayerMask 값으로 변환하는 방법

앞에서 우리는 Unity는 레이어를 지정하기 위해 32bit 비트 마스크를 사용하고 있고, 레이어를 지정하기 위해서는 각 레이어 순서의 플래그가 켜져 있는 이진 값을 넘겨 줘야함을 배웠다. 하지만 앞의 예제는 우리가 이해하기에 직관적이지 못했다. 지금 부터는 쉬프트 연산자(<<)를 이용해 보다 쉽게 레이어 마스크 값을 구하는 방법에 대해 살펴 보도록 하겠다.

쉬프트 연산을 이용하는 것은 매우 간단하다. 위의 예제에서 처럼 9번 레이어를 선택하기 위해서는 0번째 레이어 마스크를 켜고 쉬프트 연산자(<<)를 이용해 왼쪽으로 9번 이동시켜 주면 된다.

if (Physics.Raycast(ray, 10, 1<<9)) {
    // Layer 9 was hit!
}

위와 같은 방식으로 단일 레이어에 대한 충돌을 감지할 수 있다. 그럼 특정 한 레이어만을 제외한 다른 모든 레이어에서 충돌을 감지하고 싶다면 어떻게 해야 할까?

하나를 제외한 모든 레이어에서 Raycast 감지

LayerMask를 사용하여 특정 레이어의 충돌을 감지할 때와 마찬가지로 LayerMask 값을 반전(invert)하여 지정된 레이어를 제외한 모든 레이어에 대해 충돌을 감지할 수 있다.

이건은 비트 연산자 중 NOT(~)연산자를 이용하면 된다. 비트 NOT 연산은 물결표(~)를 사용하고 모든 비트를 뒤집어 반전 시킨다. 예를 들어 9번 레이어를 제외한 모든 레이어에대해 감지하고 싶다면 다음과 같이 하면 된다.

Ray ray = new Ray(transform.position, transform.forward);
if (Physics.Raycast(ray, 10, ~(1<<9))) {
    Debug.Log("something else was hit");
}

비트 연산자를 사용하여 코드에 레이어 마스크를 직접 추가하는 경우 값을 반전하기 전에 비트 연산이 먼저 수행 되도록 괄호 안에 배치하는 것이 좋다.

만일 LayerMask 변수를 따로 가지고 있다면 아래와 같이 간단하게 처리할 수도 있다.

public LayerMask worldLayer; // 레이어 마스크 변수

void FireLaser() {
    Ray ray = new Ray(transform.position, transform.forward);

    if (Physics.Raycast(ray, 10, ~worldLayer)) {
        // Something other than the world was hit!
    }
}

레이어 이름으로 레이어 번호를 알아 오는법

앞의 예제에서는 레이어를 지정하기 위해 레이어 번호를 직접 입력했다. 하지만 여러 가지 개발적 이슈로 인해 레이어의 번호가 변경 될 수도 있다. 이 때 마다 코드를 검색하여 레이어 번호를 사용하는 부분을 일일이 수정한다는 것은 비효율적인 일이다. Unity에서는 레이어의 문자열 이름으로 부터 레이어 번호를 얻을 수 있는 LayerMask.NameToLayer 헬퍼 함수를 제공하고 있다.

예를 들어 5번 레이어의 이름이 "UI"라고 가정한다면 아래와 같은 코드는 정수 5를 리턴한다.

int layerNum = LayerMask.NameToLayer("UI");
Debug.Log(layerNum); // 5

주의 할 점은, NameToLayer 함수에서 리턴 되는 값을 바로 Raycast에 사용하면 안된다는 것이다. 앞에서 이미 다루었듯이 레이어 마스크는 이진 데이터를 파라메터로 받는다. 쉬프트 연산을 통해 해당 위치의 비트를 켜주어야 한다.

Ray ray = new Ray(transform.position, transform.forward);
int layerNum = LayerMask.NameToLayer("UI");

if (Physics.Raycast(ray, 10, 1<<layerNum)) {
​​​​Debug.Log("something else was hit");
}

레이어 번호로 레이어 이름을 알아 오는법

앞에서 레이어 이름으로 레이어 번호을 알아 왔듯이 레이어 번호를 이용해 레이어의 이름을 알아 낼 수도 있다.

int layerNum = LayerMask.NameToLayer("UI");

string layerName = LayerMask.LayerToName(layerNum);
Debug.Log(layerName); // UI

Raycast를 사용할 때 trigger collider를 무시하는 법

만일 Raycast 함수가 trigger collider에 대해서 동작하는 것을 원치 않는 경우 해당 객체를 별도의 레이어에 배치하는 방법도 있겠지만 그리 좋은 방법은 아니다. 이번 섹션에서는 레이어에서 트리거 콜라이더를 무시하는 방법에 대해 살펴 보도록하겠다.

기본적으로 raycasting은 트리거 콜라이더를 감지한다. 레이캐스트가 트리거 콜라이더에 충돌하면 다른 콜라이더와 동일한 방식으로 동작한다. 하지만 프로젝트 설정을 통해 전역적으로 또는 Raycast별로 동작을 변경할 수 있다.

모든 Raycast Trigger 충돌을 비활성화 하는 법

모든 Raycast 트리거 충돌을 비활성화 하는 가장 간단한 방법은 프로젝트 셋팅에서 해당 옵션을 끄는 것이다. Project Setting를 열고 Physics 메뉴를 선택후 Queries Hit Trigger의 체크를 해제한다.

이제 기본적으로 Raycast는 모든 트리거 충돌을 무시하게 된다. 그리고 이 옵션을 끈 상태에서도 Raycast 함수의 QueryTriggerInteraction 파라메터를 이용해 전역 설정을 덮어 쓸 수 있다.

void FireLaser() {
    Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
    if (Physics.Raycast(ray, 10, worldLayer, QueryTriggerInteraction.Ignore)) {
        // Whatever you hit, it wasn't a trigger
    }
}

QueryTriggerInteraction 파라메터는 아래 세 가지 중 하나의 값을 가질 수 있다.

  • Ignore - 트리거 콜라이더의 충돌을 무시한다.
  • Collider - 트리거 콜라이더의 충돌을 허용한다.
  • UseGlobal - Physics 옵션에 정의된 기본 값을 따른다
※ Physics2D.Raycast 의 경우에는 위와 같은 enum 값이 아닌 Physics2D.queriesHitTrigger를 이용하여 true, false를 사용한다고 한다.
https://stackoverflow.com/questions/44402021/how-to-make-raycast-ignore-trigger-colliders

Raycast를 이용하여 여러 물체를 맞추는 법

Raycast 함수는 단일 객체에 충돌이 발생하면 true를 리턴하고 멈춘다. 하지만 때때로 레이저가 여러 물체를 관통하는 것과 같이 동일 Ray를 사용하여 여러 객체에 대한 충돌을 검사해야 하는 때가 있다. 이런 경우 단일 객체에 대한 레이캐스팅을 진행하는 Raycast 함수 대신 RaycastAll을 사용할 수 있다.

하나의 Ray로 여러 객체에 대한 충돌을 검사하고 싶을 때는 RaycastAll을 사용한다.

RaycastAll 함수 사용법

RaycastAll 함수는 기본적으로 Raycast함수와 매우 비슷하게 동작한다. 단 Raycast 함수에서 단 하나의 객체에 대한 충돌 정보만 반환하는 대신 RaycastHit 구조체 배열을 이용해 여러 개체에 대한 충돌 정보들을 반환한다. 

public RaycastHit[] hits;

void Update() {
    Ray ray = new Ray(transform.position, transform.forward);
    hits = Physics.RaycastAll(ray);
}

RaycastAll은 단일 Ray를 사용하여 총돌한 여러 객체에 대한 정보를 얻는데 사용 된다. 예를 들어 아래와 같이 Ray가 충돌한 객체들의 개수를 알아 낼 수 있다.

int numObjectsHit = hits.Length;

아니면 Ray의 경로에 있던 모든 객체들을 파괴하는데 사용 될 수도 있다.

public class CameraRay : MonoBehaviour {
    public RaycastHit[] hits;

    void Update() {
        if(Input.GetMouseButtonDown(0)) {
            FireLaser();
        }
    }

    void FireLaser() {
        Ray ray = new Ray(transform.position, transform.forward);
        hits = Physics.RaycastAll(ray);

        foreach(RaycastHit obj in hits) {
            Destroy(obj.transform.gameObject);
        }
    }
}

 

RaycastAll의 문제

앞에서와 같이 RaycastAll은 Ray에 충돌하는 모든 객체에 대한 정보를 얻어 오는데 유용하게 사용 될 수 있다. 단, RaycastAll은 여러 충돌체를 감지 할 수는 잇지만 정의되지 않은 순서로 검색한다. 우리가 직관적으로 생각하기에 RaycastAll에 의해 리턴 되는 정보는 물체를 통과한 레이저로써 시작점과 가까이 있는 순서대로 배열에 들어갈것 같지만 실제 결과값은 예측 할 수 없는 순서로 저장된다. 

결과값에 대해 동시에 처리를 한다면 이렇게 순서가 뒤섞이는것이 문제가 되진 않지만 순서가 중요하다면 아래와 같이 거리에 따라 배열을 정렬하는 방법도 있다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

void FireLaser() {
    RaycastHit[] hits;
    Ray ray = new Ray(transform.position, transform.forward);
    hits = Physics.RaycastAll(ray);

    // Sorts the Raycast results by distance
    Array.Sort(hits, (RaycastHit x, RaycastHit y) => x.distance.CompareTo(y.distance));
}

RaycastAll vs RaycastNonAlloc

RaycastNonAlloc은 앞에서 살펴본 RaycastAll과 매우 유사하게 동작한다. 단, 한가지 차이점이 있다면 RaycastNonAlloc은 RaycastAll 처럼 호출 될 때 마다 내부적으로 RaycastHit 배열을 생성 후 리턴하는 방식이 아니라, 외부에서 이미 생성된 배열을 out 파라메터로 재사용 할 수 있어 가비지(garbage)의 발생을 줄인다.

RaycastNonAlloc는 충돌한 객체의 개수를 리턴하지만 그 수는 인자로 넘겨진 배열의 길이 보다는 크지 않다. 실제 반환된 충돌된 객체의 개수를 알면 리턴된 배열이 가득 차지 않았을 때 빈 요소들을 참조하는 것을 방지할 수 있다.

RaycastHit[] results = new RaycastHit[10];

void Update(){
    if (Input.GetMouseButtonDown(0)) {
        FireLaser();
    }
}

void FireLaser(){
    Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
    int hits = Physics.RaycastNonAlloc(ray, results);

    for(int i=0; i < hits; i++){
        Destroy(results[i].transform.gameObject);
    }
}

일반적으로 RaycastNonAlloc은 RaycastAll 보다 효율적인 버전이다. 하지만 RaycastAll과 마찬가지로 RaycastNonAlloc 역시 정의되지 않은 순서로 충돌 정보 배열을 리턴한다. 이게 왜 문제가 되냐면 RaycastNonAlloc으로 부터 리턴 되는 충돌 객체에 대한 정보들은 지정된 배열의 길리 제한으로 인해 모두 리턴 되지 않을 수 있다. 이 배열은 정의 되지 않은 순서로 저장되기 때문에 리턴된 충돌 정보들이 시작점으로 부터 가까운 객체들이라는 보장이 없다.

예를 들어 최대 3명의 적을 관통하는 무기를 만들려는 경우, 결과를 받아올 RaycastHit 배열의 크기가 3인 경우, RaycastNonAlloc을 사용하면 3개의 결과가 반환 되긴하지만 이 결과를 정렬하더라도 가장 가까운 3개가 될것이라는 보장을 하지 못한다.

 

RaycastNonAlloc이 얼필 보면 성능을 향상 시킬 수 있는 좋은 방법 처럼 보이지만 위와 같은 문제가 있다. 따라서 이를 효과적으로 사용하려면 LayerMask와 같은 기능들을 사용하여 raycasting 결과로 리턴되는 개수가 한정적일 때 최대 길이의 배열을 사용하여 반복적인 배열을 재할당 없이 사용하는 것이 가장 적합한 방법이다.

https://kukuta.tistory.com/391

 

[Unity] Physics.Raycast 완벽 가이드

들어가며 Unity의 Physics.Raycast는 직선을 씬에 투영하여 대상에 적중되면 true를 리턴하는 물리 함수다. Raycast 함수는 캐스팅 성공 실패에 따른 결과만 리턴하는 간단한 형태에서 부터 대상과 Ray의

kukuta.tistory.com

 

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

라이트매핑  (0) 2023.03.19
네비게이션과 경로탐색  (0) 2023.03.19
카메라 - 유니티  (0) 2023.03.03
마우스좌표를 월드좌표로 - 2D  (0) 2023.03.02
[유니티매뉴얼] Unity의 회전 및 방향  (0) 2023.02.28
Unity가 편한 개발 엔진이라고 아무런 기본 지식 없이 마냥 닥치는대로 하려다보니 이래저래 어려움이 많다. 이 포스팅에서는 Unity를 사용하면서 개인적으로 계속 헷깔렸던 부분들을 정리 한다.

Transform.SetParent 의 worldPositionStays 인자

  • worldPositionStays 가 true일 경우 :
    SetParent시 자식이 되는 오브젝트의 월드 좌표는 변경되지 않는다(화면상으로 보기엔 그냥 그대로 있는것 같다는 말).
    하지만 부모가 변경 되었으므로 로컬 좌표가 변경된다(이것을 이해하기 위해서는 월드 좌표와 로컬 좌표의 개념을 알아야 한다. 하지만 나는 이미 알고 있으므로 이 포스트에서는 다루지 않는다).

    예를 들어 부모가 없는 두 오브젝트(부모가 없다는 것은 월드 포지션과 로컬 포지션이 같다는 의미) A가 (0, 1)에, 오브젝트 B가 (1, 0)에 있는 경우, SetParent 함수 호출시 worldPositionStays를 true로 하면 자식이 되는 오브젝트 B의 월드 포지션은 여전히 (1, 0)이고 부모와의 관계를 나타내는 로컬 포지션은 (1, -1)로 변경 된다(유니티 인스펙터에는 로컬 포지션이 표시된다).
  • worldPositionStatys가 false일 경우 :
    자식이 되는 오브젝트의 로컬 좌표 값을 새로운 부모와 그대로 유지한다. 오브젝트 B가  오브젝트 A의 자식이 되는 경우 B의 로컬 포지션(1, 0)은 그대로 유지되며 대신 월드 포지션이 변경 된다.

LLVM(Low Level Vritual Machine)

프로그램을 컴파일 타임, 링크 타임, 런타임 상황에서 프로그램의 작성 언어에 상관 없이 최적화를 쉽게 구현할 수 있도록 구성. LLVM으로 언어에 가상 기계를 생성, 가상 기계가 언어에 독립적인 최적화를 실행한다.

IL2CPP(Intermediate Language to CPP)

유니티 2차원 좌표계

Resources

GameObject

Transform

  • http://docs.unity3d.com/ScriptReference/Transform.html
  • scene 안에 있는 모든 객체들이 가지고 있는 위치, 스케일, 회전 정보
  • transform은 부모 transform을 가질 수 있다
  • localPosition은 부모의 transform에 상대적 위치 정보
  • GetComponentXXX<T> 함수들을 잘 이용하면 객체들을 찾기가 쉬워진다.

RectTransform

  • http://docs.unity3d.com/ScriptReference/RectTransform.html
  • 주로 UI를 위해 사용 됨(아마도..)
  • 위치, 사이즈, 앵커, 피봇 관련 정보들을 담고 있음
  • sizeDelta : RectTransform의 앵커 기준 상대적 사이즈. 만일 앵커가 붙어 있다면 sizeDelta는 size와 동일하다. 만일 앵커가 부모의 각 네 코너에 맞춰져 있다면 sizeDelta는 부모의 사각형 대비 얼마나 크거나 작은지를 나타낸다.
  • rect : eg. rectTransform.rect.height 으로 RectTransform 객체의 높이를 가져 올 수 있다

Gizmo

애니메이션 종료 여부 알아 내기

SVN 연동시 무시 되어도 될 디렉토리와 파일 리스트

안드로이드에서 파일 read/write 하기

saving and loading player game data in unity 

4.6 UI Text rect does not expand automatically

ScreenToWorldPoint

Touch Input Position

BoxCollider

  • BoxCollider 를 설정하고 IsTrigger 옵션을 선택하면 OnCollisionXXX 대신 OnTriggerXXX 함수가 호출 된다. IsTrigger 셋팅이 되어있다면 오브젝트간 물리적 상호 작용은 없고 서로 겹칠때 알림만 온다.

Dictionary 시리얼라이즈

content size fitter

부모 객체의 rect를 자식 객체들에 맞춰서 변경 시켜주는 역할. 하지만 자식에 Vertical Layout 혹은 Horizon Layout 같은 Layout이 붙어야 한다. 텍스트 같은 경우는 아마도 예외인것 같다.

JsonUtility

스크립트 직렬화

Application.OpenURL

AudioListener.volumn

마우스 클릭으로 객체 선택하기

한때 카메라를 공부한적이 있어 유니티의 RayCast를 공부하다 보니 다시 한번 빛의 발사와 반사를 생각해 봤다. 인터넷에 자료가 별로없어 직접 만들어봤는데 학문적인 정도는 아니니 참조만 하시기 바란다. 틀릴수도 있음 ㅎㅎ

우리가 물체가 보이는 이유는 광원이 있어서 이다 물론 일부 자체 발광하는 것도 있지만 .

정확히 말해 우리는 물체를 보는것이 아니라 반사되는 빛을 눈을 통해 보고 뇌로 느낄 뿐이다.

다음은 빛이 물체에 반사되는 경로를 보여준다.

1. 전구와 같은 광원은 사방으로 퍼진다.

2. 이중 물체에 반사되어진 빛은 다시 넓게 퍼진다.

3. 만일 앞에 스크린이나 종이가 있다면 이 퍼진 빛들이 충돌하게 되는데 사방에서 온 빛들이 섞여 구분할 수 없다.

4. 실제 우리가 아무리 종이를 쳐다보고 있어도 거울처럼 아무것도 반사되지 않는 점을 생각해보자.

어릴때 핀홀카메라라고 실험해보신 적이 있을것이다. 물체와 종이사이에 작은 구멍이 뚫린 종이를 놓자.

1. 물체에 반사돼 넓게 퍼져나가던 빛중 구멍을 통과하는 일부 빛만 통과되어 건너편 종이에 맺히게 된다. 

2. 물체에 모든 점에 반사되 빛은 건너편 종이에서 섞이지 않게되어 우리가 하나하나의 점을 구분할수 있게되거 전체적으로 상으로 보인다.

3. 종이에 맺힌 상은 상하좌우가 반대로 되게 된다. 집에서 실험해면 역시 허옇게 아무것도 안보인다 왜냐하면 주변에 빛이 너무 밝기 때문이다. 그래서 검은 종이상자로 주변빛을 차단하면 성공하는거다.

4. 방에 창문을 검정색으로 가리고 쪼그만 구멍을 뚫으면 거짓말 처럼 벽에 밖의 풍경이 찍히게 된다.

핀홀카메라의 개선 

핀홀카메라의 단점은 빛이 한구멍만 통과하다보니 어둡다는 거다. 사람의 눈은 렌즈가 있어 빛을 모아 밝은거다. 이걸 흉내내어 핀홀 구멍을 크게해보자 그러면 문제가 물체의 한점에서 반사된 빛민 건너편 스크린에 맺히는게 아니라 널어진 홀만큼의 사이즈 만큼의 반사된빛이 섞이게 되면서 흐릿하게 된다. ㅠㅠ

렌즈로 초점을 모으자

사람의 눈을 잘 보자. 생물시간에 배우셨겠지만. 렌즈가 들어 있다. 렌즈는 빛을 모아준다. 따라서 구멍을 통과한 빛을 렌즈를 통해 한점으로 스크린위에 모이므로 전체적인 이미지는 또렸하게 된다. 

 

그러나 이 렌즈 시스템도 문제가 있다 왜냐하면 렌즈의 초점거리는 정해져 있기 때문에 일정한 거리의 점들만 잘 보이게 되고 더 멀거나 가까운 물체는 다시 흐릿하게 된다.

인간의 눈의 렌즈는 말랑말랑한 수정체로 실시간으로 초점거리를 변경해 다양한 거리의 물체의 초점을 잡을수 있게 만들었다.

우리가 낮에 사물을 보면 단일평면이 아니 꽤 넓은 범위의 물체를 깨끗히 볼수 있어 위의 설명이 거짓말 같지만 낮에는 빛이 밝아 눈의 조리개가 작아지면서 빛이 통과하는 구멍이 작아져 위의 핀홀카메라와 같이 한점만 통과해서 그렇다. 그걸  피사체 심도가 싶다는 표현을 쓴다. 여러분이 좋와하는 뽀샤시는 조리개를 열어 특정한 범위에만 초점을 맺히게히 배경을 흐리는 효과도 이해하길수 있을거다.

 

종이대신 촬상소자를 놔보자

카메라는 촬상소자라는게 있어 빛을 2차원의 전기신호로 바꿔준다.

아래 오른쪽을 보면 4x3의 센서들이 배열로 배열되어 있다. 이걸 전기신호로 바꾸면 해상도가 수평x수직: 4*3인거다. 아마 촬송소자에 비친 이미지는 해상도가 너무 낮아 알아보기 힘들거다. 

하여간 우리 카메라는 지금 4x3의 센서들이고 잘생각해보면 광원에서 출발해서 센서에 도착한 광선의 수는 4*3=12개이다.

우리는 촬상소자 12개에 도착하는 광량을 12번의 계산으로 시뮬레이션할수 있다..해상도만큼의 계산만 하면되는거다.

반사각이 -90~90도 사이의 광선만  CCD에 도달할 것이고 대략 광원의 밝기 x 물체의 질감및 반사각에 따라는 반사율이 될것이다. 

유니티의 게임뷰

유니티는 월드좌표에 조명과 게임오브젝트, 카메라가 배치되어 있다.  위의 그림과 다를게 없다. 해상도가 좀 높을 뿐이다.

따라서 해상도가 1920x1080이라면 약200만개의 광선이 필요하다. 실제적으로는 RGB 3원색 이므로 600만개일수도 있다.  아직 유니티의 내부 렌더링 구조는 모르지만 CCD까지 시뮬레이션 할 필요는 없을것 같고 필홀부분이 카메라의 Origin좌표가 되어 여기를 기점으로 입사광선의 반사율을 계산하면 월드좌표를 게임뷰로 변환할수 있을것 같다.

여태까지 서론이 길었던건 바로 다음 기능을 생각해보기 위해서다.

  • Ray 변수 : 카메라 원점에서 에서부터 타겟지점까지의 벡터, 스크린해상도에 해당하는 광선중 한개
  • RaycastHit 변수  : 충돌 정보가 담기는 변수
  • Raycast 함수 : 레이저를 Ray정보를 이용해서 쏴준다. 

유니티에서는 Origine에서 레이저를 쏴서 충돌검사를 할수 있는데 위의 카메라의 입사하는 광선이 꺼꾸로  카메라 원점에서 부터 발사된다고 생각하면 간단하다.

카메라 원점에서부터 해상도만큼의 광선이 존재할수 있고. 마우스좌표는 이 광선들 중이 하나를 지나가고 이 광선을 추적하면 월드좌표내의 오브젝트의 충돌을 검출할 수 있다.

내 상상이 맞는지는 모르겠지만. Raycast를 공부하면서 느낀점을 정리 해봤다.

카메라 원리

 

Perspective와 Orthographic의 차이

 

 Camera 오브젝트의 Inspector 창에서 Projection의 두 가지 옵션이 있습니다. Percpective Orthographic이 있는데 Percpective는 사물에 대해 원근감과 공간감을 잘 표현하여서 보여주고, Orthographic은 사물에 대해서 원근감과 공간감 없이 표현을 해줍니다. 보통 2D나 2.5D를 제작할 시에는 Orthographic을 사용하여 제작합니다.

Perspective vs Orhographic

뷰 절두체 이해

절두체 는 피라미드 같은 모양의 윗부분을 밑면에 병렬로 잘라낸 입체 형상을 가리킵니다. 이는 원근(Perspective) 카메라에 의해 보여지고 렌더링되는 영역의 형상입니다.

원거리 절단면과 근거리 절단면은 모두 카메라의 XY 평면에 평행하게 위치하고 있으며, 만일 어떤 것이 근거리 절단면보다 카메라에 근접하거나 원거리 절단면보다 카메라에 멀리 떨어져있는 경우에는 렌더링되지 않습니다.

 

카메라에서 일정 거리 떨어진 절두체의 크기

카메라에서 일정 거리 떨어진 뷰 절두체의 교차 영역은 가시 영역을 구성하는 월드 공간에서 사각형으로 정의됩니다. 떨어진 거리를 알고 있으면 사각형의 크기를 계산할 수 있고, 사각형의 크기를 알고 있으면 떨어진 거리를 계산할 수 있기 때문에, 이를 유용하게 활용할 수 있습니다. 예를 들어, 움직이는 카메라가 항상 플레이어와 같은 특정 오브젝트를 샷 안에 계속 온전하게 담아내야 할 때, 오브젝트가 잘리지 않도록 카메라의 적정 거리를 유지할 수 있습니다.

일정 거리만큼 떨어진 절두체의 높이(두 값 모두 월드 단위)는 다음 공식을 통해 구할 수 있습니다.

 var frustumHeight = 2.0f * distance * Mathf.Tan(camera.fieldOfView * 0.5f * Mathf.Deg2Rad);

또한 이 과정을 반대로 하면 특정 절두체 높이일 때의 거리를 계산할 수 있습니다.

 var distance = frustumHeight * 0.5f / Mathf.Tan(camera.fieldOfView * 0.5f * Mathf.Deg2Rad);

거리와 높이를 모두 알고 있을 때에는 FOV 각도를 계산할 수도 있습니다.

 var camera.fieldOfView = 2.0f * Mathf.Atan(frustumHeight * 0.5f / distance) * Mathf.Rad2Deg;

각 계산식의 결과를 얻으려면 절두체의 높이를 알아야 하며, 절두체의 높이는 절두체의 너비를 이용하여 쉽게 구할 수 있습니다(절두체의 높이를 이용하여 너비를 계산할 수도 있음).

var frustumWidth = frustumHeight * camera.aspect;
var frustumHeight = frustumWidth / camera.aspect;

카메라에서 나오는 레이

Ray

public Ray (Vector3 origin, Vector3 direction);

origin에서 출발해서 direction을 따라가는 광선을 만듭니다. 

 Ray ray = new Ray(transform.position, transform.forward);

 

카메라의 뷰에서 모든 점은 월드 공간의 하나의 선에 대응됩니다. 때로는 그 선의 수학적인 표현을 사용하는 것이 편리한 경우가 있으며 Unity는 이것을 레이(Ray) 오브젝트로 제공할 수 있습니다. 레이는 항상 뷰 내의 한 점에 부합하므로 Camera 클래스는 ScreenPointToRay  ViewportPointToRay 함수를 제공합니다. 이 둘의 차이는 ScreenPointToRay가 점을 픽셀 좌표를 필요로 하는 반면 ViewportPointToRay는 0..1(뷰에서 0이 왼쪽 또는 아래쪽 1이 오른쪽 또는 위쪽) 범위의 정규화된 좌표를 요구한다는 점입니다. 이 각각의 함수는 원점과 원점으로부터 나가는 선의 방향을 나타내는 벡터로 구성된 레이의 값을 반환합니다. 레이는 카메라의 transform.position 포인트 대​​신 근접 클리핑 평면을 기점으로 하고 있습니다.

레이캐스팅(Raycasting)

카메라를 통한 레이의 가장 일반적인 사용 방법은 씬에 Raycast를 실행하는 것입니다. 레이캐스트는 가상의 “레이저 빔”을 원점에서부터 레이에 따라 씬 안의 콜라이더에 충돌할 때까지 보냅니다. 그 다음 오브젝트와 RaycastHit 오브젝트의 충돌된 점에 대한 정보를 반환합니다. 이것은 스크린상 나타난 이미지를 기반하여 오브젝트가 어디에 위치하는지 찾는 유용한 방법입니다. 예를 들어, 마우스 포지션에 있는 오브젝트는 다음 코드로 확인할 수 있습니다.

using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    public Camera camera;

    void Start(){
        RaycastHit hit;  //충돌정보를 받아오는 변수
        Ray ray = camera.ScreenPointToRay(Input.mousePosition);  //레어저벡터
        
        if (Physics.Raycast(ray, out hit)) { //레이저를 쏨
            Transform objectHit = hit.transform;
            
            // Do something with the object that was hit by the raycast.
        }
    }
}

레이를 따라 카메라 이동

때로는 화면의 한 포지션에 반응하는 레이를 설정하고 카메라를 레이에 따라 이동시키는 것이 유용할 때가 있습니다. 예를 들어, 사용자가 오브젝트를 마우스로 선택하여 동일한 화면 위치를 “고정”하면서 줌인할 경우가 있습니다(이것은 카메라가 전술 지도를 볼 때 유용할 수 있습니다). 이 작업을 위한 코드는 매우 간단합니다.

using UnityEngine;
using System.Collections;

public class ExampleScript : MonoBehaviour {
    public bool zooming;
    public float zoomSpeed;
    public Camera camera;

    void Update() {
        if (zooming) {
            Ray ray = camera.ScreenPointToRay(Input.mousePosition);
            float zoomDistance = zoomSpeed * Input.GetAxis("Vertical") * Time.deltaTime;
            camera.transform.Translate(ray.direction * zoomDistance, Space.World);
        }
    }
}

마우스를 움직여서 2D 오브젝트를 움직여 보겠다 실험을 위해 2D 프로젝트를 만든뒤 2D Sprite Circle을 하나 만들고 포지션을 리셋한다. 나중에 아시겠지만 마우스는 게임오브젝트가 투영되는 스크린의  해상도와 카메라의 Z좌표를 갖는다.

그런데 게임오브젝트는 각자의 좌표가 있고 씬뷰에 보이는 범위는 카메라에 의존한다. 따라서 마우스의 좌표를 게임오브젝트에 적용하기 위해서는 2좌표간의 차이를 알고 변환해 줘야한다.

그다음 ScreenToWorld라는 스크립트를 다음과 같이 붙여준다. 무척 직관적이다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScreenToWorld : MonoBehaviour
{
    public Vector2 mousePosition;

    // Update is called once per frame
    void Update()
    {
        mousePosition = Input.mousePosition;
        transform.position = mousePosition;
    }
}

실행히보면 원이 없어진다. 원인을 찾아보자.  

유니티 2D 기본스크린 화면이다. 객체포지션은 리셋하면  (0,0,0)인데 스크린 범위를 보기위해 (5,4,-10)으로 카메라 Z위치와 맞추었다.

하이라키뷰의 Circle을 클릭하고 Inspector를 보면 포지션이  각자 다르겠지만 마우스좌표는 스크린 좌표라 x:0~1980 y:0~1080,인데 이게 월드봐표 x:±8.8ㄹ y:±5f를 넘어서면 안보이게 된다. 

스크립트에 mousPosition을 Public으로 했기 때문에 마우스를 움직이면 좌표값을 확인할 수 있다.

마우스를 왼쪽아래로 잘 몰아보면 0에 가까워지면서 Circle이 보이게 된다.

문제는 Input.mousePosition과 transform.position과의 차이 때문이다. 왼쪽이 마우스좌표 오른쪽이 transform.position이다

두 시스템의 숫자차이도 문제지만 스크린은 (0,0)점이 좌하이고 월드좌표는 가운데다 따라서 offset(1920/2,1080/2)를 생각해야한다. 월드좌표는 현재 아래와 같고 만일 카메라의 위치 회전에 따라 변화할수 있다.

문제를 알았으니 다음 스크립트를 넣고 다시한번 해보자.

유니티는 모니트의 화면사이즈를 Screen.width, Screen.height로 얻을 수 있고 camera world의 높이를 Camera.main.orthographiSize로 얻을수 있어 이걸 화면비를 곱하면 폭도 얻을 수 있다.

실험을 위해 public변수를 많이 만들었다. 마우스를 움직이면서 봐주길 바란다.

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScreenToWorld : MonoBehaviour
{
    public Vector2 mPos;  //마우스 좌표
    public float mWidth;  //마우스 스크린 폭
    public float mHeight;  //마우스 스크록 높이
    public float wWidth;  
    public float wHeight;
    public float xscale,yscale;

    // Update is called once per frame
    private void Start() {
        mWidth = Screen.width;  //좌측에서 우측까지의 사이즈
        mHeight= Screen.height;  //아래서 위까지의 사이즈
        
        wWidth = Camera.main.orthographicSize * mWidth / mHeight;  //중앙에서 오른쪽까지 화면의 반
        wHeight = Camera.main.orthographicSize;  //중앙에서 위까지의 화면의 반
        yscale = wHeight *2 / Screen.height;
        xscale = wWidth *2 / Screen.width;
    }
    void Update()
    {
        mPos = Input.mousePosition;
        transform.position = MouseToWorld(mPos);
    }
    Vector2 MouseToWorld(Vector2 mPos) {
        return new Vector2((mPos.x - Screen.width/2) * xscale, (mPos.y- Screen.height / 2) * yscale);
    }
}

위 방법은 카메라가 월드좌표의 (0,0,0)을 바라 보고 있을 경우만 잘동작하고 그렇지 않은 경우 잘 안될것이다. 좀더 섬세한 계산이 필요할 것다. 

그런데 유니티가 이럴줄 알고  스크린좌표를 월드좌표를 마련해주었다. 잘보면 Vector2를 사용한다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScreenToWorld : MonoBehaviour
{
    Vector2 worldPosition;
    Vector2 mousePosition;

    // Update is called once per frame
    void Update()
    {
        Screen2World();
        transform.position = worldPosition;
    }
    void Screen2World() {
        mousePosition = Input.mousePosition;
        worldPosition = Camera.main.ScreenToWorldPoint(mousePosition);
    }
}

Vector3를 사용하면 Input.mousePosition의 리턴값의 Z좌표가 카메라의 Z좌표 -10되면서 카메라가 자기와 같은 평면의 Circle을 못보게 된다. 자기눈과 같은 평면에 걸 볼수가 없다. Vector2에서는 Z정보를 전달안하기 때문에 이런 문제가 안 일어 났던거다. 따라서 변환된 world좌표에 게임객체의z좌표를 카피해 주면 간단히 끝난다. 이외에도 방법은 여러가지 생각해보시길

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ScreenToWorld : MonoBehaviour
{
    Vector3 worldPosition;
    Vector3 mousePosition;

    // Update is called once per frame
    void Update()
    {
        Screen2World();
        transform.position = worldPosition;
    }
    void Screen2World() {
        mousePosition = Input.mousePosition;
        worldPosition = Camera.main.ScreenToWorldPoint(mousePosition);
        worldPosition.z = transform.position.z; 
        Debug.Log(mousePosition+ " " + worldPosition);
    }
}

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

[유니티매뉴얼] Physics Raycast Ray RaycastHit  (0) 2023.03.04
카메라 - 유니티  (0) 2023.03.03
[유니티매뉴얼] Unity의 회전 및 방향  (0) 2023.02.28
Vector3  (0) 2023.02.25
변수와 함수  (0) 2023.02.25

검색하다 좋은 블로그들을 모아봤다.

https://fiftiesstudy.tistory.com/261

 

유니티 각개격파_019_스크린 좌표를 월드 좌표로 변환하기

이전 글에서 스크린 좌표계에서 사용하는 위치와 월드 좌표에서 사용하는 위치는 다르다고 했다. 그래서 월드 좌표에 있는 게임오브젝트와 스크린 좌표계를 사용하는 마우스 포인트의 위치는

fiftiesstudy.tistory.com

 

https://blog.naver.com/pa_yu/222137727403

 

[유니티] 지형에 Mouse Picking, 광선생성/발사(ScreenPointToRay/Physics.Raycast), 참조에 의한 전달(out, ref),

Mouse Picking 마우스 픽킹이란? -모니터 화면상의 마우스에서 선택한 위치가 게임공간상에서 '어디...

blog.naver.com

https://kukuta.tistory.com/391

 

[Unity] Physics.Raycast 완벽 가이드

들어가며 Unity의 Physics.Raycast는 직선을 씬에 투영하여 대상에 적중되면 true를 리턴하는 물리 함수다. Raycast 함수는 캐스팅 성공 실패에 따른 결과만 리턴하는 간단한 형태에서 부터 대상과 Ray의

kukuta.tistory.com

https://ssabi.tistory.com/29

 

[Unity] 레이캐스트(Raycast)

레이캐스트는 광선을 쏘는 것을 의미합니다. 여기서는 레이를 쏜다 라고 표현하겠습니다. 레이캐스트를 사용하면 광선에 충돌되는 콜라이더(Collider)에 대한 거리, 위치 등의 자세한 정보를 Raycas

ssabi.tistory.com

https://www.ksakosmos.com/post/%EB%A0%88%EC%9D%B4-%ED%8A%B8%EB%A0%88%EC%9D%B4%EC%8B%B1-ray-tracing-%EA%B3%BC-%EB%B9%9B%EC%9D%98-%EB%AC%BC%EB%A6%AC%ED%95%99

 

레이 트레이싱(Ray Tracing)과 빛의 물리학

레이 트레이싱(Ray Tracing) 기법은 게임을 좋아하는 사람이라면 한 번쯤 들어봤을 것입니다. ‘RTX 2080Ti’ 같이 그래픽 카드 이름에 들어있는 ‘RT’가 바로 Ray Tracing의 약자이죠. 게임 내에서 그래

www.ksakosmos.com

https://kukuta.tistory.com/177

 

Unity를 사용하기 전에 알아두면 좋은 기본 개념들

Unity가 편한 개발 엔진이라고 아무런 기본 지식 없이 마냥 닥치는대로 하려다보니 이래저래 어려움이 많다. 이 포스팅에서는 Unity를 사용하면서 개인적으로 계속 헷깔렸던 부분들을 정리 한다. T

kukuta.tistory.com

https://blog.naver.com/crsores/222496531525

 

35. 게임엔진[3] - Handmade

1. 개념 오늘은 유니티에서 기본적으로 제공되는 오브젝트를 사용하는 것이 아니라, Handmade로 직접 도형...

blog.naver.com

https://woodev.tistory.com/category/~/Computer%20graphics

 

'게임 공부/Computer graphics' 카테고리의 글 목록

 

woo-dev.tistory.com

https://blog.naver.com/marnich/222619469408

 

잘모르는 짧은 공부일기, 33일차 / Unity 기초 03 _ 캐릭터 애니메이션 리깅 리타겟

잘모르고 부족하고 완벽하지 않아도 괜찮아! 한걸음씩 꾸준한게 중요해. 매일 잘 모르는거 조금씩, 깨잘깨...

blog.naver.com

https://kangworld.tistory.com/187

 

[Unity] 절차적 애니메이션(Procedural animation) #1

✍️ 절차적 애니메이션이란? 대부분의 게임에서 캐릭터 애니메이션은 정적이다. 캐릭터가 움직일 때 필요한 동작은 아티스트들이 사전에 만들어놓은 애니메이션을 재생하는 것으로 다른 움직

kangworld.tistory.com

https://blog.naver.com/flypizza/222586053898

 

#6 사냥을 해보자(1)_AnimationController, Transition, HasExitTime [유니티3D 모바일 방치형 키우기 게임 만들

목차는 이곳에서 확인하세요~! https://blog.naver.com/flypizza/222466103340 안녕하세요 유니티쳐 입니다...

blog.naver.com

 

Unity에서는 오일러 각과 쿼터니언을 모두 사용하여 회전과 방향을 나타낼 수 있습니다. 표현은 둘 다 동일하지만 용도와 제한 사항은 서로 다릅니다.

보통 씬에서는 방향을 오일러 각으로 표시하는 트랜스폼 컴포넌트를 사용하여 오브젝트를 회전합니다. 그러나 Unity는 회전과 방향을 내부적으로 쿼터니언으로 저장하므로 짐벌 락으로 이어질 수도 있는 더 복잡한 모션에 유용할 수 있습니다.

오일러 각

트랜스폼 좌표에서 Unity는 벡터 프로퍼티 Transform.eulerAngles X, Y, Z를 사용하여 회전을 표시합니다. 노멀 벡터와는 달리 이 값은 X, Y, Z 축에 대한 실제 회전 각도(단위: 도)를 나타냅니다.

오일러 각 회전은 3개의 축을 중심으로 3개의 개별 회전을 수행합니다. Unity는 Z축, X축, Y축을 중심으로 오일러 회전을 순차적으로 수행합니다. 이 회전 방법은 외부 회전입니다. 회전하는 동안 원래 좌표계가 변경되지 않습니다.

게임 오브젝트를 회전하려면 각 축이 트랜스폼 컴포넌트로 회전할 각의 크기를 입력할 수 있습니다. 스크립트로 게임 오브젝트를 회전하려면 Transform.eulerAngles를 사용합니다. 오일러 각으로 변환하여 계산하고 회전하려면 짐벌 락 문제가 발생할 위험이 있습니다.

짐벌 락

3D 공간에 있는 오브젝트가 자유도를 잃고 2차원 내에서만 회전할 수 있는 경우를 짐벌 락이라고 합니다. 두 축이 평행하면 오일러 각으로 짐벌 락이 발생할 수 있습니다. 스크립트에서 회전 값을 오일러 각으로 변환하지 않으면 쿼터니언을 사용하여 짐벌 락을 방지해야 합니다.

짐벌 락 문제가 있는 경우 Transform.RotateAround를 사용하면 오일러 각을 피할 수 있습니다. 각 축에 Quaternion.AngleAxis를 사용하여 함께 곱할 수도 있습니다(쿼터니언 곱셈은 각 회전에 차례로 적용됩니다).

쿼터니언

쿼터니언은 3D 공간에서 공간 방향과 회전의 고유한 표현을 위한 수학적 표기법을 제공합니다. 쿼터니언은 4개의 숫자를 사용하여 3D에서 단위 축을 중심으로 회전 방향과 각도를 인코딩합니다. 이 4개의 값은 각이나 각의 크기가 아닌 복소수입니다. 자세한 내용은 쿼터니언의 수학을 참조하십시오.

쿼터니언 회전은 계산에 있어 효율적이고 안정적이기 때문에 Unity는 회전 값을 쿼터니언으로 변환하여 저장합니다. 단일 쿼터니언은 축에 대해 360도보다 큰 회전을 나타낼 수 없기 때문에 에디터에서는 회전을 쿼터니언으로 표시하지 않습니다.

Quaternion 클래스를 사용하면 쿼터니언을 직접 사용할 수 있습니다. 회전에 스크립트를 사용하는 경우 Quaternion 클래스와 함수를 사용하여 회전 값을 만들고 변경할 수 있습니다. 회전에 오일러 각으로 값을 적용할 수 있지만 문제를 방지하기 위해 쿼터니언으로 저장해야 합니다.

오일러 각과 쿼터니언 간의 전환

다음 스크립트를 사용하여 쿼터니언과 오일러 각 간을 변환하고 원하는 방식으로 회전을 보고 편집할 수 있습니다.

  • Quaternion.Euler 함수를 사용하여 오일러 각도에서 쿼터니언으로 변환할 수 있습니다.
  • Quaternion.eulerAngles 함수를 사용하여 쿼터니언을 오일러 각으로 변환할 수 있습니다.

중요 클래스 - Quaternion

Unity는 Quaternion 클래스를 사용하여 게임 오브젝트의 3차원 방향을 저장하고, 이를 통해 한 방향에서 다른 방향으로의 상대 회전을 설명합니다.

이 페이지는 Quaternion 클래스의 개요, 그리고 이 클래스를 사용하는 스크립팅의 일반적인 용도에 대해 설명합니다. Quaternion 클래스의 모든 멤버에 대한 전체 레퍼런스는 Quaternion 스크립트 레퍼런스를 참조하십시오.

오일러 각(게임 오브젝트의 회전을 위해 인스펙터에 표시되는 X, Y, Z 값)과 Unity가 게임 오브젝트의 실제 회전을 저장하는 데 사용하는 기본 쿼터니언 값 간의 차이를 이해하고 있어야 합니다. 이 항목에 대한 기본 정보는 Unity의 회전 및 방향을 참조하십시오.

스크립트에서 회전 처리를 다루는 경우 Quaternion 클래스와 이 클래스의 함수를 사용하여 회전 값을 만들고 수정해야 합니다. 오일러 각을 사용할 수 있는 상황도 있지만, 다음 사항을 염두에 둬야 합니다. - 오일러 각을 처리하는 Quaternion 클래스 함수를 사용해야 합니다. - 회전의 오일러 값을 검색 및 수정하고 다시 적용하면 의도하지 않은 부작용이 발생할 수 있습니다(아래 참조).

쿼터니언 직접 생성 및 조정

Unity Quaternion 클래스의 여러 함수를 통해 오일러 각을 전혀 사용하지 않고도 회전을 만들고 조정할 수 있으며, 대부분의 일반적인 경우 이러한 함수들을 사용해야 합니다. 각각의 함수는 코드 샘플이 있는 스크립트 레퍼런스에 연결됩니다.

회전 생성:

회전 조작:

Transform 클래스도 쿼터니언 회전에 사용할 수 있는 다음의 메서드를 제공합니다.

오일러 각 사용

일부의 경우 스크립트에서 오일러 각을 사용하는 것이 더 좋습니다. 이 경우 각을 변수로 유지하고 회전에 오일러 각으로 적용하는 데만 사용해야 하고, 궁극적으로 쿼터니언으로 저장되어야 합니다. 오일러 각을 쿼터니언에서 검색해서 가져올 수 있지만, 검색해서 가져온 후 수정하고 다시 적용하면 문제가 발생할 수 있습니다.

이러한 문제가 정확히 어떻게 발생하는지에 대한 자세한 내용은 eulerAngles 스크립트 레퍼런스 페이지를 참조하십시오.

아래에는 흔히 발생하는 잘못된 방법에 대한 몇 개의 예제가 있습니다. 설명을 위해 X축을 중심으로 게임 오브젝트를 초당 10도씩 회전시키려는 가상의 예제를 사용합니다. 다음 2코드는 잘못된 방법입니다.

// rotation scripting mistake #1
// the mistake here is that we are modifying the x value of a quaternion
// this value does not represent an angle, and does not produce desired results
    
void Update () 
{
    var rot = transform.rotation;
    rot.x += Time.deltaTime * 10;
    transform.rotation = rot;
}

 

// rotation scripting mistake #2
// Read, modify, then write the Euler values from a Quaternion.
// Because these values are calculated from a Quaternion,
// each new rotation might return very different Euler angles, which might suffer from gimbal lock.
        
void Update () 
{
    var angles = transform.rotation.eulerAngles;
    angles.x += Time.deltaTime * 10;
    transform.rotation = Quaternion.Euler(angles);
}

그리고 다음은 스크립트에서 오일러 각을 올바르게 사용하는 예입니다.

// Rotation scripting with Euler angles correctly.
// Store the Euler angle in a class variable, and only use it to
// apply it as an Euler angle, but never rely on reading the Euler back.
        
float x;
void Update () 
{
    x += Time.deltaTime * 10;
    transform.rotation = Quaternion.Euler(x,0,0);
}

오일러각과 쿼터니언각의 차이

새로운 씬을 하나 만들고 Models>Player폴더의 Player를 끌어다 놓습니다. (Prefab은 이미 다른 스크립트가 들어 있어 안됩니다.) 이 강좌가 처음이 신분들은 아무 게임오브젝트를 만들어 놓습니다.

아래 스크립트를 끌어다 적용합니다.

using UnityEngine;
public class ExampleScript : MonoBehaviour {
    float rotationSpeed = 45;
    Vector3 currentEulerAngles;
    Quaternion currentRotation;
    float x;
    float y;
    float z;

    void Update() {
        if (Input.GetKeyDown(KeyCode.Alpha1)) x = 1 - x;
        if (Input.GetKeyDown(KeyCode.Alpha2)) y = 1 - y;
        if (Input.GetKeyDown(KeyCode.Alpha3)) z = 1 - z;
        if(Input.GetKeyDown(KeyCode.Alpha0)) {
            x = 0; y = 0; z = 0;
            currentEulerAngles = Vector3.zero;
        }

        //modifying the Vector3, based on input multiplied by speed and time
        currentEulerAngles += new Vector3(x, y, z) * Time.deltaTime * rotationSpeed;

        //moving the value of the Vector3 into Quanternion.eulerAngle format
        currentRotation.eulerAngles = currentEulerAngles;

        //apply the Quaternion.eulerAngles change to the gameObject
        transform.rotation = currentRotation;
    }

    void OnGUI() {
        GUIStyle style = new GUIStyle();
        style.fontSize = 24;
        // Use eulerAngles to show the euler angles of the quaternion stored in Transform.Rotation
        GUI.Label(new Rect(10, 0, 0, 0), "Rotating on X:" + x + " Y:" + y + " Z:" + z, style);

        //outputs the Quanternion.eulerAngles value
        GUI.Label(new Rect(10, 25, 0, 0), "CurrentEulerAngles: " + currentEulerAngles, style);

        //outputs the transform.eulerAngles of the GameObject
        GUI.Label(new Rect(10, 50, 0, 0), "GameObject World Euler Angles: " + transform.eulerAngles, style);
    }
}

1,2,3을 누르면 해당되는 x,y,z축으로 무한히 회전합니다.

0을 누르면 초기화 됩니다.

Play시켜보면 오일러나 GameObject World Euler Angle 둘 다 (0,0,0)입니다.

처음 1만 눌러 90도 전에 다시 1을 눌러 세워 보겠습니다. 아직 2개의 값은 비슷합니다.

다시1을 눌러 90도가 넘은면 1을 눌러 세워 봅니다. World Euler Angles.x가 줄어들고 y,z가 180됩니다.

일단 1,2,3을 토글하면서 오일러값과 쿼터니언의 값 변화를 보세요 쿼터니언값의 변화는 상식적이지 않습니다. 연속적인 회전이 안됩니다. 

0을 눌러 초기화 합니다

우선 1만 눌러 적당히 90을 만들어 아래로 눕게 합니다. 그다음 2,나 3을 눌러보면 둘다 Y축으로 돌아가는데 하나는 반대로 돌아갑니다. 

이게 짐벌록입니다.  x축을 90돌면서 차일드인 Z축이 같이 돌아 Y축과 겹쳐졌기 때문입니다.  

다른 축으로도 실험해보왔지만 일어나지 않습니다. 이건 유니티의 x,y,z계산 우선순위때문인듯 합니다. 

재미있는건 1을 눌러 90도쯤 변화시켜 눕힌후 2를 눌러 y축을 회전시킨후 3을 누르면 각도는 열심히 변하는데 실제 게임오브젝트는 멈춰있습니다 y축과 z축의 방향이 서로 반대라 합쳐서 0이 되기 때문입니다. 꼭해보시기 바랍니다. 희안합니다.

사진으로 간단하게 설명하겠다.

 

우선 다음 사진과 같이 x, y ,z 축을 가진 오브젝트가 있다고 해보자.

저 화살표가 가리키는 방향을 계속 유의하자. 이 오브젝트의 x(빨간축) 축을 90도 회전시켜보겠다.

x축(빨간축)으로 90도 회전시킨 모습이다.  화살표를 보면 오른쪽 방향을 가리키고 있다. 

여기까지는 문제가 없다. 

자, 그다음 Y축(초록색)으로 90도 회전시켜보겠다.

Y축으로 90 회전시키니 다음과 같은 모습이 된다.

Z 축과 X 축이 한축으로 합쳐지면서 한축에 대한 계산이 불가능해집니다.

이러한 현상을 바로 '짐벌락(Gimbal-lock)' 이라고 한다. 

 

이러한 짐벌락 현상이 생기는 이유는 오일러 앵글이 자체적으로 설정되어있는 순서로 해당 축들을 개별적으로 계산하기 때문이다.

Unity에서는 오일러 앵글이 X, Y, Z 순서로 계산된다.

세 개의 축을 동시에 계산하지 않고 각 축을 독립적으로 판단하기에 다음과 같이 어쩌다가 겹쳐버리는 현상이 발생하는 것이다.  이렇게 축이 겹쳐버리면 한 축에 대해서는 계산이 불가능하기에, 정확한 각도 계산이 불가능하다.

 

Unity로 2D 게임을 제작할 때는 오일러 각으로도 각도 구현에 문제가 없지만, 모든 각도를 통제해줘야 하는 3D 게임 같은 경우에는 오일러 앵글만으로는 구현에 한계가 있다. 

 

오일러 각의 이러한 문제를 해결하기 위해 나온 것이 바로 쿼터니언(Quaternion)이다. 

 

쿼터니언(Quaternion)

쿼터니언은 각 축을 한꺼번에 계산하기 때문에 짐벌락 문제가 발생하지 않는다.

 

Euler angle 과는 다르게 쿼터니언은 4개의 성분(x, y, z, w)으로 이루어져 있다. 

해당 성분은 벡터(x, y, z)와 스칼라(w)를 의미한다.

 

쿼터니언은 내부가 수학적으로 복잡하게 구현되어있어 이를 제대로 이해하지 못한다면 자유자재로 다루기는 상당히 까다롭다.

 

쿼터니언은 방향(orientation) (rotation) 둘을  표현할  있다.

하지만 쿼터니언의 회전은  orientation 에서 다른 orientation 으로 측정하기에 180 보다  값을 표현할  없다는 단점이 있다. 

 점이 쿼터니언을 직관적으로 이해할  없는  이유  하나이다.

 

다행히 유니티에는 이러한 쿼터니언을 간단하게 사용 가능하도록 만들어진 함수들이 다양하게 존재한다.

유니티 공식 문서에도 쿼터니언은 쓰기 어려우니 자기들이 만든 함수를 사용하도록 권장한다.

쿼터니언을 다루기 위해 사용되는 대표적인 함수들의 사용법을 정리해봤다. 

 

Quaternion.Euler

public static Quaternion Euler(float x, float y, float z);

유니티에서는 Quaternion.Euler 함수를 통해서 오일러각을 쿼터니언으로 변경시켜 사용한다.

해당 함수 인자에 오일러각을 넣으면 쿼터니언으로 변환된 값을 반환시켜준다. 

 

Euler 함수 사용법

transform.roation = Quaternion.Euler(new Vector3(120,60,100)); 
float x; 
void Update () 
{ 
	x += Time.deltaTime * 10; 
	transform.rotation = Quaternion.Euler(x,0,0); 
}

 

 

Quaternion.LookRotation

public static Quaternion LookRotation(Vector3 forwardVector3 upwards = Vector3.up);

 번째 인자인 upwards upwards는 Vector3.up 으로 디폴트 인자가 세팅되어 있다.

 번째 인자에  방향벡터를 입력하면 해당 자기 위치기준에서의 해당 방향벡터를 바라보게 된다.

 

어떠한 타겟을 향해 회전시키고 싶다면 다음과 같이 사용하면 된다.

Vector3 direction = (traget.position - this.transform.position).normalized;
Quaternion lookRotation = Quaternion.LookRotation(direction);
this.transform.rotation = lookRotation;

 

 

Quaternion.Slerp

public static Quaternion Slerp(Quaternion aQuaternion b, float t);

/from/ /to/사이를 /t/ 구형보간 합니다.

 

Quaternion.Slerp 함수는  쿼터니언의 중간값을 리턴 시켜준다.

Slerp 함수를 사용할  종종  번째 인자인 t 값에 대하여 헷갈리는데,

Slerp 함수는 lerp 함수에서 쓰이는 선형보간법이 아닌 구면선형보간법 기반으로 되있다는 점을 명심해야한다.

Lerp 함수와 Slerp 함수는  번째 인자에 따른 반환값이 다르다.

Slerp를사용하고 싶다면 선형보간법과 구면선형보간법의 차이를 숙지해야 원하는 각도 변환을 연출할  있을 것이다.

Lerp, Slerp 차이.

Lerp와 Slerp의 차이를 간단하게 그림으로 나타내면 다음과 같다. 

초록점에서 빨간 점으로 이동할 때 Lerp는 직선으로 Slerp는 곡선으로 보간 된다.

transform.rotation = Quaternion.Slerp(A.transform.rotation, B.transform.rotation, Time.deltaTime);

 

 

Quaternion.FromToRotation

public static Quaternion FromToRotation(Vector3 fromDirectionVector3 toDirection);

/fromDirection/에서 /toDirection/으로 회전한 rotation을 생성합니다.

 

FromToRotaion 함수는 fromDirection 의 방향벡터를 toDirection 으로 회전한 쿼터니언을 반환한다.

rotation(0,0,0)

rotation 값이 (0,0,0)인인 큐브이다.

transform.rotation = Quaternion.FromToRotation(Vector3.up, Vector3.right);

다음 함수를 적용 시키면

큐브의 up vector(초록색 화살표) 옆으로 꺽여있다.

카메라 위치 때문에 반대로 보이지만 큐브가 오른쪽으로 90 회전한 모습이다.

 

FromToRotation 함수는 중심축을 첫 번째 인자로 넣고 회전하고 싶은 방향벡터를 두 번째 인자로 넣어서 사용하면 될듯싶다.

 

참조 : 유니티매뉴얼 ,  https://hub1234.tistory.com/21

 

[유니티] Euler, Quaternion 오일러각 쿼터니언 총 정리

[Unity] Euler, Quaternion 오일러각(짐벌락) 쿼터니언에 대하여! Unity의 Euler 각도는 x,y,z 3개 축을 기준으로 회전시키는 우리가 흔히 알고있는 각도계를 의미한다. 이 각도계를 사용하면 우리 모두 삽질

hub1234.tistory.com

 

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

카메라 - 유니티  (0) 2023.03.03
마우스좌표를 월드좌표로 - 2D  (0) 2023.03.02
Vector3  (0) 2023.02.25
변수와 함수  (0) 2023.02.25
Scripts as Behaviour Components  (0) 2023.02.25

Vector3는 UnityEngine 구조체이다

쉽게 생각하면 다음과 같다  물론 실제는 좀더 복잡하다.

public struct Vector3 :IEquatable<Vector3>, IFormattable{
    public float x;
    public float y;
    public float z;
    public static Vector3 right {get;}
    public static Vector3 left {get;}
    public static Vector3 up {get;}
    public static Vector3 down {get;}
    public static Vector3 foward {get;}
    public static Vector3 back {get;}
}
 

이 구조는 Unity 전체에서 3D 위치와 방향을 전달하는 데 사용됩니다. 또한 일반적인 벡터 연산을 수행하기 위한 함수도 포함되어 있습니다.

아래 나열된 함수 외에도 다른 클래스를 사용하여 벡터와 점을 조작할 수도 있습니다. 예를 들어 Quaternion 및 Matrix4x4 클래스는 벡터와 점을 회전하거나 변환하는 데 유용합니다.

 

정적 변수

back Vector3(0, 0, -1) 작성에 대한 약어.
down Vector3(0, -1, 0) 작성에 대한 약어.
forward Vector3(0, 0, 1) 작성에 대한 약어.
left Vector3(-1, 0, 0) 작성에 대한 약어.
negativeInfinity Vector3( float.NegativeInfinity , float.NegativeInfinity , float.NegativeInfinity )
one Vector3(1, 1, 1) 작성에 대한 약어.
positiveInfinity Vector3( float.PositiveInfinity , float.PositiveInfinity , float.PositiveInfinity )
right Vector3(1, 0, 0) 작성에 대한 약어.
up Vector3(0, 1, 0) 작성에 대한 약어.
zero Vector3(0, 0, 0) 작성에 대한 약어.

변수

magnitude 이 벡터의 길이를 반환합니다(읽기 전용).
normalized 크기가 1인 이 벡터를 반환합니다(읽기 전용).
sqrMagnitude 이 벡터의 제곱 길이를 반환합니다(읽기 전용).
this[int] 각각 [0], [1], [2]를 사용하여 x, y, z 구성 요소에 액세스합니다.
x 벡터의 X 구성요소.
y 벡터의 Y 구성 요소입니다.
z 벡터의 Z 구성 요소입니다.

생성자

Vector3 지정된 x, y, z 구성 요소로 새 벡터를 만듭니다.

Public 함수

Equals 주어진 벡터가 이 벡터와 정확히 같으면 true를 반환합니다.
Set 기존 Vector3의 x, y 및 z 구성요소를 설정합니다.
ToString 이 벡터에 대해 형식이 지정된 문자열을 반환합니다.

Static 함수

Angle 및에서 벡터 사이의 각도를 계산합니다.
ClampMagnitude maxLength 로 고정된 벡터의 복사본을 반환합니다 .
Cross 두 벡터의 외적.
Distance a와 b 사이의 거리를 반환합니다.
Dot 두 벡터의 내적.
Lerp 두 점 사이를 선형 보간합니다.
LerpUnclamped 두 벡터 사이를 선형 보간합니다.
Max 두 벡터의 가장 큰 구성 요소로 만들어진 벡터를 반환합니다.
Min 두 벡터의 가장 작은 구성 요소로 만들어진 벡터를 반환합니다.
MoveTowards maxDistanceDelta 로 지정된 거리보다 더 멀리 이동하지 않고 현재 및 대상으로 지정된 점 사이의 위치를 계산합니다 .
Normalize 이 벡터의 크기를 1로 만듭니다.
OrthoNormalize 벡터를 정규화하고 서로 직교하도록 만듭니다.
Project 벡터를 다른 벡터에 투영합니다.
ProjectOnPlane 평면에 수직인 법선으로 정의된 평면에 벡터를 투영합니다.
Reflect 법선에 의해 정의된 평면에서 벡터를 반사합니다.
RotateTowards 대상을 향해 벡터 전류를 회전합니다.
Scale 두 벡터를 구성요소별로 곱합니다.
SignedAngle 축을 기준으로 시작과 끝 벡터 사이의 부호 있는 각도를 계산합니다.
Slerp 두 벡터 사이를 구면으로 보간합니다.
SlerpUnclamped 두 벡터 사이를 구면으로 보간합니다.
SmoothDamp 시간이 지남에 따라 원하는 목표를 향해 벡터를 점차적으로 변경합니다.

operator - 한 벡터에서 다른 벡터를 뺍니다.
operator != 벡터가 다른 경우 true를 반환합니다.
operator * 벡터에 숫자를 곱합니다.
operator / 벡터를 숫자로 나눕니다.
operator + 두 벡터를 더합니다.
operator == 두 벡터가 거의 같으면 true를 반환합니다.

 

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

카메라 - 유니티  (0) 2023.03.03
마우스좌표를 월드좌표로 - 2D  (0) 2023.03.02
[유니티매뉴얼] Unity의 회전 및 방향  (0) 2023.02.28
변수와 함수  (0) 2023.02.25
Scripts as Behaviour Components  (0) 2023.02.25

프로젝트창에서 우클릭하고 Create>Script를 하면 스크립트가 하나만들어지고 이름을 Empty라고 바꿔보자.

바꾼 이름인 Empty  class가 자동으로 만들어진다. 유니티는 스크립트 언어로 c#을 사용한다.

나중에 이 스크립트를 카피할때 조심해야 한다 복사한 파일의 이름을 변경해도 내부의 클래스 이름은 안 바뀌기 때문이다.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Empty : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

 

Empty class는 Start()와 Update() 2개의 함수를 갖고 있다. 

사실 class Empty는 MonoBehaviour class에서 상속되어졌기에 아래와 같이 다양한 콜백함수들이 라이프싸이클을 갖고 실행된다. Empty라는 클래스가 생성되면서 파괴될때까지의 과정이라고 보면 된다. 프로그래밍을 위해서는 라이프싸이클을 이해할 필요가 있다.

1. 모노 (Mono)

.Net은 마이크로 소프트(MicroSoft)에서 C언어에 자바의 장점을 수용하여 개발한 MS Windows 프로그램 개발 및 실행 환경이자 언어이다.

네트워크와 UI 등의 많은 작업을 캡슐화 하여 코딩의 효율성을 극대화 한 .Net 의 강력한 기능을 사용하기 위해서는 .Net 프레임워크가 설치 된 윈도우 환경이 있어야 했다.

이에 윈도우가 아닌 다른 플랫폼에서 .Net 프레임워크를 사용하기 위해 개발된 것이 얼마 전 MS에서 인수한 자마린(Xamarin) 사의 Mono 이다.

Mono 는 .Net 프레임워크(framework) 의 오픈소스 개발 플랫폼으로서 크로스플랫폼(Cross-platform) 어플리케이션의 개발을 지원하며 C#과 CLI (Common Language Infrastructure) 에 기반을 두고 있다.

Mono 를 활용한 대표적인 크로스플랫폼 개발 도구가 유니티와 자마린 이다.

현재 유니티에서 사용하는 Mono 의 .Net 컴파일러에서 지원하는 .Net 버전은 4.x 로 C# 7까지 사용할 수 있다고 한다.

2. 스크립트 언어 (Script Langauge)

하나 이상의 어플리케이션 에서 스크립트(script)를 지원하는 프로그래밍의 부분 집합(subset)이다.

스크립트는 흔히 어플리케이션의 코어 코드와는 별개의 언어로서 최종 사용자에 의해 작성되거나 최소한으로 수정되는 프로그램이다.  스크립트는 대개 소스코드나 바이트코드로 부터 해석되며 이는 어플리케이션이 기계어나 중간언어로 컴파일되는 것과 차별화 된다.  그런면에서 스크립트 언어인지 아닌지를 결정하는 것은 언어 그 자체가 아니라 그 언어가 사용되는 환경이다.

3. Unity 의 Behaviour Script

유니티에서 하나의 스크립트는 그 자체로 하나의 클래스(Class)를 뜻한다.

클래스란 속성(Properties), 메서드(Method) 들을 하나의 객체로 묶은 데이터 타입이다.

유니티에서 하나의 스크립트는 각각 속성(Properties), 변수(Variables), 명령(Instructions) 또는 기능(Functions)을 가지며 사용자는 원하는 순간에 해당 스크립트를 호출 할 수 있다.

모든 스크립트는 또한 Behaviour Component 이다.

Behaviour 는 활성화(Enable), 비활성화(Disable) 할 수 있는 Component 이다.

즉, Behaviour는 껐다켰다 할 수 있는 동작(behaviour) 이며, 이는 캐릭터의 동작이 될 수도 있고, 환경이 될 수도 있고, 게임 내 흐름을 제어하는 프로그램 자체가 될 수도 있다.

* Component 란? GameObject 에 부착되는(Attached) 모든 것들이 상속받는 기반 클래스.

4. MonoBehaviour

MonoBehaviour 는 Unity 의 모든 스크립트가 상속받는 클래스이다.

사용자가 Unity 엔진의 작동 방식을 이해하지 못하더라도 코드를 작성할 수 있도록 미리 만들어 둔(built-in) Behaviour 클래스 이자 스크립트 명령(scripting instruction) 들의 집합이다.

덕분에 모든 스크립트는 유니티 엔진에 의해 호출(invoke) 되는 콜백(callback) 함수들을 이용할 수 있게 된다.

이 콜백 함수들은 Reset, Awake, Start, Update, OnGUI, OnDestroy 등 유니티를 사용하면서 수없이 사용하게 된다.

5. MonoBehaviour 의 생명주기(Lifecycle)

 

유니티의 공식 매뉴얼을 보면 위와 같이 MonoBehaviour 의 수많은 콜백함수 종류와 각각이 호출 되는 시점을 알 수 있다.

이 중 개발 과정에서 실제 자주 이용하게 되는 콜백들의 라이프사이클을 살펴보자.

 

Reset : 유니티 에디터에서 오브젝트 생성 후 인스펙터 뷰에서 리셋을 눌러줄 때 실행된다.

          객체의 속성을 초기 값으로 설정해 줄 때 사용한다.

 

Awake : 프리팹이 인스턴스화 한 직후, 스크립트가 호출되자마자 오브젝트 활성화 여부와 상관없이 실행 된다.

           모든 오브젝트가 초기화 된 후 호출되기 때문에 GameObject.Find 같은 명령문을 안전하게 사용할 수 있다.                 Awake 함수는 언제나 Start 함수 전에 호출되는 점에 주의. (StartCoroutine 을 사용할 수 없다.)

 

OnEnable : 다른 초기화 함수와 달리 하나의 라이프 사이클 내에서 여러번 호출 될 수 있다.

                인스펙터뷰에서 체크 및 스크립트 내에서 SetActive 함수로 게임 오브젝트를 활성화 할 때마다 호출 된다.

 

Start : Update 함수가 호출되기 전에 한번만 호출된다.

         다른 스크립트의 모든 Awake가 모두 실행된 이후에 실행되며 Awake와 달리 오브젝트가 활성화 되어 있어야 호출 된다.

         Awake 이후 호출되므로 예를들어 A 객체의 Awake 함수에서 동적 생성한 멤버를 B객체의 Awake 함수에서 접근할 경우 오브젝트 들의 Awake 함수 호출 순서는 임의로 정할 수 없으므로 B객체의 Awake 가 먼저 호출 되어 NullReferenceExecption 을 발생 시킬 수 있다.

         이럴 경우 동적 생성은 Awake 에서 하고 동적 생성되는 멤버에 접근하는 초기화 코드는 항상 Awake 이후로 보장되는 Start 에 넣는 것이 좋다. 

 

FixedUpdate 프레임과 상관없이 무조건 시간 기준(default 0.02초. 변경 가능)으로 호출 되는 Update 콜백이기 때문에 주로 물리 엔진을 사용하는 경우 일정 시간 간격으로 힘을 가하거나 체크할 때 사용한다.

                   프레임 속도가 기준 시간 속도보다 오래 걸릴 정도로 느려질 경우 한 프레임에서 여러번 호출 될 수 있다.

 

Update : 매 프레임마다 호출되는 가장 일반적인 Update 함수.

             오브젝트가 활성화 되어 있어야 호출 되며 프레임 단위이기에 호출 시간 간격은 프레임에 따라 변한다.

 

LateUpdate : 모든 Update 계열 콜백들이 실행되고 나서 호출된다.

                  Update 함수에서 캐릭터를 이동 시킨 후 LastUpdate에서 캐릭터의 좌표를 추적해 카메라의 좌표를 이동시키는 등의 경우에 사용한다.

 

OnDisable : 게임 오브젝트 또는 스크립트가 비 활성화 되었을 때 호출된다. (StartCoroutine 사용 불가)

 

OnDestroy : 해당 오브젝트가 파괴 되기 전 프레임의 Update 함수 실행 후 호출 된다.

                 일반적으로 라이프 사이클 내에서 사용한 자원들을 돌려 놓는 작업을 이곳에서 하게 된다.

 

OnApplicationQuit :  앱이 종료 되기 직전에 모든 오브젝트에서 호출된다.

                             에디터에서는 플레이 모드 중지할 때 호출 된다.

 

6. MonoBehaviour 의 특징

MonoBehaviour 를 상속받은 스크립트 파일은 그 자체로 사용할 수 없다.

GameObject 에 Component 형태로 등록되어 있어야 한다.

즉, 게임 내에서 사용할 GameManager.cs 라는 스크립트 파일을 만들었다면 해당 클래스를 적용할 빈 GameObject를

Unity의 Hierarchy 에서 추가한 후 Inspector 창에 이 스크립트 파일을 등록한다.

그리고 코드에서 해당 GameManager 클래스를 가져오려면 위에서 추가한 GameObject 객체에 GetComponent<GameManager>(); 형태로 가져와야 한다는 뜻이다.

또한 가장 중요한 특징 중 하나는 MonoBehaviour 를 상속받은 클래스는 new 로 동적 할당할 수 없다.

이 경우,

1. GamObject.Instantiate 함수를 통해 해당 스크립트가 Component 로 추가된 오브젝트의 인스턴스를 생성

2. 기존 생성된 GameObject 객체에 AddComponent<GameManager>();

하여 사용할 수 있다.

MonoBehaviour 의 다양한 콜백 함수는 필요할 경우 오버라이딩 해서 사용하면 된다.

하지만 오버라이딩 해놓고 해당 함수 안에서 아무것도 하지 않고 비워두면 어떻게 될까?

컴파일 과정에서 이런 경우 함수 호출을 제거해 주면 좋으련만 아쉽게도 내용이 있던 없던 무조건 호출을 진행 한다.

Awake 나 Start 같은 한번만 호출 되는 경우는 상대적으로 영향이 적겠지만 FixedUpdate 같은 경우 0.02초 마다 오브젝트 별로 각각 호출을 하게 되므로 퍼포먼스에 상당한 영향을 끼칠수 있다.

쓰지 않는 MonoBehaviour 함수는 꼭 삭제해 주자.

 

https://skuld2000.tistory.com/25

 

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

카메라 - 유니티  (0) 2023.03.03
마우스좌표를 월드좌표로 - 2D  (0) 2023.03.02
[유니티매뉴얼] Unity의 회전 및 방향  (0) 2023.02.28
Vector3  (0) 2023.02.25
Scripts as Behaviour Components  (0) 2023.02.25

행동부품으로서의 스크립 번역해보면 어색하지만, 모든 스크립트는  Behaviour Component 이다.

Behaviour 는 활성화(Enable), 비활성화(Disable) 할 수 있는 Component 이다.

즉, Behaviour는 껐다켰다 할 수 있는 동작(behaviour) 이며, 이는 캐릭터의 동작이 될 수도 있고, 환경이 될 수도 있고, 게임 내 흐름을 제어하는 프로그램 자체가 될 수도 있다.

* Component 란? GameObject 에 부착되는(Attached) 모든 것들이 상속받는 기반 클래스.

아시다시피 유니티는 게임오브젝트에 다양한 부품을 추가할 수 있다. 

유니티는 Create Empty라는 게임오브젝트를 만들면 축만보이는 투명한 오브젝트가 만들어지고 오른쪽 Inspector창을 보면  Transform이외에 아무런 기능이 추가되여 있지 않다.

transform이라는 이동 회전 스케일을 처리하는 컴포넌트만 보인다. 이 transform이라는 컴포넌트는 제가불가능하다. 오른쪽 삼점을 눌러봐도 Delete 메뉴가 안보인다.

유니티는 게임오브젝트의 특성(생명)을 부여하기 위해 다양한 컴포넌트를 추가할 수 있는데 스크립트가 여러가지 부품중 하나로 취급된다는 거다. 부품이란 필요할때 추가되기도 하고 제거할 수도 있다.

결론은 스크립트 == 컴포넌트 라는 이야기

'유니티스크립팅 > 유니티매뉴얼' 카테고리의 다른 글

카메라 - 유니티  (0) 2023.03.03
마우스좌표를 월드좌표로 - 2D  (0) 2023.03.02
[유니티매뉴얼] Unity의 회전 및 방향  (0) 2023.02.28
Vector3  (0) 2023.02.25
변수와 함수  (0) 2023.02.25

+ Recent posts