행렬 — Mat4 — 한 줄 한 줄 직접 구현

벡터가 점 하나라면, 행렬은 공간 전체를 한 번에 바꾸는 규칙입니다. 이동·회전·크기·투영이 전부 4×4 행렬 하나로 표현되고, 정점 하나를 그 행렬에 곱하면 화면 위 어디로 갈지 결정됩니다. 이 페이지에서는 4×4 행렬을 float 16개로 저장하는 Mat4 구조체를 만들고, 항등행렬 · 행렬 곱 · 전치를 성분 하나까지 손으로 따라가며, 마지막으로 이 행렬을 GPU 상수 버퍼(cbuffer)에 올릴 때 왜 전치해야 하는지까지 파헤칩니다.

무엇을, 왜 만드나

무엇을: 4×4 실수 행렬을 행 우선(row-major)으로 저장하는 구조체 Mat4와, 그 위에서 동작하는 항등행렬 생성 · 행렬 곱셈 · 전치 세 가지 연산을 만듭니다.

왜: 그래픽스에서 하나의 정점은 보통 모델→월드→뷰→투영이라는 여러 단계를 거칩니다. 각 단계가 행렬 하나이고, 이들을 미리 곱해 하나의 MVP 행렬로 합쳐 두면 정점마다 곱셈 한 번으로 끝납니다. 그래서 행렬 곱이 핵심입니다. 또 저장 순서를 행 우선으로 잡은 이유는 DirectXMath의 XMFLOAT4X4와 메모리 배치를 똑같이 맞춰, 나중에 상수 버퍼로 올릴 때 memcpy 한 번으로 재사용하기 위함입니다.

1. 저장 구조 — float m[16] 하나로 4×4를 표현하고, (행 r, 열 c)를 m[r*4+c]로 접근합니다.
2. 접근자 at(r,c) — 2차원 좌표를 1차원 인덱스로 바꿔 주는 통로. 읽기용/쓰기용 두 버전.
3. 항등행렬 identity() — 대각선만 1, 나머지 0. "아무것도 안 바꾸는" 곱셈의 기준점.
4. 행렬 곱 operator* — C(r,c) = Σ A(r,k)·B(k,c). 3중 루프로 16개 성분을 채웁니다.
5. 전치 transpose — 행과 열을 뒤바꿔 (r,c) ↔ (c,r). cbuffer 업로드용.
6. cbuffer 업로드 — 전치한 행렬을 GPU로 복사하고, 전치를 빠뜨렸을 때 생기는 대표적 버그를 짚습니다.

1. 4×4를 float 16개로 — 저장 구조와 인덱싱

수학에서 4×4 행렬은 4행 4열, 총 16개의 수입니다. 하지만 C++에서 2차원 배열(float m[4][4]) 대신 1차원 배열 float m[16]을 씁니다. 메모리는 어차피 일렬로 이어진 바이트 뭉치라, 16칸을 한 줄로 늘어놓고 "몇 번째 칸이 몇 행 몇 열인지"를 우리가 정하면 됩니다. 그 규칙이 바로 행 우선입니다.

#pragma once
// 메모리: [row0(4개), row1(4개), row2(4개), row3(4개)]가 일렬로 붙어 있음.
// (행 r, 열 c) 성분의 위치 = m[r*4 + c]
struct Mat4 {
    float m[16] = { 0 };                          // 16칸 전부 0으로 시작
    float& at(int r, int c) { return m[r * 4 + c]; }             // 쓰기/읽기용
    const float& at(int r, int c) const { return m[r * 4 + c]; } // 읽기 전용
};

한 줄씩 해부

#pragma once — 이 헤더가 여러 .cpp에서 #include돼도 딱 한 번만 펼쳐지게 하는 중복 포함 방지 지시입니다. 같은 구조체를 두 번 정의하면 컴파일 오류가 나기 때문에 헤더 맨 위의 관례입니다.

struct Mat4 { ... }; — struct는 class와 거의 같지만 기본 접근이 public이라, 수학용 값 타입처럼 멤버를 자유롭게 읽고 쓰는 자료구조에 적합합니다.

float m[16] = { 0 }; — 4×4=16개의 실수를 담는 배열입니다. = { 0 }는 집합 초기화(aggregate initialization)로, 첫 원소를 0으로 두면 나머지 15칸도 자동으로 0이 됩니다. 즉 Mat4를 만들면 영행렬(모두 0)로 시작합니다. 이 "기본이 0"이라는 사실은 뒤에서 함정으로 다시 등장하니 기억해 두세요.

인덱싱 m[r*4 + c]가 왜 이 공식인가

행 우선이란 "한 행을 통째로 먼저 저장하고, 그다음 행을 이어 붙인다"는 뜻입니다. 그러면 r번째 행은 앞에 이미 r개의 행(각 4칸)이 놓여 있으니 r*4칸을 건너뛴 자리에서 시작하고, 그 행 안에서 c번째 열이니 +c를 더합니다. 그래서 m[r*4 + c]입니다.

메모리 한 줄을 그림글로 그리면 이렇습니다(인덱스 0~15):

index :  0    1    2    3  | 4    5    6    7  | 8    9   10   11 | 12   13   14   15
(r,c) : (0,0)(0,1)(0,2)(0,3)|(1,0)(1,1)(1,2)(1,3)|(2,0)(2,1)(2,2)(2,3)|(3,0)(3,1)(3,2)(3,3)
행    :  <-------- row0 ------->|<-------- row1 ------->|<-------- row2 ------->|<-------- row3 ------->

예) at(2,1) -> m[2*4 + 1] = m[9]   // 3번째 행(r=2), 2번째 열(c=1)
    at(0,3) -> m[0*4 + 3] = m[3]
    at(3,3) -> m[3*4 + 3] = m[15]  // 오른쪽 맨 아래 구석

접근자 at이 두 개인 이유 — const 오버로드

float& at(int r, int c)는 성분에 대한 참조(&)를 돌려줍니다. 참조를 돌려주니 M.at(0,0) = 1;처럼 왼쪽에 두고 값을 대입할 수 있습니다(쓰기 가능).

두 번째 const float& at(int r, int c) const는 함수 끝에 const가 붙어 "이 함수는 Mat4 자신을 건드리지 않는다"고 약속합니다. 그래서 const Mat4&로 받은 읽기 전용 행렬에서도 성분을 꺼내 볼 수 있습니다. 반환도 const float&라 실수로 값을 바꿀 수 없습니다. 아래 곱셈 함수는 인자를 const A, const B로 받는데, 이 const 버전이 없으면 A.at(r,k) 같은 읽기조차 컴파일되지 않습니다. 그래서 쓰기용 · 읽기용 두 벌을 둡니다.

참조로 돌려주는 또 다른 이점은 복사 비용 0입니다. float 하나야 작지만, 배열 원소의 실제 위치를 가리키므로 대입이 곧바로 원본에 반영되는 것이 핵심입니다.

2. 항등행렬 identity() — "아무것도 안 바꾸는" 기준점

항등행렬(identity matrix)은 대각선만 1이고 나머지는 0인 행렬입니다. 숫자에서 1을 곱하면 그대로이듯, 어떤 행렬 M이나 벡터 v에 항등행렬을 곱해도 값이 그대로입니다(M·I = M, v·I = v). 그래서 변환을 아직 아무것도 안 한 초기 상태, 여러 변환을 누적할 때의 출발점으로 씁니다.

    static Mat4 identity() {
        Mat4 r;                 // 모든 성분 0 (집합 초기화 덕분)
        r.at(0,0) = 1;          // 대각선만 1로
        r.at(1,1) = 1;
        r.at(2,2) = 1;
        r.at(3,3) = 1;
        return r;
    }

한 줄씩 해부

static Mat4 identity() — static이라 특정 인스턴스가 아니라 타입에 속한 함수입니다. 그래서 객체 없이 Mat4::identity()로 호출해 새 행렬을 찍어내는 팩토리처럼 씁니다.

Mat4 r; — 앞서 본 = { 0 } 덕분에 이 순간 r은 완전한 영행렬입니다. 그래서 뒤이어 대각선 4칸만 1로 덮으면 나머지는 이미 0이라 손댈 필요가 없습니다.

r.at(0,0)=1; r.at(1,1)=1; r.at(2,2)=1; r.at(3,3)=1; — (0,0),(1,1),(2,2),(3,3)이 주대각선입니다. 이 네 자리는 메모리로는 m[0], m[5], m[10], m[15](각각 r*4+c로 0, 5, 10, 15)에 해당합니다. at가 참조를 돌려주니 = 1 대입이 곧바로 배열에 꽂힙니다.

| 1  0  0  0 |
| 0  1  0  0 |
| 0  0  1  0 |
| 0  0  0  1 |

3. 행렬 곱 operator* — 그래픽스의 심장

행렬 곱 C = A * B는 "두 변환을 하나로 합치는" 연산입니다. 예를 들어 A가 회전, B가 투영이라면 A*B는 "회전하고 나서 투영하는" 단일 행렬이 됩니다. 정점 수백만 개에 두 변환을 따로 적용하는 대신 미리 한 번 곱해 두면 정점당 곱셈이 절반으로 줍니다. 이게 MVP를 미리 만드는 이유입니다.

수학적 의미 → 직관 → 코드

① 수학: 결과 행렬의 (r,c) 성분은 정해진 공식으로 계산됩니다.

C(r,c) = A(r,0)·B(0,c) + A(r,1)·B(1,c) + A(r,2)·B(2,c) + A(r,3)·B(3,c)
       = Σ (k=0..3)  A(r,k) · B(k,c)

② 직관(그림글): C의 (r,c)를 구하려면 A의 r번째 가로줄(행)과 B의 c번째 세로줄(열)을 겹쳐 놓고, 같은 위치끼리 곱해서 4개를 전부 더합니다. "A의 한 행이 B의 한 열 위를 훑고 지나가며 내적을 만든다"고 상상하면 됩니다.

          B의 c열 (세로)
             ↓
          [ B(0,c) ]
   A의 r행  [ B(1,c) ]
[A(r,0) A(r,1) A(r,2) A(r,3)]  ·  [ B(2,c) ]  =  C(r,c)
             (가로)              [ B(3,c) ]

C(r,c) = A(r,0)·B(0,c) + A(r,1)·B(1,c) + A(r,2)·B(2,c) + A(r,3)·B(3,c)

③ 코드: 이 공식을 그대로 3중 루프로 옮깁니다.

// C = A * B,  C(r,c) = Σ A(r,k)·B(k,c)
inline Mat4 operator*(const Mat4& A, const Mat4& B) {
    Mat4 C;                                   // 결과: 처음엔 영행렬
    for (int c = 0; c < 4; ++c)               // 결과의 열을 하나씩
        for (int r = 0; r < 4; ++r) {         // 그 열의 행을 하나씩 -> (r,c) 한 칸
            float sum = 0;                    // 이 칸의 누적합
            for (int k = 0; k < 4; ++k)       // 내적: A의 r행 × B의 c열
                sum += A.at(r,k) * B.at(k,c);
            C.at(r,c) = sum;                  // 완성된 (r,c) 성분 기록
        }
    return C;
}

한 줄씩 해부

inline Mat4 operator*(const Mat4& A, const Mat4& B) — operator*를 오버로딩해 A * B라고 쓰면 이 함수가 불리게 만듭니다. 함수 이름을 multiply(A,B)로 둘 수도 있지만, world * view * proj처럼 수식 그대로 자연스럽게 읽히는 코드를 위해 연산자로 정의합니다. 인자를 const Mat4&(읽기 전용 참조)로 받는 이유는 64바이트짜리 행렬을 복사하지 않고 원본을 안전하게 참조하기 위함입니다. inline은 헤더에 정의를 두어 여러 파일에서 포함해도 중복 정의 오류가 나지 않게 하는 표시입니다.

Mat4 C; — 결과 행렬. 집합 초기화로 0에서 시작하므로, 아래에서 16칸을 모두 덮어씁니다.

바깥 두 루프 for(c) for(r) — 결과 C의 16개 칸 (r,c)을 하나씩 돌기 위한 이중 루프입니다. 여기서는 바깥이 열(c), 안쪽이 행(r) 순서입니다. 논리적 결과는 순서와 무관합니다 — 어차피 16칸을 전부 채우니까요. 다만 뒤에 나올 cbuffer가 열 우선으로 해석하는 것과 시각을 맞추려고 "열을 먼저 고르고 그 안의 행을 훑는" 순서로 적어 두면 열 단위로 결과를 떠올리기 편합니다.

안쪽 루프 for(k)와 sum — 고른 한 칸 (r,c)의 값을 만드는 내적입니다. k=0,1,2,3을 돌며 A.at(r,k) * B.at(k,c)를 더합니다. 여기서 반복 변수 k가 A에서는 열 번호로, B에서는 행 번호로 동시에 쓰이는 것이 핵심입니다. 두 번째 인덱스(k)가 겹쳐 돌아가며 "A의 r행"과 "B의 c열"을 짝지어 줍니다.

그래서 4×4 곱은 성분 16개 × 각 4번 곱셈 = 총 64번의 곱셈과 48번의 덧셈으로 이뤄집니다. "16개 곱셈의 합"이라는 말은 한 칸을 기준으로 볼 때 곱셈이 4개 더해진다는 뜻이고, 행렬 전체로는 16칸 × 4 = 64회가 됩니다.

손으로 한 칸 계산해 보기

간단한 예로 A를 항등행렬, B를 임의 행렬로 두고 C(0,0)을 계산해 봅시다. A의 0행은 [1, 0, 0, 0]이므로:

C(0,0) = A(0,0)·B(0,0) + A(0,1)·B(1,0) + A(0,2)·B(2,0) + A(0,3)·B(3,0)
       =   1·B(0,0)    +   0·B(1,0)    +   0·B(2,0)    +   0·B(3,0)
       =   B(0,0)

// 항등행렬은 1이 있는 자리 하나만 살아남으므로 결국 C = B.  I * B = B 를 성분으로 확인.

이렇게 항등행렬의 0행 [1,0,0,0]은 B의 0행만 그대로 골라냅니다. 다른 행도 마찬가지라 C = A*B = I*B = B가 성분 수준에서 확인됩니다. 항등행렬이 "아무것도 안 바꾼다"는 성질의 실체입니다.

4. 전치 transpose — 행과 열 뒤집기

전치(transpose)는 행렬을 주대각선 기준으로 대칭 이동시켜 (r,c)와 (c,r)을 맞바꾸는 연산입니다. Mᵀ(r,c) = M(c,r). 순수 수학에서도 자주 쓰지만, 우리 파이프라인에서 전치가 등장하는 진짜 이유는 GPU로 행렬을 올릴 때 저장 순서를 맞추기 위해서입니다(6번 항목에서 상세히).

// 전치: (r,c) ↔ (c,r).  cbuffer 업로드 시 HLSL의 열 우선 관례에 맞추려고 사용.
inline Mat4 transpose(const Mat4& M) {
    Mat4 r;
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            r.at(i,j) = M.at(j,i);     // 인덱스를 뒤집어 대입
    return r;
}

한 줄씩 해부

inline Mat4 transpose(const Mat4& M) — 원본 M은 읽기만 하고(const&), 새 행렬 r을 만들어 돌려줍니다(원본을 제자리에서 바꾸지 않음).

이중 루프의 핵심은 대입 한 줄 r.at(i,j) = M.at(j,i);입니다. 왼쪽은 (i,j), 오른쪽은 인덱스가 뒤집힌 (j,i)입니다. 즉 결과의 (i,j) 자리에 원본의 (j,i) 값을 가져다 놓습니다. 이 한 줄이 곧 Mᵀ(i,j)=M(j,i)의 코드 번역입니다.

메모리로 보면: 원본에서 m[j*4+i]에 있던 값이 결과에서 m[i*4+j]로 옮겨 갑니다. 주대각선(i==j)은 자기 자신이라 안 움직이고, 나머지는 대각선을 기준으로 짝을 지어 자리를 바꿉니다.

        원본 M                     전치 Mᵀ
| a  b  c  d |            | a  e  i  m |
| e  f  g  h |    ->      | b  f  j  n |
| i  j  k  l |            | c  g  k  o |
| m  n  o  p |            | d  h  l  p |
// b(0,1)↔e(1,0),  c(0,2)↔i(2,0),  g(1,2)↔j(2,1) ...  대각 a,f,k,p는 그대로

5. 상수 버퍼(cbuffer) 업로드 — 그리고 전치가 필요한 진짜 이유

CPU에서 만든 MVP 행렬을 셰이더가 쓰려면 상수 버퍼(constant buffer, cbuffer)라는 GPU 메모리로 복사해야 합니다. 행렬은 그냥 float 16개이니 memcpy로 통째로 밀어 넣습니다. 문제는 CPU와 HLSL의 저장 순서 해석이 다르다는 점입니다.

struct CBTransform { float mvp[16]; };      // cbuffer와 1:1 대응하는 CPU 구조체

Mat4 mvp = world * view * proj;             // 우리 규약: 행벡터라 v' = v*(W*V*P)

// HLSL의 cbuffer float4x4는 기본적으로 '열 우선'으로 해석한다.
// 우리는 '행 우선' 저장이므로, 그대로 올리면 GPU가 전치된 걸로 읽는다 -> 미리 전치해서 상쇄.
Mat4 t = transpose(mvp);

CBTransform cb;
std::memcpy(cb.mvp, t.m, sizeof(cb.mvp));   // float 16개를 그대로 복사

context->UpdateSubresource(constantBuffer.Get(), 0, nullptr, &cb, 0, 0);
context->VSSetConstantBuffers(0, 1, constantBuffer.GetAddressOf());

한 줄씩 해부

struct CBTransform { float mvp[16]; }; — 셰이더 쪽 cbuffer의 float4x4와 바이트 레이아웃이 정확히 같은 CPU 구조체입니다. 여기 담긴 순서 그대로 GPU 메모리에 놓입니다.

Mat4 mvp = world * view * proj; — 앞의 곱셈 연산자로 세 변환을 하나로 합칩니다. 행벡터 규약이라 정점은 셰이더에서 mul(v, mvp)(즉 v * mvp)로 곱해집니다.

Mat4 t = transpose(mvp); — 핵심 한 줄. 우리는 mvp를 행 우선으로 저장했는데, HLSL cbuffer의 float4x4는 열 우선으로 읽습니다. 같은 16개 바이트를 서로 다른 순서로 해석하면 결과가 전치된 행렬이 됩니다. 그래서 미리 한 번 전치해서 올리면 GPU 쪽의 전치 해석과 서로 상쇄되어 우리가 의도한 행렬이 그대로 적용됩니다.

std::memcpy(cb.mvp, t.m, sizeof(cb.mvp)); — 전치한 행렬의 배열 t.m 16개를 구조체로 복사합니다. sizeof(cb.mvp)는 16*4=64바이트. 행 우선으로 저장을 맞춰 뒀기에 필드별로 옮기지 않고 한 번에 복사됩니다.

UpdateSubresource(...) — CPU의 cb를 GPU 상수 버퍼로 전송합니다. VSSetConstantBuffers(0, 1, ...)는 그 버퍼를 버텍스 셰이더의 슬롯 0번에 바인딩해, 셰이더가 register(b0)로 접근할 수 있게 합니다.

6. DirectXMath 버전 — 실무 표준

학습을 위해 직접 만들었지만, 실무에서는 SIMD로 최적화된 DirectXMath를 씁니다. 아래는 위 코드와 1:1로 대응합니다.

#include <DirectXMath.h>
using namespace DirectX;

XMMATRIX mvp = XMMatrixIdentity();          // 항등행렬 (우리 identity()에 대응)
// ... 여기서 world/view/proj를 곱해 mvp를 구성 ...

XMFLOAT4X4 mvpStore;                          // 저장용 4x4 (구조체 멤버로 안전)
XMStoreFloat4x4(&mvpStore, XMMatrixTranspose(mvp));  // 전치 후 메모리에 저장

CBTransform cb;
memcpy(cb.mvp, &mvpStore, sizeof(cb.mvp));    // 그대로 cbuffer로
UpdateSubresource(/* ... */);

원본 ↔ DirectXMath 1:1 대응

정리

• 저장: float m[16]을 행 우선으로, (r,c) = m[r*4+c]. DirectXMath와 배치를 맞추기 위함.
• identity: 대각선만 1인 "변화 없음" 행렬. 누적의 출발점(영행렬로 시작하면 화면이 까맣게 됨).
• 곱셈: C(r,c)=Σ A(r,k)·B(k,c). 3중 루프로 16칸 × 4곱 = 64회. 교환법칙 없음(순서 중요).
• 전치: (r,c)↔(c,r). cbuffer의 열 우선 해석과 상쇄시키기 위해 업로드 직전 한 번.
• 실무: XMMATRIX(계산) / XMFLOAT4X4(저장) + XMMatrixTranspose로 전치.