벡터 — Vec3 — 한 줄 한 줄 직접 구현

그래픽스에서 위치(점이 어디 있나), 방향(어느 쪽을 보나), 색(RGB) — 이 세 가지는 모두 숫자 세 개로 표현됩니다. 이 세 개를 하나로 묶은 것이 3차원 벡터 Vec3입니다. 이 페이지에서는 Vec3 구조체를 C++로 직접 만들고, 덧셈·뺄셈·스칼라 곱·단항 부호·내적·외적·길이·정규화를 코드 한 줄, 성분 하나까지 해부한 뒤, 실무 표준인 DirectXMath로 똑같이 옮겨 봅니다.

0. 무엇을, 왜 만드나

Vec3는 float 세 개(x, y, z)를 담는 아주 작은 구조체입니다. 하지만 이 위에 덧셈·내적·외적 같은 연산을 얹는 순간, 그래픽스의 거의 모든 계산을 표현할 수 있게 됩니다.

• 위치(point): 정점의 좌표 (1, 2, 3).
• 방향(direction): 빛이 나아가는 방향, 카메라가 보는 방향 (0, 0, 1).
• 색(color): 빨강·초록·파랑 세기 (1, 0, 0) = 빨강.

같은 세 숫자라도 "점"이냐 "방향"이냐에 따라 의미가 다릅니다. 예를 들어 두 점을 더하는 것은 대개 의미가 없지만 (뉴욕 좌표 + 서울 좌표 = ?), 점 + 방향은 "그 점에서 그 방향으로 이동한 새 점"이라는 뚜렷한 의미가 있습니다. 구조체 하나로 이 셋을 모두 표현하되, 의미는 우리가 코드로 구분해서 씁니다.

1. 구조체와 생성자 — 뼈대 만들기

먼저 세 개의 float을 담을 그릇을 정의합니다. 그리고 그 그릇을 "빈 채로" 또는 "값을 채워서" 만드는 두 가지 방법(생성자)을 마련합니다.

1. float 세 개 x, y, z를 멤버로 선언하고 0으로 기본 초기화합니다.
2. 인자 없는 기본 생성자로 (0,0,0) 벡터를 만들 수 있게 합니다.
3. 값 세 개를 받는 생성자로 Vec3 a(1,2,3) 처럼 채워서 만들 수 있게 합니다.

#pragma once
#include <cmath>

struct Vec3 {
    float x = 0.0f, y = 0.0f, z = 0.0f;
    Vec3() = default;
    Vec3(float x_, float y_, float z_) : x(x_), y(y_), z(z_) {}
};

한 줄씩 해부

#pragma once — 이 헤더가 여러 .cpp에서 #include돼도 딱 한 번만 컴파일에 포함되게 막아 주는 지시문입니다. 없으면 같은 구조체가 두 번 정의됐다는 오류가 납니다. #include <cmath>는 뒤에서 쓸 std::sqrt(제곱근) 때문에 필요합니다.

struct Vec3 { ... }; — 새 자료형 Vec3를 정의합니다. C++에서 struct와 class는 기본 접근 권한만 다릅니다(struct는 기본 public). 데이터를 그대로 노출하는 수학 타입에는 struct가 관례입니다.

float x = 0.0f, y = 0.0f, z = 0.0f; — 세 멤버 변수입니다. 뒤의 = 0.0f는 기본 멤버 초기화(default member initializer)로, 어떤 생성자를 타든 값을 안 주면 자동으로 0이 됩니다. "쓰레기 값(초기화 안 된 메모리)"이 들어가는 실수를 원천 차단합니다. f 접미사는 이 리터럴이 double이 아니라 float임을 뜻합니다(GPU/그래픽스는 대부분 32비트 float을 씁니다).

Vec3() = default; — 기본 생성자를 컴파일러가 자동으로 만들게 명시합니다. 위에서 멤버에 = 0.0f를 줬으므로 이 생성자로 만든 벡터는 (0,0,0)입니다. 사실 아래에 인자 있는 생성자를 하나라도 직접 선언하면 컴파일러가 기본 생성자를 자동으로 안 만들어 주기 때문에, = default;로 되살려 두는 것입니다. 이게 없으면 Vec3 v;가 컴파일 오류가 납니다.

Vec3(float x_, float y_, float z_) : x(x_), y(y_), z(z_) {} — 값 세 개를 받는 생성자입니다. : x(x_), y(y_), z(z_) 부분이 멤버 초기화 리스트로, 멤버 x를 인자 x_로 초기화합니다. 본문({}) 안에서 x = x_;로 대입하는 것보다 초기화 리스트가 더 효율적이고 정석입니다 (대입은 "일단 기본값 생성 → 다시 대입" 2단계, 초기화는 1단계). 인자 이름에 밑줄(x_)을 붙인 건 멤버 x와 이름이 겹쳐 헷갈리는 것을 피하기 위한 흔한 관례입니다.

집합 초기화(aggregate init) 한 마디

아래 연산자들에서 return { x + b.x, y + b.y, z + b.z }; 처럼 중괄호로 값 세 개를 나열하는 문법을 자주 씁니다. 이건 Vec3의 세 멤버를 순서대로(x, y, z) 채워 새 객체를 만드는 중괄호 초기화입니다. 반환 타입이 Vec3임을 컴파일러가 알기에 return Vec3{...}를 return {...}로 줄여 쓸 수 있습니다.

2. 덧셈과 뺄셈 — 이동과 "차이"

무엇을 만드나: 두 벡터를 성분끼리 더하거나 빼는 연산입니다. 왜 필요한가: 덧셈은 "점을 방향만큼 이동"(새위치 = 위치 + 속도), 뺄셈은 "A에서 B로 가는 방향"(목표 - 현재)을 구하는 데 매일 쓰입니다. 벡터 뺄셈 b - a는 그래픽스에서 "a에서 b를 향하는 화살표"라고 외워 두면 두고두고 편합니다.

    Vec3 operator+(const Vec3& b) const { return { x + b.x, y + b.y, z + b.z }; }
    Vec3 operator-(const Vec3& b) const { return { x - b.x, y - b.y, z - b.z }; }

시그니처 해부

Vec3 operator+(const Vec3& b) const — 앞에서부터 뜯어봅니다.

• 반환 타입 Vec3: 더한 결과는 새 벡터이므로 Vec3를 값으로 돌려줍니다. 원본 두 벡터는 건드리지 않고 새 벡터를 만들어 반환합니다.
• operator+: 이름이 operator+인 멤버 함수를 정의하면 a + b라고 쓸 때 컴파일러가 이걸 a.operator+(b)로 바꿔 호출합니다. 이것이 연산자 오버로딩입니다. 덕분에 Vec3 c = a + b;처럼 수학 그대로 읽히는 코드를 쓸 수 있습니다.
• const Vec3& b: 오른쪽 피연산자입니다.
  • &(참조): Vec3를 복사하지 않고 원본을 가리킵니다. float 3개라 복사가 싸긴 하지만, 참조로 받는 것이 관례이며 큰 타입일수록 이득이 큽니다.
  • const: 이 함수는 b를 읽기만 하고 바꾸지 않겠다는 약속입니다. 호출자에게 안전을 보장하고, const 벡터도 인자로 넘길 수 있게 합니다.
• 맨 끝 const: "이 멤버 함수는 자기 자신(왼쪽 피연산자)도 바꾸지 않는다"는 약속입니다. a + b에서 a는 그대로 있어야 하므로 반드시 const를 붙입니다. 이게 없으면 const Vec3 a; a + b;가 컴파일되지 않습니다.

성분별 계산 — 수학 → 코드

수학적으로 (x, y, z) + (bx, by, bz) = (x+bx, y+by, z+bz) 입니다. 즉 같은 축끼리만 더합니다 (x는 x끼리, y는 y끼리). 코드의 세 항이 정확히 이에 대응합니다:

기하 직관: 덧셈은 화살표를 이어 붙이기입니다. 벡터 a의 화살촉 끝에서 벡터 b를 다시 그리면, 출발점에서 b의 화살촉까지가 a + b입니다(평행사변형 법칙). 뺄셈 a - b는 b의 화살촉에서 a의 화살촉으로 향하는 화살표입니다.

손계산 예제

a = (1, 2, 3), b = (4, 0, 0) 이면 a + b = (1+4, 2+0, 3+0) = (5, 2, 3), a - b = (1-4, 2-0, 3-0) = (-3, 2, 3) 입니다.

3. 스칼라 곱 — 길이 늘이고 줄이기

무엇을 만드나: 벡터에 실수 하나(스칼라)를 곱해 세 성분 모두를 같은 배율로 키우거나 줄이는 연산입니다. 왜 필요한가: 속도 * deltaTime(프레임당 이동량), 방향 * 거리(그 방향으로 얼마만큼), 색 밝기 조절 등 끝없이 쓰입니다. 스칼라를 곱해도 방향은 그대로, 길이만 바뀝니다(음수를 곱하면 방향이 뒤집힙니다).

    // 멤버: v * s  (벡터 * 스칼라)
    Vec3 operator*(float s) const { return { x * s, y * s, z * s }; }
};  // struct 끝

// 자유 함수: s * v  (스칼라 * 벡터) — v * s 로 되돌려 재사용
inline Vec3 operator*(float s, const Vec3& v) { return v * s; }

왜 두 개나 필요한가 — v*s 와 s*v

수학에서는 v * s든 s * v든 같은 뜻이지만, C++에서는 둘이 서로 다른 함수 호출입니다.

• v * s → v.operator*(s): 왼쪽이 Vec3이므로 멤버 함수로 처리됩니다.
• s * v → operator*(s, v): 왼쪽이 float입니다. float에는 우리가 멤버 함수를 추가할 수 없으므로, 구조체 바깥의 자유 함수(free function)로 정의해야 합니다. 이게 없으면 2.0f * v가 컴파일 오류입니다.

inline Vec3 operator*(float s, const Vec3& v) { return v * s; } — 이 자유 함수는 스스로 계산하지 않고 return v * s;로 멤버 버전을 재사용합니다. 로직을 한 곳(멤버)에만 두어 중복과 실수를 줄이는 좋은 습관입니다. inline은 이 함수가 헤더에 정의돼 여러 .cpp에 포함될 때 "중복 정의" 링크 오류를 막아 줍니다 (헤더에 함수 본문을 쓸 때는 붙이는 게 안전합니다).

참고로 멤버 operator*는 구조체 안이라 inline이 필요 없습니다(클래스 안 정의 함수는 자동으로 inline 취급).

성분별 계산 & 기하 직관

(x, y, z) * s = (x·s, y·s, z·s). 세 성분에 똑같은 배율 s를 곱합니다. s = 2면 화살표가 두 배 길어지고, s = 0.5면 절반, s = -1이면 길이는 그대로인데 정반대 방향이 됩니다.

손계산: a = (1,2,3), s = 2 → a * 2 = (2, 4, 6). 2 * a도 결과는 같은 (2,4,6).

4. 단항 마이너스 — 방향 뒤집기

무엇을 만드나: -v처럼 벡터 하나 앞에 마이너스를 붙여 모든 성분의 부호를 바꾸는 연산입니다. 왜 필요한가: 반대 방향(카메라의 "뒤", 빛의 반대 방향 등)을 구할 때 씁니다. 사실상 v * -1.0f과 같지만, -v가 훨씬 읽기 좋습니다.

    Vec3 operator-() const { return { -x, -y, -z }; }

이항 뺄셈과 어떻게 구분되나

앞서 operator-(const Vec3& b)(인자 1개)는 이항 뺄셈 a - b였습니다. 여기 operator-()는 인자가 0개입니다. 컴파일러는 인자 개수로 둘을 구분합니다: a - b는 이항(뺄셈), -a는 단항(부호 반전). 같은 기호 -지만 다른 함수입니다.

{ -x, -y, -z } — 세 성분 각각에 마이너스를 붙여 새 벡터를 만듭니다. a = (1,2,3)이면 -a = (-1, -2, -3). 길이는 그대로, 방향만 정반대입니다. 맨 끝 const는 앞서와 같은 이유로 "자기 자신을 바꾸지 않는다"는 약속입니다.

5. 내적 dot — 두 벡터가 얼마나 "같은 쪽"을 보나

무엇을 만드나: 두 벡터의 성분끼리 곱해 모두 더한 하나의 실수(스칼라)를 돌려주는 연산입니다. 결과가 벡터가 아니라 숫자 하나라는 점이 핵심입니다. 왜 필요한가: 내적은 그래픽스의 심장입니다. 두 방향의 사잇각, 표면이 빛을 얼마나 받는지(램버트 조명), 앞/뒤 판별, 투영 등 거의 모든 조명·기하 계산의 출발점입니다.

inline float dot(const Vec3& a, const Vec3& b) {
    return a.x*b.x + a.y*b.y + a.z*b.z;
}

시그니처: 왜 float을 돌려주나

inline float dot(const Vec3& a, const Vec3& b) — 반환 타입이 Vec3가 아니라 float입니다. 내적의 결과는 스칼라 하나이기 때문입니다. 두 인자 모두 const Vec3&로 받아 읽기 전용·복사 없이 처리합니다. 구조체 바깥의 자유 함수이며(멤버가 아니어도 두 인자를 대칭으로 받는 편이 자연스러움), 헤더 정의라 inline을 붙였습니다.

수식 → 기하 직관 → 코드 3단

① 수식: a · b = ax·bx + ay·by + az·bz. 같은 축끼리 곱해서 전부 더합니다.

② 기하 직관: 내적은 또한 a · b = |a| |b| cos θ 와 같습니다(θ는 두 벡터 사잇각, |a|는 길이). 여기서 어마어마하게 유용한 사실이 나옵니다:

• a · b > 0 → 사잇각이 90°보다 작음 = 대체로 같은 쪽을 봄.
• a · b = 0 → 정확히 수직(직교).
• a · b < 0 → 사잇각이 90°보다 큼 = 반대쪽을 봄.

특히 두 벡터가 모두 단위 길이(정규화됨)라면 |a| = |b| = 1이므로 a · b = cos θ가 되어, 내적 값이 곧 코사인입니다. 조명에서 "표면 법선 N 과 빛 방향 L 의 dot(N, L)"이 바로 이 원리로 "정면으로 받으면 1(가장 밝음), 옆이면 0, 뒤면 음수(빛 안 닿음 → 0으로 클램프)"를 계산합니다.

③ 코드 매핑: a.x*b.x(x축 곱) + a.y*b.y(y축 곱) + a.z*b.z(z축 곱). 수식과 1:1입니다.

손계산 예제

a = (1, 2, 3), b = (4, 0, 0) 이면 dot(a, b) = 1·4 + 2·0 + 3·0 = 4. b가 x축만 가리키므로, 내적은 결국 a의 x성분(1)에 b의 크기(4)를 곱한 값과 같습니다. 이는 "a를 b(=x축) 방향으로 투영했을 때의 크기"라는 내적의 또 다른 의미를 그대로 보여 줍니다.

6. 외적 cross — 두 벡터에 수직인 벡터

무엇을 만드나: 두 벡터 a, b에 동시에 수직인 새 벡터를 돌려줍니다. 내적과 달리 결과가 벡터입니다. 왜 필요한가: 삼각형의 두 변에서 면의 법선(수직 방향)을 구할 때, 카메라의 오른쪽·위 축을 만들 때 등 "수직 방향이 필요한 모든 곳"에 씁니다. 조명·컬링·좌표계 구축의 핵심입니다.

inline Vec3 cross(const Vec3& a, const Vec3& b) {
    return {
        a.y*b.z - a.z*b.y,   // x 성분
        a.z*b.x - a.x*b.z,   // y 성분
        a.x*b.y - a.y*b.x    // z 성분
    };
}

왜 이렇게 복잡한가 — 성분별로 하나씩

외적의 각 성분은 "자기 축을 뺀 나머지 두 축"의 교차 곱셈이라는 규칙을 따릅니다. 외우기보다 패턴으로 보세요. 각 결과 성분마다, 나머지 두 축을 순환 순서(x→y→z→x)로 "앞·뒤"를 곱해 뺍니다.

x 성분 a.y*b.z - a.z*b.y: x를 만들 때는 x를 빼고 남은 y와 z만 씁니다. 순환 순서 x→y→z를 따라 "앞(y)·뒤(z)"를 곱한 a.y*b.z에서 "뒤(z)·앞(y)"를 곱한 a.z*b.y를 뺍니다.

y 성분 a.z*b.x - a.x*b.z: y를 빼고 남은 z와 x를 씁니다. 순환에서 y 다음은 z→x이므로 "앞(z)·뒤(x)" a.z*b.x에서 "뒤(x)·앞(z)" a.x*b.z를 뺍니다. 주의: 여기서 순서가 z, x지 x, z가 아니라는 점이 초보자가 가장 많이 틀리는 곳입니다(부호가 뒤집혀 법선이 반대로 나옵니다).

z 성분 a.x*b.y - a.y*b.x: z를 빼고 남은 x와 y를 씁니다. 순환에서 z 다음은 x→y이므로 "앞(x)·뒤(y)" a.x*b.y에서 "뒤(y)·앞(x)" a.y*b.x를 뺍니다. 이 z 성분만 따로 떼면 2D 외적 (감김 방향/삼각형 넓이 부호 판정)에 그대로 쓰입니다.

기하 직관과 방향(오른손/왼손)

결과의 방향: cross(a, b)는 a와 b가 이루는 평면에 수직입니다. 구체적으로 어느 쪽(위/아래)인지는 손 규칙으로 정해집니다. 수학의 기본 공식(위 코드)은 오른손 법칙을 따릅니다: 오른손 손가락을 a에서 b로 감아쥐면 엄지가 cross(a, b) 방향입니다.

결과의 길이: |cross(a, b)| = |a| |b| sin θ로, 이는 a, b가 만드는 평행사변형의 넓이와 같습니다 (삼각형 넓이는 그 절반). 두 벡터가 평행하면 sin θ = 0이라 외적이 영벡터가 됩니다 — "수직 방향이 정의되지 않음".

손계산 예제

a = (1, 2, 3), b = (4, 0, 0) 로 계산해 봅니다.

• x: a.y*b.z - a.z*b.y = 2·0 - 3·0 = 0
• y: a.z*b.x - a.x*b.z = 3·4 - 1·0 = 12
• z: a.x*b.y - a.y*b.x = 1·0 - 2·4 = -8

→ cross(a, b) = (0, 12, -8). 검산으로 내적이 0이면 수직임을 확인합니다: dot((0,12,-8), a) = 0·1 + 12·2 + (-8)·3 = 24 - 24 = 0 ✓, dot((0,12,-8), b) = 0·4 + 0 + 0 = 0 ✓. 결과가 a, b 둘 다에 수직임이 확인됩니다.

7. 길이 length — 벡터의 크기

무엇을 만드나: 벡터의 크기(원점에서 화살촉까지의 거리)를 실수로 돌려줍니다. 왜 필요한가: 두 점 사이 거리(length(b - a)), 속력, 정규화의 재료 등에 쓰입니다.

inline float length(const Vec3& v) { return std::sqrt(dot(v, v)); }

왜 dot(v, v)인가

피타고라스로 |v| = √(x² + y² + z²) 입니다. 그런데 dot(v, v) = x·x + y·y + z·z = x² + y² + z²이므로, 제곱합이 곧 자기 자신과의 내적입니다. 그래서 dot(v, v)에 std::sqrt(제곱근)를 씌우면 길이가 됩니다. 이미 만든 dot를 재사용하니 코드가 짧고 실수가 줄어듭니다.

std::sqrt는 <cmath>에 있는 제곱근 함수입니다(그래서 맨 위에서 #include <cmath> 했습니다). 손계산: a = (1,2,3) → dot(a,a) = 1+4+9 = 14 → length(a) = √14 ≈ 3.742.

8. 정규화 normalize — 길이만 1로, 방향은 그대로

무엇을 만드나: 방향은 유지하되 길이를 정확히 1로 맞춘 단위 벡터를 돌려줍니다. 왜 필요한가: 조명(dot(N, L) = cos θ가 성립하려면 둘 다 단위여야 함), 방향 비교, 이동 방향 등 "크기는 필요 없고 방향만 필요한" 거의 모든 곳에서 먼저 정규화합니다.

inline Vec3 normalize(const Vec3& v) {
    float len = length(v);
    if (len < 1e-8f) return { 0.0f, 0.0f, 0.0f };
    return v * (1.0f / len);
}

한 줄씩

float len = length(v); — 먼저 현재 길이를 구합니다. 이걸로 나눠 주면 길이가 1이 됩니다.

if (len < 1e-8f) return { 0.0f, 0.0f, 0.0f }; — 0으로 나누기 방어입니다. 영벡터(또는 거의 영)에는 "방향"이 없어 정규화가 정의되지 않습니다. 그대로 나누면 len이 0이라 결과가 inf/NaN이 되어 화면 전체가 깨질 수 있습니다. 1e-8f(= 0.00000001)은 "이보다 작으면 사실상 0으로 본다"는 엡실론(허용 오차)입니다. 정확히 == 0.0f로 비교하지 않는 이유는 float 계산에는 미세 오차가 있어, 이론상 0이어야 할 값이 아주 작은 값으로 남을 수 있기 때문입니다. 엡실론으로 "충분히 작으면 0 취급"하는 것이 안전합니다.

return v * (1.0f / len); — 각 성분을 길이로 나눠 단위 벡터를 만듭니다. v / len 대신 1.0f / len을 한 번 구해 곱하는 이유는 성능입니다: 나눗셈은 곱셈보다 느리므로, 나눗셈 한 번 + 곱셈 세 번이 나눗셈 세 번보다 빠릅니다. (여기서 앞서 만든 v * s 스칼라 곱이 재사용됩니다.)

손계산 예제

b = (4, 0, 0) → length(b) = 4 → normalize(b) = (4/4, 0/4, 0/4) = (1, 0, 0). 방향(x축 양의 방향)은 그대로, 길이만 1이 됐습니다.

9. 전체를 한 번에 — 사용 예

Vec3 a{1, 2, 3};
Vec3 b{4, 0, 0};

Vec3 sum = a + b;         // (5, 2, 3)
Vec3 dir = normalize(b);  // (1, 0, 0)  — x축 단위 벡터
float d  = dot(a, b);     // 4
Vec3 c   = cross(a, b);   // (0, 12, -8) — a, b 에 수직
float la = length(a);     // sqrt(14) ≈ 3.742

앞에서 손으로 계산한 값들이 그대로 나옵니다. 여기까지가 직접 구현입니다. 내부 동작을 손으로 확인했으니, 이제 실무 표준으로 넘어갑니다.

10. 실무 버전 — DirectXMath로 옮기기

실제 D3D 프로젝트에서는 Vec3를 직접 만들지 않고 DirectXMath를 씁니다. SIMD(한 번에 4개 float을 병렬 계산)로 최적화돼 있고, 행렬·쿼터니언까지 일관된 API를 제공합니다. 직접 구현은 원리 학습용, DirectXMath는 실전용이라고 생각하세요.

핵심 개념 하나만 잡으면 됩니다: 저장은 XMFLOAT3, 계산은 XMVECTOR.

• XMFLOAT3: 우리 Vec3처럼 float 3개를 담는 평범한 저장용 구조체. 정점 버퍼·멤버 변수 등 메모리에 담아 둘 때 씁니다.
• XMVECTOR: SIMD 레지스터에 올라가는 계산 전용 타입. 실제 연산은 이걸로 합니다.

그래서 흐름이 항상 "로드(XMLoadFloat3) → 계산 → 저장(XMStoreFloat3)" 입니다.

#include <DirectXMath.h>
using namespace DirectX;

XMFLOAT3 aS{1, 2, 3};      // 저장용(storage)
XMFLOAT3 bS{4, 0, 0};

// 1) 로드: 저장용 → 계산용
XMVECTOR a = XMLoadFloat3(&aS);
XMVECTOR b = XMLoadFloat3(&bS);

// 2) 계산: 전부 XMVECTOR 로
XMVECTOR sum  = XMVectorAdd(a, b);          // a + b
XMVECTOR diff = XMVectorSubtract(a, b);     // a - b
XMVECTOR sc   = XMVectorScale(a, 2.0f);     // a * 2
XMVECTOR ndir = XMVector3Normalize(b);      // normalize(b)
XMVECTOR cx   = XMVector3Cross(a, b);       // cross(a, b)

// 내적/길이는 결과가 스칼라지만 XMVECTOR(4채널에 복제)로 나옴 → Get 으로 추출
float d  = XMVectorGetX(XMVector3Dot(a, b));    // dot(a, b) = 4
float la = XMVectorGetX(XMVector3Length(a));    // length(a) ≈ 3.742

// 3) 저장: 계산용 → 저장용 (메모리에 다시 담기)
XMFLOAT3 sumS;
XMStoreFloat3(&sumS, sum);   // 이제 sumS.x = 5, ...

원본 ↔ DirectXMath 1:1 매핑

한 가지 낯선 점: XMVector3Dot·XMVector3Length의 결과가 float이 아니라 XMVECTOR라는 것입니다. SIMD 특성상 스칼라 하나도 4개 채널(x, y, z, w)에 같은 값으로 복제해 담기 때문입니다. 그래서 XMVectorGetX(...)로 첫 채널을 꺼내 진짜 float으로 씁니다. 우리 직접 구현이 곧바로 float을 돌려주던 것과의 유일한 사용법 차이입니다.