Code in Coffee

[CPP] 1. 객체와 메모리

타자치는 문돌이 — Tue, 14 Jul 2026 17:17:06 +0900

객체에 어떻게 접근할까? - 주소와 포인터

#include <iostream>

int main()
{
    int x = 10;
    int* p = &x;
    int& r = x;

    std::cout << "x value: " << x << '\n'; 
    std::cout << "x address: " << &x << '\n';

    std::cout << "p value: " << p << '\n'; 
    std::cout << "p address: " << &p << '\n'; 
    std::cout << "*p value: " << *p << '\n';

    std::cout << "r: " << r << '\n'; 
    std::cout << "&r: " << &r << '\n';
}

x는 객체다.
메모리의 어딘가에 4 바이트의 메모리를 잡고 10을 저장한다.

&x는 x가 10을 저장한 메모리의 주소이다.

int* p는 주소를 저장하는 변수로, 여기에 x의 주소인 &x를 저장할 수 있다.
즉, p는 x의 주소 &x이다.

*p는 p의 주소에 저장된 객체에 접근한다.
p는 x의 주소가 있으므로 x의 주소에 저장된 10에 접근한다.

int& r은 x를 x라는 이름 대신 r이라는 이름으로 쓸 수 있게 해준다.
따라서 r의 주소도 x와 같고, 값도 x와 같으며, x를 수정하면 값이 같이 달라진다.

x value: 10
x address: 0x7ffe0d6f03a4
p value:   0x7ffe0d6f03a4
p address: 0x7ffe0d6f03a8
*p value: 10
r: 10
&r:        0x7ffe0d6f03a4

int* p의 *와 *p의 *는 역할이 다르다.
int*는 p가 포인터 변수라는 것을 알려주는 선언자(int, float 같은)의 한 부분이고,
*p는 p의 주소에 저장된 객체에 접근하는 연산자이다.
int&과 &도 마찬가지로 int&는 선언자, &는 주소를 반환하는 연산자이다.

객체의 수명 - Stack, Heap, Static의 생명주기

운영체제를 공부할 때, 프로세스의 지역 변수는 Stack, 전역 변수는 Data, 동적으로 할당된 데이터는 Heap에 저장된다고 배웠다.

이 데이터는 언제까지 유효할까?

#include <iostream>

struct Tracer
{
    const char* Name;

    Tracer(const char* InName) : Name(InName)
    {
        std::cout << "Construct: " << Name << '\n';
    }

    ~Tracer()
    {
        std::cout << "Destruct: " << Name << '\n';
    }
};

Tracer GlobalTracer("Global");

void Foo()
{
    std::cout << "Enter Foo\n";
    Tracer LocalTracer("Local in Foo");
    Tracer* DynamicTracer = new Tracer("Dynamic in Foo");
    std::cout << "DynamicTracer : "<< DynamicTracer << '\n';
    delete DynamicTracer;
    std::cout << "Leave Foo\n";
}

int main()
{
    std::cout << "Enter main\n";
    std::cout << "GlobalTracer : "<< &GlobalTracer << '\n';
    Tracer LocalTracer("Local in main");
    std::cout << "LocalTracer : "<< &LocalTracer << '\n';
    Foo();
    std::cout << "Leave main\n";
}

Tracer는 생성과 소멸에 Name을 출력한다.

Construct: Global
    Enter main
    GlobalTracer : 0x56343152d158
    Construct: Local in main
    LocalTracer : 0x7fffd3d7cd80
        Enter Foo
        Construct: Local in Foo
        Construct: Dynamic in Foo
        DynamicTracer : 0x56343c94c6c0
        Destruct: Dynamic in Foo
        Leave Foo
        Destruct: Local in Foo
    Leave main
    Destruct: Local in main
Destruct: Global

전역 객체는 main보다 먼저 생성되고, 프로그램 종료 시점에 사라진다.
지역 객체는 Scope에 들어가면 생성되고, Scope 종료 시점에 사라진다.
동적 객체는 new에 생성되고, delete에 소멸한다. delete가 없으면 사라지지 않는다.

객체는 어떻게 메모리에 배치되는가 - `sizeof`, alignment, padding

#include <iostream>

struct A
{
    char c1;
    int i;
    char c2;
};

struct B
{
    int i;
    char c1;
    char c2;
};

int main()
{
    std::cout << "sizeof(char): " << sizeof(char) << '\n';
    std::cout << "sizeof(int): " << sizeof(int) << '\n';
    std::cout << "sizeof(void*): " << sizeof(void*) << '\n';

    std::cout << "sizeof(A): " << sizeof(A) << '\n';
    std::cout << "sizeof(B): " << sizeof(B) << '\n';
}

sizeof는 객체가 차지하는 메모리의 크기이다.

sizeof(char): 1
sizeof(int): 4
sizeof(void*): 8
sizeof(A): 12
sizeof(B): 8

void*는 포인터의 크기로, 64 bit 환경에서는 주로 8 바이트, 32 bit에서는 4 바이트이다.

A와 B는 같은 내용을 담지만, 12와 8로 크기가 다르다. 이는 alignment에 따른 변수의 위치 조정 때문이다. int의 alignment가 4라면, int 객체는 메모리의 4의 배수 자리에 놓인다.
A의 경우 char-int-char 순서로 놓는 동시에 int를 4의 배수 자리에 놓기 위해 char 뒤에 padding 3 바이트를 추가한다.
B는 같은 데이터지만, int-char-char로 배치해 alignement가 1인 char를 붙여 배치할 수 있으므로 8 바이트만 사용한다.

alignment에 따른 padding은 클래스에서도 마찬가지로 발생한다.

배열, 포인터, 연속 메모리

#include <iostream>

int main()
{
    int arr[3] = {10, 20, 30};
    int* p = arr;

    std::cout << "sizeof(int): " << sizeof(int) << '\n';
    std::cout << "sizeof(arr): " << sizeof(arr) << '\n';
    std::cout << '\n';

    std::cout << "&arr[0]: " << &arr[0] << '\n';
    std::cout << "&arr[1]: " << &arr[1] << '\n';
    std::cout << "&arr[2]: " << &arr[2] << '\n';
    std::cout << '\n';

    std::cout << "arr: " << arr << '\n';
    std::cout << "&arr[0]: " << &arr[0] << '\n';
    std::cout << '\n';

    std::cout << "sizeof(arr) : " << sizeof(arr) << '\n';
    std::cout << "sizeof(&arr[0]) : " << sizeof(&arr[0]) << '\n';
    std::cout << "sizeof(p) : " << sizeof(p)   << '\n';
    std::cout << '\n';

    std::cout << "p : " << p << '\n';
    std::cout << "p+1 : " << p + 1 << '\n';
    std::cout << "p+2 : " << p + 2 << '\n';
}

&arr[1]: 0x7ffc8015d550
&arr[2]: 0x7ffc8015d554

arr: 0x7ffc8015d54c
&arr[0]: 0x7ffc8015d54c

sizeof(arr) : 12
sizeof(&arr[0]) : 8
sizeof(p) : 8

p : 0x7ffc8015d54c
p+1 : 0x7ffc8015d550
p+2 : 0x7ffc8015d554

배열은 같은 타입의 객체가 연속된 메모리에 저장된다.
따라서 int 배열 원소의 주소는 4 차이이다.

배열 이름은 포인터가 아니지만, 많은 표현식에서 배열의 첫 원소를 가리키는 포인터로 변환된다.
따라서 arr은 &arr[0]으로 쓰기도 한다.
둘은 같은 메모리 주소를 반환한다.

그러나 sizeof(arr)는 arr의 크기 (4*3), sizeof(&arr[0])과 sizeof(p)는 arr[0]와 p의 포인터 객체 크기(8)이다.

포인터의 산술 연산은 타입 크기를 기준으로 한다.
int*의 연산은 4 바이트 기준이다.
따라서 p + 1은 p + int (4 바이트)이다.
내부적으로 arr[i] == *(arr + i)이다.

#include <iostream>

struct A
{
    char c1;
    int i;
    char c2;
};

int main()
{
    A arr[3];

    std::cout << "sizeof(A): " << sizeof(A) << '\n';

    std::cout << "&arr[0]: " << &arr[0] << '\n';
    std::cout << "&arr[1]: " << &arr[1] << '\n';
    std::cout << "&arr[2]: " << &arr[2] << '\n';
}

sizeof(A): 12
&arr[0]: 0x7fff34d9d070
&arr[1]: 0x7fff34d9d07c
&arr[2]: 0x7fff34d9d088

A는 char+int+char로 char 1 + [padding 3] + int 4 + char 1 + [padding 3]로 12 바이트를 차지한다. 이때 마지막 char도 tail padding을 가져 A의 배열에서도 그 크기만큼 간격이 생긴다. 따라서 A 배열의 각 원소는 12 바이트 간격으로 배치된다.

사라진 객체 - Dangling Pointer와 Undefined Behavior

Dangling Pointer

Dangling Pointer는 이미 수명이 끝난 객체를 가리키는 포인터이다.

#include <iostream>

int* MakePointer()
{
    int Local = 10;
    return &Local; // 위험
}

int main()
{
    int* p = MakePointer();

    std::cout << *p << '\n'; // Undefined Behavior
}

Local은 MakePointer()가 종료되면 사라지지만, p는 사라진 Local의 주소를 들고 있다.
이때 사라진 Local의 주소를 가리키는 p를 dangling pointer라고 한다.

int* p = new int(10);

delete p;

std::cout << *p << '\n'; // Undefined Behavior

이 경우도 p는 delete로 사라진 new int(10)의 주소를 들고 있다.
안전하게 처리하려면

delete p;
p = nullptr;

로 처리한다.

nullptr과 dangling pointer는 다르다. nullptr은 '아무 객체도 가리키지 않는다'는 명확한 값으로

if (p)
{
    std::cout << *p << '\n';
}

와 같이 사용할 수 있지만,
dangling pointer의 값은 nullptr이 아닐 수도, 유효하지 않은 예전 주소값을 그대로 가지고 있을 수도 있다.

dangling pointer와 마찬가지로 dangling reference도 존재한다.

int& MakeReference()
{
    int Local = 10;
    return Local; // 위험
}

int main()
{
    int& r = MakeReference();

    std::cout << r << '\n'; // Undefined Behavior
}

마찬가지로 이미 소멸한 객체를 참조하고 있다면 위험하다.

Undefined Behaviour

C++이 프로그램이 어떻게 동작할지 정의하지 않는다는 뜻으로 어떤 결과나 나올지 모른다.
정상처럼 보일 수도, 쓰레깃값이 나올 수도, 크래시가 날 수도 있다.

int* p = new int(10);

delete p;

std::cout << *p << '\n';

이 코드가 어떤 경우에는 10을 출력할 수 있지만, 그건 우연히 메모리에 아직 10이 남아 있던 것이고 항상 같은 결과를 보장하지도, 안전하지도 않다.

#include <iostream>

int main()
{
    int arr[3] = {10, 20, 30};

    std::cout << arr[3] << '\n'; // Undefined Behavior
}

arr[3]은 *(arr + 3)으로 arr[2] 다음 위치 주소를 역참조한다. 그러나 이 위치의 값은 무엇일지 알 수 없다. 따라서 역참조하면 안 된다.

이를 반복문에 활용할 수는 있다.

int arr[3] = {10, 20, 30};

int* begin = arr;
int* end = arr + 3;

for (int* p = begin; p != end; ++p)
{
    std::cout << *p << '\n';
}

반복문의 종료 지점으로 사용하지만, 절대 그 값을 역참조해서는 안 된다.

const와 메모리

const는 이 이름을 통해서는 객체를 수정하지 않겠다는 뜻이다.

const int x = 10;

x = 20; // 컴파일 에러

`const int`와 `int const`

int a = 10;
int b = 20;

const int* p = &a;

*p = 30; // 불가능
p = &b;  // 가능

이건 p가 가리키는 int를 수정할 수 없다는 뜻이다.
p가 b를 가리킬 수는 있다.
그러나 p가 가리키는 값을 수정할 수는 없다.
즉, 대상은 수정 가능하지만, 내용은 수정할 수 없다.

int* const p = &a;

*p = 30; // 가능
p = &b;  // 불가능

이건 반대로 p 자체가 const이므로
p가 가리키는 int를 바꿀 수는 없지만, p가 가리키는 int의 값을 수정할 수는 있다.
즉, 대상은 수정할 수 없지만, 내용은 수정 가능하다.

const int* const p = &a;

이러면 대상도 내용도 수정할 수 없다.

const &

int a = 10;

const int& r = a;

r = 20; // 불가능 
a = 20; // 가능

r은 a의 별칭으로, r의 값은 수정할 수 없다는 뜻이다.

함수 인자로의 `const`

C++의 const는 함수 인자를 받을 때의 약속이 된다.

void PrintValue(const int& value)
{
    std::cout << value << '\n';
}

이 경우 value를 복사하지 않고 참조로 받지만, 함수 안에서 value를 수정하지 않는다는 뜻이다. 즉, value의 복사 비용이 들지 않고, 읽기 전용으로 전달할 수 있다.

[softeon-theme] Stitch와 Codex로 Jekyll Blog Theme 만들기

타자치는 문돌이 — Wed, 17 Jun 2026 17:17:10 +0900

Home | softeon-theme

This preview sentence appears on the Projects Sample Beta card. Sample Projects Order 70

taeahnk.github.io

GitHub - TaeAhnK/softeon-theme

Contribute to TaeAhnK/softeon-theme development by creating an account on GitHub.

github.com

Codex가 프론트엔드는 매우 잘 만든다고 해서 기존의 포트폴리오 사이트를 새로 만들어보기로 했다. 웹개발 쪽은 잘 모르지만 정적 웹사이트 정도는 만들 수 있을 것 같다.

지금은 Github Pages로 호스팅하는 Jekyll 블로그를 포폴로 쓰고 있다.
사이트에서 다운 받은 템플릿을 조금 수정해 사용 중이다.
현재 사이트도 나쁘지 않지만 만들어 보고 싶은 기능이 있어 새로 만들어 보기로 했다.

가끔씩 포트폴리오를 pdf로 요구하는 회사들이 있다. 포트폴리오에 프로젝트가 늘어나고 게시글이 많아질수록 이걸 워드나 파워포인트로 옮겨서 작성하기가 어렵다. 특히 코드 블록이 모두 어그러진다.
그래서 포트폴리오에 프린트용 View를 따로 두고, 이걸 pdf로 저장해 제출하려고 한다.

기능 기획

먼저 구현해야 할 기본 기능은 다음과 같다.

Header, Hero, Profile, Projects, Other Projects, Current Project 섹션
Markdown 프로젝트 포스트
포스트에서 썸네일과 설명, 태그를 추출하고, 적절한 섹션에 적절한 순서로 배치
썸네일로 이미지 또는 유튜브 영상 사용
이후 Markdown 포스트 추가만으로 확장 가능
반응형으로 브라우저 크기를 줄여도 어색하지 않은 화면

이 기능들은 이전 포트폴리오에서도 수정해서 적용했었다.
추가로 구현해야 하는 기능은

print.html에서 print용 view 보여주기
<div class="print-hide">가 있으면 print view에서 숨기기
인쇄 시 (pdf로 출력) 적절한 위치에서 페이지 나눔
print.html은 A4에 적절한 css
<div class="print-show">가 있으면 게시글에선 숨기고 print view에서 보여주기
print view에서 보여줄 project 개수 설정

구현

Codex에게 다음 순서로 작업을 요청했다.

Init
Index 페이지 구현
Post 페이지 구현
테스트 게시글 생성
카드 제목/설명/썸네일 출력
Youtube Embed 출력
디자인 파일 적용
다크모드 적용
print.html 구현
<div class="print-hide"> 구현
프린트모드 적용

단계별로 구현에 필요한 내용을 Feature.md에 적고, 해당 내용을 참고하며 작업을 요청했다.
먼저 블로그의 구조를 정의했다. 기존 블로그와 비슷한 구조로

Header
Hero
About
Projects
Other Projects
Current Projects
Footer

로 구성했다. 프로젝트 섹션에서는 카드 형태로 게시물을 보여준다.

포스트는 간단하게 뒤로가기 버튼이 있는 헤더와 제목, 본문, Footer로 구성했다.

마크다운만으로 새 프로젝트를 추가할 수 있도록 프로젝트 포스트의 Front Matter에 다음과 같은 내용을 정의했다.

---
layout: post
title: Title
display_area: projects / other-projects / current-projects / hide
display_order: number (descending order)
thumbnail_type: img / vid
thumbnail_img: path
thumbnail_vid: "{youtube link}"
tags: tags for thumbnail
---

Front Matter의 값에 따라 보일 섹션과 순서, 썸네일 타입과 썸네일을 정의했다. 썸네일에서 같이 보여줄 태그도 작성했다. display_order는 나중에 프로젝트를 추가할수록 앞에 오는 일이 많을 것 같아 내림차순으로 적용했다.

메인 페이지의 프로젝트 소개글은 excerpt_separator로 구분하고, 이 내용은 포스트를 볼 때는 보이지 않게 했다.

---
(front matter)
---

Preview Description

<!-- preview -->

(Main Post)

이건 이전 포트폴리오에서 쓰던 방식으로 preview용 마크다운을 따로 두거나 하는 다른 방식보다 편했다.

나는 디자인을 못 한다. 내가 가장 취약한 부분이다.
일단은 Google Stitchs가 웹 디자인을 해줄 수 있다고 하니 한번 사용해 보았다.

게임 개발자 포트폴리오를 만들 것이고, 위에서 만든 레이아웃을 사용할 것이라고 했다.

괜찮은 디자인이 나왔다.
프린트모드를 다크모드로 만들었다간 인쇄할 때 어떤 끔찍한 일이 생길지 모르므로 라이트모드도 만들어 달라고 했다.

AI가 유독 좋아하는 흰색+보라색 조합으로 만들어줬다. Neon 느낌이 약해졌지만, 마음에 들었다. 아쉬워도 뭐가 어색하니 고쳐달라 할 감각이 부족하다.
이 6개의 이미지를 zip으로 내보냈다. 팔레트는 Markdown, 사이트는 이미지와 html로 제공한다.
이 파일을 주고 이 디자인을 그대로 프로젝트에 적용해달라고 했다.

거의 완성된 블로그가 만들어졌다. 텍스트를 yml 파일로 수정할 수 있도록 연결하고, home.yml에서 관리할 수 있게 했다. 마음에 안 드는 간격과 위치는 조금씩 조정했다.

다크모드 버튼도 추가해달라 하고, 다크모드 디자인도 적용해달라고 했다.

print.html을 어떤 식으로 구현할지를 고민해야 했다. 우선은 index.html을 구성하는 다양한 include html을 인쇄용에 적합하게 배치하고, post collections를 이어 붙이는 방식으로 구현해 보았다. 원하는 대로 index.html이 cover 역할을 하고, post가 내용 역할을 하는 pdf가 만들어졌다. 모양과 정렬 등은 나중에 css에서 처리하기로 했다.

print.html은 별도의 css를 만들어 달라고 했다. 폰트 크기부터 규칙까지 다른 부분이 많아 적용할 내용이 많았기 때문이다. 대표적으로

폰트 크기 10pt
별도의 링크 소개
항상 라이트모드
<details>로 접힌 부분 모두 열어두기
포스트 끝마다 페이지 넘기기 적용
코드 블록이 길어지면 줄바꿈
클릭해도 게시물로 넘어가지 않기
등을 적용해야 했다.

포스트에서 프린트모드에서 숨길 부분은 <div class="print-hide>로 감싸면 숨겨지게 했다. 웹에서는 코드를 모두 보여줘도 <details>로 숨겨 분량 걱정이 없지만, 이걸 그대로 출력하면 포폴이 너무 길어져 편집해야 한다. 그리고 Demo 영상도 숨겨야 한다.

그리고 출력 설정으로

특정 부분을 크롬 인쇄 설정으로 미표시하지 않기
위아래 1 inch margin
을 줘야 했다.

이런 부분은 모두 codex에 맡기고, codex가 css를 수정해 적용했다.

마지막으로 config.yml에서 레이아웃 조정이 가능하게 했다. 각 섹션의 가로 프로젝트 개수, 보여줄 프로젝트 개수, 프린트모드에서 보여줄 프로젝트 개수를 설정하게 해 개수가 달라져도 모양이 어색하지 않게 했다.

index:
  projects_count: 4
  other_projects_count: 3
  current_projects_count: 1

print:
  projects_count: 4
  other_projects_count: 3
  current_projects_count: 1

괜찮은 Jekyll Theme이 만들어졌다.

이걸 기존 포트폴리오에 적용해 보았다.

테스트 때는 몰랐는데 폰트가 별로여서 수정했다. (한글 태그에 굴림체가 적용됐다.)
그리고 아무리 노력해도 줄 끝 맞춤과 단어 잘림의 적절한 조합을 모르겠다.
가끔 긴 단어 앞에서의 넓어지는 여백이나 어색하게 잘리는 단어, 안 맞는 줄 끝 중 하나를 택해야 한다. 이것 때문에 문장을 수정하는 경우도 종종 등장한다.

느낀 점

사실 말이 안 된다. html, css에 대한 매우 기초적인 지식은 있고, Jekyll로 다른 사람이 만든 Theme을 사용해 블로그를 만들어 봤지만 이 기술에 대한 이해는 분명 부족하다. 그럼에도 Codex에 해달라고 하면 어지간한 기능이 완성된다.

물론 한계가 있다고 생각한다. 먼저 이건 정적 웹사이트다. css, html 잘하고 예뻐 보이면 땡이다. 이건 AI가 매우 잘하는 분야일 것이다. 서버가 있는 동적 웹사이트면 다양한 오류와 요구사항에 맞지 않는 구현이 자주 나올 것이다.

기술에 대한 이해 없이 썼을 때의 문제도 있다. 먼저 토큰이다. 5시간 토큰 제한에 걸린 게 거의 처음이다. css를 잘 모르니 간단한 css 수정과 롤백도 다 Codex에 맡기게 된다. 그리고 수정을 위해 필요한 파일의 위치를 모르니 프로젝트를 다 검색하는 경우도 자주 있다. 로직을 설명하며 구현하라고 하면 더 정확하고 저렴하게 구현하지만 내가 원하는 기능을 묘사만 하고 만들어 달라고 하면 토큰이 녹는다.

이런 이유로 개발자가 필요하다고는 하지만... 결국 토큰 가성비가 좋은 모델이 나올수록 해결될 문제 아닐까? 수정해야 할 개발자가 필요하다는 것도 이전만큼 많은 개발자가 필요하지는 않다는 것이다. 기술을 아는 개발자가 필요는 하지만 많이 필요하지 않고, 기존의 개발자로 더 큰 효율을 낼 수 있는 시점이다.

[ProjectRE] 개발 일지 1

타자치는 문돌이 — Thu, 11 Jun 2026 01:49:30 +0900

프로젝트가 개발 단계의 한 사이클을 돌았다고 할 정도가 진행되었다.
이제 어떤 게임을 만드려고 하는지 보이는 프로토타입 정도가 되었다.
며칠 정도 현재까지 개발한 내용을 검토하며 다져놔야 할 부분을 다질 타이밍인 것 같다.

복기

개발 방식

LLM 도입

초창기에는 GPT를 참고용으로 활용하다가 Enhancement System 개발 즈음부터 본격적으로 Codex와 Gemini cli를 도입했다. 몇 달 사이에 너무 많이 발전했다. 몇 번의 시행착오와 조사 끝에 나만의 작업 흐름을 완성했다.

1. 기획 문서 작성
구현하려는 기능의 기획을 작성한다. 어떤 기능이고, 어떤 식으로 쓰일 지, 규칙 등을 작성하고 GPT로 구체화해서 완성했다. 어떻게 구현할지 코드 관련 내용은 모두 빼고 기획 측면에서 원하는 내용을 적었다.

2. 관련 자료 조사
AI로 게임을 개발하며 있던 가장 큰 문제는(특히 언리얼), 이미 구현되어 있는 기능을 새로 구현하려 한다는 점이었다. 예를 들어 Ability System에는 이미 사용 가능한 Target Data와 활용 함수들이 정의되어 있지만, 이걸 활용하는 대신 새로운 Target Data를 정의하고 사용하려 한다. 이를 막기 위해 이 단계를 추가했다.
Codex로 1의 기획을 구현하기 위해 알아두어야 할 프로젝트의 내용과 Unreal Engine의 내용, 보편적으로 구현하는 방식을 조사해 작성한다. AbilityBase를 구현하려 하면 현재 Player ASC, Gameplay Ability 등에 대해 조사해 작성한다.

3. 구현 기획 문서 작성
1과 2를 바탕으로 새 기능을 어떻게 구현할 지 작성한다. 클래스가 어떤 함수를 가지고, 어떤 로직으로 작동하며, 어떤 기능을 사용할지를 정리한다.

4. 코드
실제로 구현할 코드나 Blueprint를 작성한다.

각 단계에서 마음에 안들면 직접 수정하거나 전 단계로 돌아가 내가 원하는 대로 기획이 코드로 구체화되도록 방향을 잡았다. 그리고 작성한 문서는 Gemini cli가 검토하고 피드백을 한다.

결과물은 상당히 마음에 들고 원하는 방향으로 구현하지만 생각보다 검토에 시간이 오래 걸린다. 각 단계마다 300~500줄 정도의 문서가 생성되고 검토해야 한다. 쓸데없는 말을 줄이는 방향으로 promts를 설정할 수 있다면 찾아봐야겠다.

주요 구현

Experience System

Lyra와 모듈형 게임플레이

https://dev.epicgames.com/documentation/ko-kr/unreal-engine/game-features-and-modular-gameplay-in-unreal-engineGame Feature와 ExperienceLyra는 여러가지 모드가 존재하고, 이를 Experience라는 단위로 나누어 구분한다.이때, 필요없

code-in-coffee.tistory.com

Lyra의 Experience System을 구현해 초기화 로직을 관리한다. 아직 간단한 역할만 하며 현재 주요 역할은 Player의 Pawn, Abilityset, InputConfig 등을 연결하고 초기화 타이밍을 관리하며 Experience를 로드하는 GameMode 역할이다. Main Menu -> Room -> Gameplay 부분과 Async Load가 완성되면 더 강조될 것 같다.

GAS 기반 전투 시스템

Attributeset을 기반으로 하는 능력치 시스템과, Gamplay Ability를 바탕으로 하는 AbilityBase, Gameplay Tag를 활용한 Input System과 전투 제어 로직을 구현했다. Blueprint에서 쉽게 확장 가능한 구조로 만들어 다양한 스킬을 쉽게 구현할 수 있다.

Enhancement System

로스트아크의 엘릭서 시스템을 가져온 강화 시스템을 구현했다. 강화 미리 보기의 구현이 특히 힘들었다.

Widget Controller 기반 UI

Widget Controller를 기반으로 UI를 관리하는 HUD 시스템을 만들었다. WC에서 쉽게 필요한 값을 전달 받아 Widget이 보여준다. Widget 크기와 위치 관련해서는 공부가 더 필요하다.

BT 기반 Enemy

언리얼 BT와 Blackboard를 활용한 Enemy 로직을 구현했다.

막힌 부분

기획과 에셋

사실 기획한 내용은 지금까지의 구현이 대부분이다. "전투->강화가 반복되는, 엘릭서 방식 강화를 사용하고 다양한 무기를 쓸 수 있는 쿼터뷰 액션 로그라이크". 여기서 더 나아가려면 기획을 확정해야 한다. 메인 컨셉을 어떻게 할지를 정해야 무기와 스킬, 적, 맵 스타일, 스토리 등이 정해진다. 이게 어려운 이유는 에셋이다. 메인 컨셉에 맞춰 에셋을 구하는 것보다 에셋에 맞춰 메인 컨셉이 강제로 정해질 확률이 높다. 3D 에셋을 거의 못 만지는 개발자의 한계다. 에셋을 찾으며 느낀 것은 생각보다 쿼터뷰에 맞는 애니메이션을 찾기 어렵다는 것(Paragon 에셋을 쓰니까 너무 붕쯔붕쯔 느낌이라 다른 애니메이션을 찾아야 했다)과 무료 VFX가 많이 없다는 것이다.
돈을 쓰거나 AI를 써야한다.

Map 구현 방식

현재는 BP_Stage를 소환하는 방식으로 맵을 구현 했다. 그러나 배경을 더 신경 쓴다면 스테이지 여러 개가 채워진 맵을 만드는 것이 나을 것 같다. 아니면 PCG도 고려해 볼 만하다.

Enhancement System

강화 시스템은 선택지에 따라 다양한 효과를 준다.
카드 게임을 어떻게 구현할지 고민하며 생각해 본 것인데, 나라면 하스스톤 카드의 효과를 어떻게 구현할까?
비슷한 기능으로 묶어서 대상-비용-규칙-효과 데이터를 저장하고 이걸 해석해서 발동하는 것이 정석적이고, Enhancement System도 이렇게 구현했지만, 사실 규칙이 복잡해지고 양이 많아지면 오히려 이걸 각각 구현하는 것이 더 낫지 않을까라는 생각도 한다. 특히 새 효과를 위해 규칙 전체나 효과 전체에 수정을 해야 하는데 이 수정이 다른 모든 카드에 영향이 없을지를 확신할 수 있을까? 하스스톤이라면 가능할 것 같다고 생각이 든다면 유희왕은 어떨까? 그 말도 안 되는 카드 효과를 컨텍스트 해석으로 풀어낼 수 있는 것일까?

Loading Screen

맵과 맵의 전환에서 동작하는 시스템이라 아직 버그가 많다. 맵 전환하면 아주 짧게 로딩 안된 상태의 맵이 보일 때가 있다.

IGameMoviePlayer | Unreal Engine 5.7 Documentation | Epic Developer Community

An interface to the movie player we will use for loading screens and gameplay movies

dev.epicgames.com

이걸 써보는 것도 계획 중이다.

다음 개발 동안 생각해 볼 것

개발 방식

개발 방식과 관련해 몇 가지 변화를 주려고 한다.

LLM Wiki 도입

앤드류 카파시가 제안한 패턴으로, llm과의 대화를 일회성으로 끝내는 대신 llm wiki에 기록해 지식을 축적하고, 대화를 할 때 필요한 정보를 wiki에서 검색하는 방식이다.

llm-wiki

llm-wiki. GitHub Gist: instantly share code, notes, and snippets.

gist.github.com

현재도 비슷한 방식을 쓰고는 있다. 기능을 구현한 다음, 방금 개발한 기능을 요약하라고 한 뒤, IMPLEMENTATION_STATE.md에 기록하고 있다. 개발에서 맥락이 필요하면 이 문서를 참고해 정보를 긁어오지만, 이 문서는 벌써 1000줄을 넘어가 검색할 때 비효율적인 문서가 되었다. IMPLEMENTATION_STATE.md를 대체하는 기능으로 프로젝트에 한정한 llm wiki를 구성할 계획이다.

은근히 거슬리는 폴더 구조

Codex는 .gitignore를 반영하고, 이걸 수정할 방법이 아직 없는 것 같다. Gemini는 .gitignore 무시하기 옵션이 있지만 Codex는 찾을 수 없다. llm 관련 파일이 많이 존재하는데 .gitignore에 등록하면 무시되고, 안 하면 계속 unstaged change에 보인다. 생각해 낸 꼼수는 프로젝트 폴더를 감싸는 것이다.

기존에는 프로젝트 root에 .gemini, .agent폴더를 두고 여기서 Codex나 Gemini를 사용했다.

// 기존 구조
ProjectRE/  
├─ Source/  
├─ Content/
├─ ...
├─ .gemini/
├─ .agents/
│  ├─ commands/  
│  ├─ ...
│  └─ docs/
├─ .gitignore
├─ ...
└─ ProjectName.uproject
...

새로 구상 중인 방법은 프로젝트 폴더 밖에 llm 관련 파일을 놓고 실행하는 방식이다. 이러면 거슬리는 llm 파일을 git의 범위에서 뺄 수 있다.

ProjectRE/
├─ ProjectRE/  
│  ├─ Source/  
│  ├─ Content/
│  ├─ .gitignore
│  ├─ ...
│  └─ ProjectName.uproject
├─ .gemini/
├─ .agents/
├─ feature/
└─ wiki/

객체 지향

객체 지향적인 코드를 짜기 위해 노력했지만 ai를 활용한 개발을 하며 새로운 관점으로 생각해 보기 시작했다.

게임의 객체들이 단독으로 존재하고, 다른 요소를 모르거나 없어도 작동해야 한다.

객체의 내부를 모르는 상태에서도 로직이 돌아가면 ai도 상대 객체를 파악하지 않아도 된다. 아직 ai는 다른 요소를 파악하고 그것까지 감안해 줄 정도로 똑똑하지는 않다. 상대 객체 파악은 많은 토큰을 쓰기도 한다. 차라리 단독으로도 잘 작동하고 상호작용 가능한 객체를 만드는 것이 낫다고 생각한다. Component도 더 적극적으로 활용해야겠다. 역할과 기능이 얽힐수록 ai가 멍청한 대답을 준다.

도입해 볼 만한 기술

PCG, Level Streaming

맵을 PCG로 생성하는 것도 후보에 있다. 아니면 방마다 Level Streaming으로 로드/언로드 할 수도 있다. 맵은 어떻게 구현할지 더 고민해봐야 한다.

Motion Matching

이동 애니메이션을 아직은 크게 신경 안 쓰고 있지만 자연스러운 애니메이션 전환이 가능하다면 도입해보려고 한다. 다만 대부분 예제가 3인칭 백뷰 기준이라 그대로 적용하면 회전이 이상하게 동작한다. 이 문제를 고쳐야 한다.

Async Load

Gameplay Camera

자세히 조사는 안 한 기능이다. GAS와 조합이 좋아서 컷신 연출 등이 간편하면 사용해 볼 계획이다.

흠...

한 일주일 정도 쉬면서 프로젝트의 클래스 다이어그램을 그려봐야겠다. 프로토타입 정도까지 되니까 어떤 요소로 내가 원하는 것을 표현하면 될지 큰 그림이 잡혔다.

"대화를 바탕으로 이 게임이 완성됐을 때의 모습을 그려줘."

그림은 참 잘 그린단 말이지...

[TinyRenderer] Lesson 1. Bresenham 직선 알고리즘

타자치는 문돌이 — Sun, 7 Jun 2026 19:58:49 +0900

Lesson 1: Bresenham’s line drawing algorithm · TaeAhnK/TinyRenderer@c308465

+ void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)

github.com

점을 그렸으니, 이제 선을 그려야 한다.
두 점을 잇는 선을 어떻게 그릴까?
픽셀 위에서는 결국 점을 찍어야 한다.

가장 간단한 방법은 보간을 사용하는 방식으로, 두 점 사이를 나타내는 식을 구하고, 시작점을 0, 끝점을 1로 둔 뒤, 0에서 1까지의 값을 함수에 넣으며 선 위의 좌표를 계산해 점을 찍는 것이다.

두 점 $(x_0, y_0)$, $(x_1, y_1)$, 보간 매개변수 $t (0 \le t \le1)$에 대해
$$
\begin{aligned}
x &= x_0 + (x_1 - x_0) \times t \\
y &= y_0 + (y_1 - y_0) \times t
\end{aligned}
$$
은 두 점을 잇는 선 위에 있다.

이걸 코드로 구현하면, 다음과 같다.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    for (float t = 0.; t < 1.; t += 0.02)
    {
        int x = x0 + ((x1 - x0) * t);
        int y = y0 + ((y1 - y0) * t);

        framebuffer.set(x, y, color);
    }
}

이걸 이용해 선을 그려보자.

int main()
{
    constexpr int width = 64;
    constexpr int height = 64;

    TGAImage framebuffer(width, height, TGAImage::RGB);

    line(7, 3, 12, 37, framebuffer, white);
    line(12, 37, 62, 53, framebuffer, red);
    line(62, 53, 7, 3, framebuffer, blue);
    line(62, 53, 12, 37, framebuffer, green);

    framebuffer.write_tga_file("output/framebuffer.tga");

    return 0;
}

이 방식은 몇 가지 문제가 있다.

초록과 빨강은 같은 선을 그려야 하지만, 실제로는 다른 값이 칠해져 빨강이 보인다.
파랑 중간중간에 빈 공간이 있다. (7,3)과 (62, 53)을 잇기 위해선 최소한 62-7=55 픽셀이 필요하지만, t가 0.02씩 증가해 51개의 픽셀만 칠했다.

따라서 더 나은 방법이 필요하다.

t를 0.02같은 고정된 숫자만큼 늘리는 방식 대신 x를 1씩 증가시키고, 선에서의 진행도 t를 구해 y를 계산할 수 있다.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)  
{  
    for (int x = x0; x <= x1; x++)  
    {  
        float t = static_cast<float>(x - x0) / static_cast<float>(x1 - x0);
        int y = static_cast<int>(y0 * (1.0f - t) + y1 * t);  

        framebuffer.set(x, y, color);  
    }  
}

몇 가지 문제가 생겼다. 파랑은 사라지고, 흰색은 간격이 매우 넓어졌다.

파랑은 (62, 53) -> (7, 3)으로 x가 줄어들어 for문이 작동하지 않았다.
흰색은 x만을 기준으로 해 간격이 매우 넓다.

즉, sample이 이번에도 적절하지 않았다.
우선 파랑 문제를 해결해 보자.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    for (int x = x0; x <= x1; x++)
    {
        float t = static_cast<float>(x - x0) / static_cast<float>(x1 - x0);
        int y = static_cast<int>(y0 * (1.0f - t) + y1 * t);

        framebuffer.set(x, y, color);
    }
}

선이 가파를 때 흰색과 같은 문제가 생긴다.
그러면 가파를 때 x 대신 y를 쓰면 어떨까?
x 차이보다 y 차이가 더 크면 y를 기준으로 선을 그려보자.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    bool steep = std::abs(x0 - x1) < std::abs(y0 - y1);
    if (steep) { // if the line is steep, we transpose the image
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    for (int x = x0; x <= x1; x++)
    {
        float t = static_cast<float>(x - x0) / static_cast<float>(x1 - x0);
        int y = static_cast<int>(y0 * (1.0f - t) + y1 * t);

        if (steep)
            framebuffer.set(y, x, color);
        else
            framebuffer.set(x, y, color);
    }
}

이제 원하는 대로 선을 그리지만, 아직 비효율적인 부분이 많다.
이를 최적화한 최종 버전을 만들어보자.

튜토리얼에 따르면 이 부분에는 언급되지 않은 역사적/문화적 배경이 많고, 특히 CPU냐 GPU냐에 따라 다른 결과가 나올 것이라고 한다.

먼저 기존 방식에서 1,600만 회 정도 선을 그려보자.

int main()
{
    constexpr int width = 64;
    constexpr int height = 64;

    TGAImage framebuffer(width, height, TGAImage::RGB);

    auto start = std::chrono::high_resolution_clock::now();

    std::srand(std::time({}));
    for (int i = 0; i < (1 << 24); i++) {
        int ax = rand() % width, ay = rand() % height;
        int bx = rand() % width, by = rand() % height;

        line(ax, ay, bx, by, framebuffer, { static_cast<unsigned char>(rand() % 255), 
            static_cast<unsigned char>(rand() % 255), 
            static_cast<unsigned char>(rand() % 255), 
            static_cast<unsigned char>(rand() % 255) });
    }

    auto end = std::chrono::high_resolution_clock::now();

    double elapsedSec = std::chrono::duration<double>(end - start).count();

    std::cout << "Line rendering time: " << elapsedSec << " s\n";

    framebuffer.write_tga_file("output/framebuffer.tga");

    return 0;
}

Line rendering time: 10.9131 s

현재 방식은 픽셀마다

float t = (x - x0) / (float)(x1 - x0);  
int y = y0 * (1.0f - t) + y1 * t;

를 계산한다.
이때 t에 대해 증가하는 y 비율은 항상 같다.
t와 y를 계산하는 대신, 기울기만큼 y를 누적하는 방식으로 바꾸면 y를 매번 계산할 필요가 없다.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    bool steep = std::abs(x0 - x1) < std::abs(y0 - y1);
    if (steep) { // if the line is steep, we transpose the image
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    float slope = (y1 - y0) / static_cast<float>(x1 - x0);
    float y = y0;

    for (int x = x0; x <= x1; x++) {
        if (steep) // if transposed, de−transpose
            framebuffer.set(y, x, color);
        else
            framebuffer.set(x, y, color);
        y += slope;
    }
}

Line rendering time: 10.0969 s

여기서 우리는 기울기만큼 y를 올리고 있지만, y는 정수 좌표만 유효하다. 그러면 소수 부분을 누적했다가 정수 부분이 바뀌면 1씩 올리는 방식을 사용해 볼 수 있다.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    bool steep = std::abs(x0 - x1) < std::abs(y0 - y1);
    if (steep) { // if the line is steep, we transpose the image
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    float slope = abs(y1 - y0) / static_cast<float>(x1 - x0);
    int y = y0;
    float error = 0;

    for (int x = x0; x <= x1; x++) {
        if (steep) // if transposed, de−transpose
            framebuffer.set(y, x, color);
        else
            framebuffer.set(x, y, color);
        error += slope;
        if (error > 0.5) 
        {
            y += y1 > y0 ? 1 : -1;
            error -= 1.;
        }
    }
}

Line rendering time: 11.8649 s

연산이 늘어 시간이 늘어났다.

여기서 소수점 연산을 없앨 수 있을까?
오차를 적절히 scale해 int로 만들어보자.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    bool steep = std::abs(x0 - x1) < std::abs(y0 - y1);
    if (steep) { // if the line is steep, we transpose the image
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    int dx = x1 - x0;
    int dy = y1 - y0;
    int absdy2 = 2 * std::abs(dy);
    int dx2 = 2 * dx;
    int ystep = dy > 0 ? 1 : -1;

    int y = y0;
    int ierror = 0;

    for (int x = x0; x <= x1; x++) {
        if (steep)
            framebuffer.set(y, x, color);
        else
            framebuffer.set(x, y, color);

        ierror += absdy2;

        if (ierror > dx) {
            y += ystep;
            ierror -= dx2;
        }
    }
}

매번 x1 - x0으로 나누는 대신, 오차를 2*(x1 - x0)배 scale해 정수로 관리한다.

Line rendering time: 11.8008 s

float 연산이 있는 버전보다 빨라지긴 했지만, 오히려 처음 방식보다 느리다.
CPU 관점에서 CPU는 명령어 가져오기, 해석하기, 계산, 메모리 읽기/쓰기 등의 작업을 나눠서 처리한다. 이걸 순차적으로 처리하면 느리므로 여러 명령어를 겹쳐서 처리하는 Pipelining을 사용한다.

명령어 A: 실행 중  
명령어 B: 해석 중  
명령어 C: 가져오는 중

그런데 if와 같은 분기문은 흐름을 끊을 수 있다.

if (condition) 
{  
    A();  
} 
else 
{  
    B();  
}

CPU 입장에서는 다음에 실행해야 할 코드가 A인지 B인지 모른다. 따라서 condition 계산 전에 미리 사용할 명령어를 예측한다. 이때 예측이 틀리면 성능 문제가 생긴다.

따라서 여기서 병목이 생긴다.

    if (ierror > dx) {
        y += ystep;
        ierror -= dx2;
    }

이를 해소하기 위해 branchless form으로 다음과 같이 수정할 수 있다.

void line(int x0, int y0, int x1, int y1, TGAImage& framebuffer, TGAColor color)
{
    bool steep = std::abs(x0 - x1) < std::abs(y0 - y1);
    if (steep) { // if the line is steep, we transpose the image
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    if (x0 > x1) { // make it left−to−right
        std::swap(x0, x1);
        std::swap(y0, y1);
    }

    int dx = x1 - x0;
    int dy = y1 - y0;
    int absdy2 = 2 * std::abs(dy);
    int dx2 = 2 * dx;
    int ystep = dy > 0 ? 1 : -1;

    int y = y0;
    int ierror = 0;

    for (int x = x0; x <= x1; x++) {
        if (steep)
            framebuffer.set(y, x, color);
        else
            framebuffer.set(x, y, color);

        ierror += absdy2;

        int over = ierror > dx;
        y += ystep * over;
        ierror -= dx2 * over;
    }
}

Line rendering time: 11.4141 s

이제 선을 이용한 Wireframe Rendering이 가능하다.
Obj 파일은 v (x) (y) (z), vt (u) (v), vn (x) (y) (z), f (a/b/c) (ta/tb/tc) (na/nb/nc)가 나열되어 있다.

v (x) (y) (z)는 점의 3D 위치이다. 아직 TinyRender는 x와 y만 사용할 수 있다.
vt (u) (v)는 텍스처의 위치이다. 이번에는 무시할 것이다.
vn (x) (y) (z)는 Normal Vector로 표면이 향하는 방향을 의미한다. 빛 계산에 필요하고, 이번에는 무시한다.
f (a/ta/na) (b/tb/nb) (c/tc/nc)는 연결되어 Face를 만드는 세 좌표를 의미한다. a, b, c,는 좌표를 저장한 v 인덱스, ta, tb, tc는 vt에서의 인덱스, na, nb, nc는 vn에서의 인덱스이다.

이번 목표는 z를 무시한 v를, f를 기준으로 연결해 렌더링 된 이미지를 생성하는 것이다.

먼저 v를 저장하려면 Vector3가 필요하나 Vector3가 없어 직접 구현한다.

typedef struct vec3
{
    double x;
    double y;
    double z;
} vec3;

obj 파일을 담기 위한 클래스 Model을 만들자.

model.h

#pragma once

#include <vector>
#include "geometry.h"
#include <string>

class Model
{
    std::vector<vec3> verts = {};
    std::vector<int> facet_vrt = {};

public:
    Model(const std::string filename);
    int nverts() const;
    int nfaces() const;
    vec3 vert(const int i) const;
    vec3 vert(const int iface, const int nthvert) const;
};

model.cpp

#include <fstream>
#include <sstream>
#include <iostream>
#include "model.h"

Model::Model(const std::string filename)
{
    std::ifstream in;

    in.open(filename, std::ifstream::in);

    if (in.fail())
    {
        std::cerr << "Failed to open OBJ file: " << filename << '\n';
        return;
    }

    std::string line;

    while (std::getline(in, line))
    {
        std::istringstream iss(line);

        if (line.rfind("v", 0) == 0)
        {
            char prefix;
            vec3 vertex;

            iss >> prefix >> vertex.x >> vertex.y >> vertex.z;

            verts.push_back(vertex);
        }
        else if (line.rfind("f", 0) == 0)
        {
            char prefix;
            char slash;
            int a, b, c;
            int ta, tb, tc;
            int na, nb, nc;

            iss >> prefix;

            iss >> a >> slash >> ta >> slash >> na;
            facet_vrt.push_back(a - 1);

            iss >> b >> slash >> tb >> slash >> nb;
            facet_vrt.push_back(b - 1);

            iss >> c >> slash >> tc >> slash >> nc;
            facet_vrt.push_back(c - 1);
        }
    }

}

int Model::nverts() const
{
    return verts.size();
}

int Model::nfaces() const
{
    return facet_vrt.size()/3;
}

vec3 Model::vert(const int i) const
{
    return verts[i];
}

vec3 Model::vert(const int iface, const int nthvert) const
{
    return verts[facet_vrt[iface * 3 + nthvert]];
}

obj 파일을 읽을 때는 a/b/c의 값이 반드시 존재하고, 한 줄에 3번 나타나는 파일임을 가정했다.

이 데이터를 바탕으로 main에서 obj를 렌더링해 보자.

int main()
{
    constexpr int width = 800;
    constexpr int height = 800;

    TGAImage framebuffer(width, height, TGAImage::RGB);

    Model model("obj/diablo3_pose.obj");

    for (int i = 0; i < model.nfaces(); i++)
    {
        vec3 a = model.vert(i, 0);
        int ax = static_cast<int>((a.x + 1.f) * width / 2.f);
        int ay = static_cast<int>((a.y + 1.f) * height / 2.f);

        vec3 b = model.vert(i, 1);
        int bx = static_cast<int>((b.x + 1.f) * width / 2.f);
        int by = static_cast<int>((b.y + 1.f) * height / 2.f);

        vec3 c = model.vert(i, 2);
        int cx = static_cast<int>((c.x + 1.f) * width / 2.f);
        int cy = static_cast<int>((c.y + 1.f) * height / 2.f);

        line(ax, ay, bx, by, framebuffer, red);
        line(bx, by, cx, cy, framebuffer, red);
        line(cx, cy, ax, ay, framebuffer, red);
    }


    framebuffer.write_tga_file("output/framebuffer.tga");

    return 0;
}

[TinyRenderer] Lesson 0. 시작하기

타자치는 문돌이 — Thu, 4 Jun 2026 00:10:59 +0900

Lesson 0: getting started · TaeAhnK/TinyRenderer@206b974

Create a tga file and draw points

github.com

이 프로젝트는 ssloy/tinyrenderer를 보고 진행한 실습으로, OpenGL, DirectX, Vulkan과 같은 현대 3D 그래픽 API가 작동하는 원리를 재현한 렌더러 프로그램이다.
그래픽 API는 사용하지 않았고, 그래픽 API가 동작하는 원리를 학습하기 위해 진행하였다.

Visual Studio 2022에서 빈 프로젝트를 만들고, main.cpp 를 추가한다.

int main()
{
    return 0;
}

우리의 첫 목표는 이미지 파일 한 장을 직접 생성하고, 픽셀에 점을 찍어보는 것이다.
TinyRenderer는 .tga라는 형식의 이미지 파일로 이미지를 저장한다.

먼저 tga 이미지를 정의하는 클래스가 필요하다. tinyrenderer의 tgaimage.h를 사용했다.

tgaimage.h

#pragma once
#include <cstdint>
#include <fstream>
#include <vector>

#pragma pack(push,1)
struct TGAHeader {
    std::uint8_t  idlength = 0;
    std::uint8_t  colormaptype = 0;
    std::uint8_t  datatypecode = 0;
    std::uint16_t colormaporigin = 0;
    std::uint16_t colormaplength = 0;
    std::uint8_t  colormapdepth = 0;
    std::uint16_t x_origin = 0;
    std::uint16_t y_origin = 0;
    std::uint16_t width = 0;
    std::uint16_t height = 0;
    std::uint8_t  bitsperpixel = 0;
    std::uint8_t  imagedescriptor = 0;
};
#pragma pack(pop)

struct TGAColor {
    std::uint8_t bgra[4] = {0,0,0,0};
    std::uint8_t bytespp = 4;
    std::uint8_t& operator[](const int i) { return bgra[i]; }
};

struct TGAImage {
    enum Format { GRAYSCALE=1, RGB=3, RGBA=4 };
    TGAImage() = default;
    TGAImage(const int w, const int h, const int bpp);
    bool  read_tga_file(const std::string filename);
    bool write_tga_file(const std::string filename, const bool vflip=true, const bool rle=true) const;
    void flip_horizontally();
    void flip_vertically();
    TGAColor get(const int x, const int y) const;
    void set(const int x, const int y, const TGAColor &c);
    int width()  const;
    int height() const;
private:
    bool   load_rle_data(std::ifstream &in);
    bool unload_rle_data(std::ofstream &out) const;
    int w = 0, h = 0;
    std::uint8_t bpp = 0;
    std::vector<std::uint8_t> data = {};
};

tgaimage.cpp

#include <iostream>
#include <cstring>
#include "tgaimage.h"

TGAImage::TGAImage(const int w, const int h, const int bpp) : w(w), h(h), bpp(bpp), data(w*h*bpp, 0) {}

bool TGAImage::read_tga_file(const std::string filename) {
    std::ifstream in;
    in.open(filename, std::ios::binary);
    if (!in.is_open()) {
        std::cerr << "can't open file " << filename << "\n";
        return false;
    }
    TGAHeader header;
    in.read(reinterpret_cast<char *>(&header), sizeof(header));
    if (!in.good()) {
        std::cerr << "an error occured while reading the header\n";
        return false;
    }
    w   = header.width;
    h   = header.height;
    bpp = header.bitsperpixel>>3;
    if (w<=0 || h<=0 || (bpp!=GRAYSCALE && bpp!=RGB && bpp!=RGBA)) {
        std::cerr << "bad bpp (or width/height) value\n";
        return false;
    }
    size_t nbytes = bpp*w*h;
    data = std::vector<std::uint8_t>(nbytes, 0);
    if (3==header.datatypecode || 2==header.datatypecode) {
        in.read(reinterpret_cast<char *>(data.data()), nbytes);
        if (!in.good()) {
            std::cerr << "an error occured while reading the data\n";
            return false;
        }
    } else if (10==header.datatypecode||11==header.datatypecode) {
        if (!load_rle_data(in)) {
            std::cerr << "an error occured while reading the data\n";
            return false;
        }
    } else {
        std::cerr << "unknown file format " << (int)header.datatypecode << "\n";
        return false;
    }
    if (!(header.imagedescriptor & 0x20))
        flip_vertically();
    if (header.imagedescriptor & 0x10)
        flip_horizontally();
    std::cerr << w << "x" << h << "/" << bpp*8 << "\n";
    return true;
}

bool TGAImage::load_rle_data(std::ifstream &in) {
    size_t pixelcount = w*h;
    size_t currentpixel = 0;
    size_t currentbyte  = 0;
    TGAColor colorbuffer;
    do {
        std::uint8_t chunkheader = 0;
        chunkheader = in.get();
        if (!in.good()) {
            std::cerr << "an error occured while reading the data\n";
            return false;
        }
        if (chunkheader<128) {
            chunkheader++;
            for (int i=0; i<chunkheader; i++) {
                in.read(reinterpret_cast<char *>(colorbuffer.bgra), bpp);
                if (!in.good()) {
                    std::cerr << "an error occured while reading the header\n";
                    return false;
                }
                for (int t=0; t<bpp; t++)
                    data[currentbyte++] = colorbuffer.bgra[t];
                currentpixel++;
                if (currentpixel>pixelcount) {
                    std::cerr << "Too many pixels read\n";
                    return false;
                }
            }
        } else {
            chunkheader -= 127;
            in.read(reinterpret_cast<char *>(colorbuffer.bgra), bpp);
            if (!in.good()) {
                std::cerr << "an error occured while reading the header\n";
                return false;
            }
            for (int i=0; i<chunkheader; i++) {
                for (int t=0; t<bpp; t++)
                    data[currentbyte++] = colorbuffer.bgra[t];
                currentpixel++;
                if (currentpixel>pixelcount) {
                    std::cerr << "Too many pixels read\n";
                    return false;
                }
            }
        }
    } while (currentpixel < pixelcount);
    return true;
}

bool TGAImage::write_tga_file(const std::string filename, const bool vflip, const bool rle) const {
    constexpr std::uint8_t developer_area_ref[4] = {0, 0, 0, 0};
    constexpr std::uint8_t extension_area_ref[4] = {0, 0, 0, 0};
    constexpr std::uint8_t footer[18] = {'T','R','U','E','V','I','S','I','O','N','-','X','F','I','L','E','.','\0'};
    std::ofstream out;
    out.open(filename, std::ios::binary);
    if (!out.is_open()) {
        std::cerr << "can't open file " << filename << "\n";
        return false;
    }
    TGAHeader header = {};
    header.bitsperpixel = bpp<<3;
    header.width  = w;
    header.height = h;
    header.datatypecode = (bpp==GRAYSCALE ? (rle?11:3) : (rle?10:2));
    header.imagedescriptor = vflip ? 0x00 : 0x20; // top-left or bottom-left origin
    out.write(reinterpret_cast<const char *>(&header), sizeof(header));
    if (!out.good()) goto err;
    if (!rle) {
        out.write(reinterpret_cast<const char *>(data.data()), w*h*bpp);
        if (!out.good()) goto err;
    } else if (!unload_rle_data(out)) goto err;
    out.write(reinterpret_cast<const char *>(developer_area_ref), sizeof(developer_area_ref));
    if (!out.good()) goto err;
    out.write(reinterpret_cast<const char *>(extension_area_ref), sizeof(extension_area_ref));
    if (!out.good()) goto err;
    out.write(reinterpret_cast<const char *>(footer), sizeof(footer));
    if (!out.good()) goto err;
    return true;
err:
    std::cerr << "can't dump the tga file\n";
    return false;
}

bool TGAImage::unload_rle_data(std::ofstream &out) const {
    const std::uint8_t max_chunk_length = 128;
    size_t npixels = w*h;
    size_t curpix = 0;
    while (curpix<npixels) {
        size_t chunkstart = curpix*bpp;
        size_t curbyte = curpix*bpp;
        std::uint8_t run_length = 1;
        bool raw = true;
        while (curpix+run_length<npixels && run_length<max_chunk_length) {
            bool succ_eq = true;
            for (int t=0; succ_eq && t<bpp; t++)
                succ_eq = (data[curbyte+t]==data[curbyte+t+bpp]);
            curbyte += bpp;
            if (1==run_length)
                raw = !succ_eq;
            if (raw && succ_eq) {
                run_length--;
                break;
            }
            if (!raw && !succ_eq)
                break;
            run_length++;
        }
        curpix += run_length;
        out.put(raw ? run_length-1 : run_length+127);
        if (!out.good()) return false;
        out.write(reinterpret_cast<const char *>(data.data()+chunkstart), (raw?run_length*bpp:bpp));
        if (!out.good()) return false;
    }
    return true;
}

TGAColor TGAImage::get(const int x, const int y) const {
    if (!data.size() || x<0 || y<0 || x>=w || y>=h) return {};
    TGAColor ret = {0, 0, 0, 0, bpp};
    const std::uint8_t *p = data.data()+(x+y*w)*bpp;
    for (int i=bpp; i--; ret.bgra[i] = p[i]);
    return ret;
}

void TGAImage::set(int x, int y, const TGAColor &c) {
    if (!data.size() || x<0 || y<0 || x>=w || y>=h) return;
    memcpy(data.data()+(x+y*w)*bpp, c.bgra, bpp);
}

void TGAImage::flip_horizontally() {
    for (int i=0; i<w/2; i++)
        for (int j=0; j<h; j++)
            for (int b=0; b<bpp; b++)
                std::swap(data[(i+j*w)*bpp+b], data[(w-1-i+j*w)*bpp+b]);
}

void TGAImage::flip_vertically() {
    for (int i=0; i<w; i++)
        for (int j=0; j<h/2; j++)
            for (int b=0; b<bpp; b++)
                std::swap(data[(i+j*w)*bpp+b], data[(i+(h-1-j)*w)*bpp+b]);
}

int TGAImage::width() const {
    return w;
}

int TGAImage::height() const {
    return h;
}

TGAImage는 정보를 저장한 uint8_t의 vector 형식으로 이미지 데이터를 저장한다.

TGAImage 파일을 생성해보자.

#include "tgaimage.h"

int main()
{
    constexpr int width = 64;
    constexpr int height = 64;

    TGAImage framebuffer(width, height, TGAImage::RGB);

    framebuffer.write_tga_file("output/framebuffer.tga");

    return 0;
}

TGAImage 변수를 만들고, write_tga_file로 파일로 작성했다.

64*64의 작은 이미지가 생성되었다.

이번에는 TGAImage의 픽셀을 변경해 점을 찍어보자.
색을 미리 선언해 두면 편하다.

constexpr TGAColor white =    { 255, 255, 255, 255 };
constexpr TGAColor red =    {    0,   0, 255, 255 };
constexpr TGAColor blue =    { 255,     0,   0, 255 };
constexpr TGAColor green =    {    0, 255,      0, 255 };

int main()
{
    constexpr int width = 64;
    constexpr int height = 64;

    TGAImage framebuffer(width, height, TGAImage::RGB);

    framebuffer.set(7, 3, white);
    framebuffer.set(12, 37, red);
    framebuffer.set(62, 53, blue);
    framebuffer.set(30, 34, green);

    framebuffer.write_tga_file("output/framebuffer.tga");

    return 0;
}

set을 통해 특정 위치의 픽셀을 변경했다.

Heap, Hashmap, Set

타자치는 문돌이 — Fri, 21 Nov 2025 20:32:17 +0900

Heap

C++에서는 priority_queue를 Heap으로 쓸 수 있다.

struct Node {
    int cost, x, y;
};

struct Cmp {
    bool operator()(const Node& a, const Node& b) const {
        return a.cost > b.cost;   // ex) 비용이 작은 게 top에 오도록
    }
};


int main() {
    // 선언
    priority_queue<int> pq; // 최대 힙

    // 추가
    pq.push(1);
    pq.push(2);
    pq.push(3);

    // 가장 큰 값
    pq.top();

    // 삭제
    pq.pop();

    // 작은 게 위로
    priority_queue<int, vector<int>, greater<int>> pq;

    // 내가 원하는 기준으로
    priority_queue<Node, vector<Node>, Cmp> pq;
}

삽입과 삭제에 O(log N), 최대/최소값 조회는 O(1)이 걸린다.
가장 큰 원소 K개를 구하려면, 최소 힙 (greater<int>)를 만든 뒤, 크기가 K가 넘어가면 pop을 해준다.
priority_queue는 queue처럼 직접 모든 원소를 빼는 것이 아니면 순회가 안된다.

Hashmap

C++에서는 unordered_map으로 만들 수 있다.


int main()
{
    // 선언
    unordered_map<string, int> mp; // <key, value>

    // 추가
    mp["apple"] = 3;
    mp["banana"] = 5;

    // 값 증가
    mp["apple"]++;

    // 키 확인
    if (mp.count("apple"))
    {

    }

    // 조회
    auto it = mp.find("banana");
    if (it != mp.end()) {
        cout << it->second;
    }

    // 삭제
    mp.erase("apple");

    // 순회
    for (auto &p : mp) 
    {
        cout << p.first << " : " << p.second << "\n";
    }
}

순회는 정렬된 순서가 아니다.
없는 원소에 대해 mp["hello"]를 조회하면 자동으로 추가되니 주의하자.

Set

unordered_set으로 중복 없는 원소와 빠른 접근(O(1))이 가능하다.

int main()
{
    // 선언
    unordered_set<int> s;

    // 삽입
    s.insert(10);

    // 확인
    if (s.count(10))
    {

    }

    // 삭제
    s.erase(10);

    // 순회
    for (auto x : s) 
    {
        cout << x << " ";
    }
}

마찬가지로 순회는 랜덤이다.

순열과 조합, 비트마스크

타자치는 문돌이 — Fri, 21 Nov 2025 20:07:35 +0900

순열

permutation 함수를 통해 벡터를 순열 순으로 정렬할 수 있다.
이때, a는 정렬되어 있어야 한다.

using namespace std;

int main() {
    vector<int> a = {1, 2, 3};
    sort(a.begin(), a.end());

    do {
        // 이제 a는 while을 돌면서
        // {1, 2, 3}, {1, 3, 2}...로 정렬됨
        for (int x : a) cout << x << " ";
        cout << "\n";
    } while (next_permutation(a.begin(), a.end()));
}

조합

5개 중 3개를 선택한다고 하자.
선택한 원소를 1, 아닌 원소를 0으로 00111과 같이 표현할 수 있다.
00111에 대해 permutation을 통해 순열을 구하면 포함 정보를 구할 수 있다.
(00111, 01011, 01101, 01110...)

using namespace std;

int main()
{
    vector<int> idx(n, 0);
    fill(idx.end()-k, idx.end(), 1); // 1이 선택

    do {
        if (idx[i] == 1) // i가 선택된 원소
        {
            ...
        }
    } while (next_permutation(idx.begin(), idx.end()));
}

비트마스크

3자리 vector에 대해, 3자리 이진수를 생각해보면
000, 001, 010, 100, 101, 110, 111으로 0을 넣음, 1을 안넣음으로 생각할 수 있다.
원소의 포함/미포함 조합에 대해 특정 로직을 적용하거나, 팀을 나누는 등의 경우에 사용할 수 있다.
이 이진수는 Bitmask를 통해 구한다.

using namespace std;

int main()
{
    vector<int> a = {1, 2, 3};

    for (int mask = 0; mask < (1 << a.size()); i++) // 0(000), 1(001), 2(010)...
    {
        for (int i = 0; i < a.size(); i++)
        {
            if (mask & (1 << i)) // i가 1이면
            {
                a[i] // 포함된 a의 원소
                ...
            }
        }
    }
}

Lyra와 모듈형 게임플레이

타자치는 문돌이 — Mon, 3 Nov 2025 17:58:40 +0900

https://dev.epicgames.com/documentation/ko-kr/unreal-engine/game-features-and-modular-gameplay-in-unreal-engine

Game Feature와 Experience

Lyra는 여러가지 모드가 존재하고, 이를 Experience라는 단위로 나누어 구분한다.

이때, 필요없는 종속성과 인터랙션을 방지하기 위해 Game Feature로 여러 기능을 Plugin화 한 뒤, Experience를 로드할 때 필요한 Game Feature만 동적으로 추가하는 방식으로 작동한다.

Experience는 ULyraExperienceDefinition라는 데이터 에셋으로 저장되어 이 Experience를 로드할 때 수행해야할 Action, 사용할 DefaultPawn 등으로 구성되어 있다.

여기서 수행하는 액션으로는 Ability 부착, InputBinding 추가, Widget 추가, 컴포넌트 추가 등이 있다.

즉, 게임 플레이 맵으로 이동할 때, 기존의 Gameplay Actor에 여러 컴포넌트를 붙여 무기 기능, 인벤토리 기능 등을 활성화 하는 것이다. 이를 위해 로딩 개념을 추가했다.

void ALyraGameMode::OnMatchAssignmentGiven(FPrimaryAssetId ExperienceId, const FString& ExperienceIdSource)  
{  
    if (ExperienceId.IsValid())  
    {  
       UE_LOG(LogLyraExperience, Log, TEXT("Identified experience %s (Source: %s)"), *ExperienceId.ToString(), *ExperienceIdSource);  

       ULyraExperienceManagerComponent* ExperienceComponent = GameState->FindComponentByClass<ULyraExperienceManagerComponent>();  
       check(ExperienceComponent);  
       ExperienceComponent->SetCurrentExperience(ExperienceId);  
    }  
    else  
    {  
       UE_LOG(LogLyraExperience, Error, TEXT("Failed to identify experience, loading screen will stay up forever"));  
    }  
}

GameMode에서 매칭을 시작하기 전에 ExperienceId를 받아 GameState에 부착된 ULyraExperienceManagerComponent를 통해 Experience를 Set한다. 이 과정에서 StartExperienceLoad가 호출되어 필요한 에셋을 비동기로 로드한다. 그 후, OnExperienceLoadComplete에서 Game Feature를 로드한 뒤, OnExperienceFullLoadCompleted에서 GameFeature Action을 실행한다.

Experience의 로드가 완료되면 OnExperienceLoaded를 구독한 요소들에게 알림을 보낸다. 주요 구독자로는 ALyraGameMode와 ALyraPlayerState가 있다.

Modular Gameplay Actor와 Component

많은 로직이 동적으로 Component로 붙기 때문에 Component 초기화 로직이 중요해진다. 이를 ModularGameplayActor를 통해 해결한다.

Lyra의 Gameplay Actor(PlayerController, PlayerState...)는 ModularGameplayActor와 CommonGame을 상속 받는다. ModularGameplayActor는 GameFeature를, CommonGame은 온라인 서브시스템을 위한 플러그인의 일부이다.

void AModularPlayerState::PreInitializeComponents()  
{  
    Super::PreInitializeComponents();  

    UGameFrameworkComponentManager::AddGameFrameworkComponentReceiver(this);  
}  

void AModularPlayerState::BeginPlay()  
{  
    UGameFrameworkComponentManager::SendGameFrameworkComponentExtensionEvent(this, UGameFrameworkComponentManager::NAME_GameActorReady);  

    Super::BeginPlay();  
}  

void AModularPlayerState::EndPlay(const EEndPlayReason::Type EndPlayReason)  
{  
    UGameFrameworkComponentManager::RemoveGameFrameworkComponentReceiver(this);  

    Super::EndPlay(EndPlayReason);  
}  

void AModularPlayerState::Reset()  
{  
    Super::Reset();  

    TArray<UPlayerStateComponent*> ModularComponents;  
    GetComponents(ModularComponents);  
    for (UPlayerStateComponent* Component : ModularComponents)  
    {  
       Component->Reset();  
    }  
}  

void AModularPlayerState::CopyProperties(APlayerState* PlayerState)  
{  
    Super::CopyProperties(PlayerState);  

    TInlineComponentArray<UPlayerStateComponent*> PlayerStateComponents;  
    GetComponents(PlayerStateComponents);  
    for (UPlayerStateComponent* SourcePSComp : PlayerStateComponents)  
    {  
       if (UPlayerStateComponent* TargetComp = Cast<UPlayerStateComponent>(static_cast<UObject*>(FindObjectWithOuter(PlayerState, SourcePSComp->GetClass(), SourcePSComp->GetFName()))))  
       {  
          SourcePSComp->CopyProperties(TargetComp);  
       }  
    }  
}

void AModularCharacter::PreInitializeComponents()  
{  
    Super::PreInitializeComponents();  

    UGameFrameworkComponentManager::AddGameFrameworkComponentReceiver(this);  
}  

void AModularCharacter::BeginPlay()  
{  
    UGameFrameworkComponentManager::SendGameFrameworkComponentExtensionEvent(this, UGameFrameworkComponentManager::NAME_GameActorReady);  

    Super::BeginPlay();  
}  

void AModularCharacter::EndPlay(const EEndPlayReason::Type EndPlayReason)  
{  
    UGameFrameworkComponentManager::RemoveGameFrameworkComponentReceiver(this);  

    Super::EndPlay(EndPlayReason);  
}

Modular GameplayActor들의 역할은 단순히 UGameFrameworkComponentManager에 자신을 등록하고, 적절한 타이밍에 GameActorReady를 보내는 것이다. GameActorReady를 보내면 UGameFrameworkComponentManager는 알림을 구독한 Component에 State가 변경되었다는 알림을 보낸다. 구독자는 IGameFrameworkInitStateInterface라는 Interface를 가지고 있고, 알림이 오면 자신의 CanChangeInitState를 확인해 자신의 상태를 변환한다. 그 후, 변환된 상태에 맞게 HandleChangeInitState를 실행해 특정 행동을 한다.

Lyra의 스킬 발동

타자치는 문돌이 — Thu, 30 Oct 2025 18:20:29 +0900

Lyra는 GameplayAbilitySystem를 기반으로 스킬을 처리한다.
Move, Look, Crouch, AutoRun은 별도의 C++ 구현을 두고, Dash, Heal, Grenade, Emote 등 다른 스킬은 모두 Gameplay Ability로 구현되어 있다.

먼저, LyraHeroComponent에서 InputAction을 바인드 한다.

void ULyraHeroComponent::InitializePlayerInput(UInputComponent* PlayerInputComponent)
{
    ...
    UEnhancedInputLocalPlayerSubsystem* Subsystem = LP->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>();
    check(Subsystem);

    Subsystem->ClearAllMappings();

    if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
    {
        if (const ULyraPawnData* PawnData = PawnExtComp->GetPawnData<ULyraPawnData>())
        {
            if (const ULyraInputConfig* InputConfig = PawnData->InputConfig)
            {
                for (const FInputMappingContextAndPriority& Mapping : DefaultInputMappings)
                {
                    ...
                    Subsystem->AddMappingContext(IMC, Mapping.Priority, Options);
                }

                // The Lyra Input Component has some additional functions to map Gameplay Tags to an Input Action.
                // If you want this functionality but still want to change your input component class, make it a subclass
                // of the ULyraInputComponent or modify this component accordingly.
                ULyraInputComponent* LyraIC = Cast<ULyraInputComponent>(PlayerInputComponent);
                if (LyraIC)
                {
                    ...
                    // This is where we actually bind and input action to a gameplay tag, which means that Gameplay Ability Blueprints will
                    // be triggered directly by these input actions Triggered events. 
                    TArray<uint32> BindHandles;
                    LyraIC->BindAbilityActions(InputConfig, this, &ThisClass::Input_AbilityInputTagPressed, &ThisClass::Input_AbilityInputTagReleased, /*out*/ BindHandles);

                    LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Move, ETriggerEvent::Triggered, this, &ThisClass::Input_Move, /*bLogIfNotFound=*/ false);
                    LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Look_Mouse, ETriggerEvent::Triggered, this, &ThisClass::Input_LookMouse, /*bLogIfNotFound=*/ false);
                    LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Look_Stick, ETriggerEvent::Triggered, this, &ThisClass::Input_LookStick, /*bLogIfNotFound=*/ false);
                    LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Crouch, ETriggerEvent::Triggered, this, &ThisClass::Input_Crouch, /*bLogIfNotFound=*/ false);
                    LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_AutoRun, ETriggerEvent::Triggered, this, &ThisClass::Input_AutoRun, /*bLogIfNotFound=*/ false);
                }
            }
        }
    }
    ...
}

LyraInputComponent에서 AbilityActions를 묶고, 이동 관련 함수를 바인드한다.

template<class UserClass, typename PressedFuncType, typename ReleasedFuncType>
void ULyraInputComponent::BindAbilityActions(const ULyraInputConfig* InputConfig, UserClass* Object, PressedFuncType PressedFunc, ReleasedFuncType ReleasedFunc, TArray<uint32>& BindHandles)
{
    check(InputConfig);

    for (const FLyraInputAction& Action : InputConfig->AbilityInputActions)
    {
        if (Action.InputAction && Action.InputTag.IsValid())
        {
            if (PressedFunc)
            {
                BindHandles.Add(BindAction(Action.InputAction, ETriggerEvent::Triggered, Object, PressedFunc, Action.InputTag).GetHandle());
            }

            if (ReleasedFunc)
            {
                BindHandles.Add(BindAction(Action.InputAction, ETriggerEvent::Completed, Object, ReleasedFunc, Action.InputTag).GetHandle());
            }
        }
    }
}

void ULyraHeroComponent::Input_AbilityInputTagPressed(FGameplayTag InputTag)
{
    if (const APawn* Pawn = GetPawn<APawn>())
    {
        if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
        {
            if (ULyraAbilitySystemComponent* LyraASC = PawnExtComp->GetLyraAbilitySystemComponent())
            {
                LyraASC->AbilityInputTagPressed(InputTag);
            }
        }    
    }
}

void ULyraHeroComponent::Input_AbilityInputTagReleased(FGameplayTag InputTag)
{
    const APawn* Pawn = GetPawn<APawn>();
    if (!Pawn)
    {
        return;
    }

    if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
    {
        if (ULyraAbilitySystemComponent* LyraASC = PawnExtComp->GetLyraAbilitySystemComponent())
        {
            LyraASC->AbilityInputTagReleased(InputTag);
        }
    }
}

BindAbilityActions에서는 LyraInputConfig에 저장된 <InputAciton, GameplayTag> 쌍에 대해 Input_AbilityInputTagPressed와 Input_AbilityInputTagReleased를 바인드한다. Input 함수는 ASC의 AbilityInputTagPressed/Released 함수를 호출한다.

void ULyraAbilitySystemComponent::AbilityInputTagPressed(const FGameplayTag& InputTag)
{
    if (InputTag.IsValid())
    {
        for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
        {
            if (AbilitySpec.Ability && (AbilitySpec.GetDynamicSpecSourceTags().HasTagExact(InputTag)))
            {
                InputPressedSpecHandles.AddUnique(AbilitySpec.Handle);
                InputHeldSpecHandles.AddUnique(AbilitySpec.Handle);
            }
        }
    }
}

ASC에서는 실행 가능한 Ability 목록에서 태그를 검색해 InputPressedSpecHandles와 InputHeldSpecHandles에 핸들을 추가하고,

void ULyraAbilitySystemComponent::ProcessAbilityInput(float DeltaTime, bool bGamePaused)
{
    ...

    for (const FGameplayAbilitySpecHandle& SpecHandle : InputHeldSpecHandles)
    {
        if (const FGameplayAbilitySpec* AbilitySpec = FindAbilitySpecFromHandle(SpecHandle))
        {
            if (AbilitySpec->Ability && !AbilitySpec->IsActive())
            {
                const ULyraGameplayAbility* LyraAbilityCDO = Cast<ULyraGameplayAbility>(AbilitySpec->Ability);
                if (LyraAbilityCDO && LyraAbilityCDO->GetActivationPolicy() == ELyraAbilityActivationPolicy::WhileInputActive)
                {
                    AbilitiesToActivate.AddUnique(AbilitySpec->Handle);
                }
            }
        }
    }

    for (const FGameplayAbilitySpecHandle& SpecHandle : InputPressedSpecHandles)
    {
        ...
    }


    for (const FGameplayAbilitySpecHandle& AbilitySpecHandle : AbilitiesToActivate)
    {
        TryActivateAbility(AbilitySpecHandle);
    }

    for (const FGameplayAbilitySpecHandle& SpecHandle : InputReleasedSpecHandles)
    {
        ...
    }

    InputPressedSpecHandles.Reset();
    InputReleasedSpecHandles.Reset();
}

ProcessAbilityInput에서 TryActivateAbility(AbilitySpecHandle);을 통해 모든 입력을 한번에 처리한다. ProcessAbilityInput는 PostProcessInput에서 실행된다.

void ALyraPlayerController::PostProcessInput(const float DeltaTime, const bool bGamePaused)
{
    if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
    {
        LyraASC->ProcessAbilityInput(DeltaTime, bGamePaused);
    }

    Super::PostProcessInput(DeltaTime, bGamePaused);
}

대략 이런 구조이다.

Unreal Engine에서 기본 요소의 초기화 순서 (Host-Client)

타자치는 문돌이 — Fri, 24 Oct 2025 17:04:27 +0900

각 요소를 초기화하고 의존성을 묶는 시작 지점에서 연결이 안되는 문제가 발생했다.
그래서 GameMode, PlayerController, PlayerState, DefaultPawn, HUD 클래스의 초기화 순서에 대해 알아보기로 하였다.

실험 방법

TEST 클래스를 만든 뒤, 클래스를 상속 받는 BP를 만들고, GameMode에 적용했다.

ATESTGameModeBase::ATESTGameModeBase()  
{  
    NET_LOG(Log, TEXT("GameMode::Constructor"));  
}

TEST 클래스는 NET_LOG 매크로를 구현해 로그를 출력했다.

LogNetRole: [PIE0][Standalone][SID=-1] [Server] GameMode::Constructor

[PIE0] : PlayInEditor ID. 구분하기 제일 좋은 기준
[SID] : PlayerState의 PlayerId로 없으면 -1
[Server] : HasAuthority면 Server, 아니면 Client. HUD와 Standalone은 Client가 권한이 있어 Server로 나오는 한계가 있다.

Standalone

LogNetRole: [PIE0][Standalone][SID=-1] [Server] GameMode::Constructor
LogNetRole: [PIE0][Standalone][SID=-1] [Server] PlayerController::Constructor
LogNetRole: [PIE0][Standalone][SID=-1] [Server] PlayerState::Constructor
LogNetRole: [PIE0][Standalone][SID=-1] [Server] PlayerState::PostInitializeComponents
LogNetRole: [PIE0][Standalone][SID=262] [Server] HUD::Constuctor
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerCharacter::Constructor
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerCharacter::PossessedBy
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerCharacter::SetupPlayerInputComponent
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerController::OnPossess
LogNetRole: [PIE0][Standalone][SID=262] [Server] GameMode::BeginPlay
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerController::BeginReplication
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerController::BeginPlay
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerState::BeginPlay
LogNetRole: [PIE0][Standalone][SID=262] [Server] HUD::BeginPlay
LogNetRole: [PIE0][Standalone][SID=262] [Server] PlayerCharacter::BeginPlay

GameMode->PlayerController->PlayerState->HUD->DefaultPawn 순서로 생성되고, BeginPlay도 같은 순서로 실행된다. HUD가 PlayerCharacter보다 먼저 실행되므로 PlayerCharacter의 BeginPlay에서 HUD가 참조해야 할 요소가 초기화된다면 문제가 있을 수 있다.

Listen Server (Host-Client)

LogNetRole: [PIE0][ListenServer][SID=-1] [Server] GameMode::Constructor
LogNetRole: [PIE0][ListenServer][SID=-1] [Server] PlayerController::Constructor
LogNetRole: [PIE0][ListenServer][SID=-1] [Server] PlayerState::Constructor
LogNetRole: [PIE0][ListenServer][SID=-1] [Server] PlayerState::PostInitializeComponents
LogNetRole: [PIE0][ListenServer][SID=264] [Server] HUD::Constuctor
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::Constructor
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::PossessedBy
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::SetupPlayerInputComponent
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::OnPossess
LogNetRole: [PIE0][ListenServer][SID=264] [Server] GameMode::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::BeginReplication
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerState::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] HUD::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::Constructor
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerState::Constructor
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerState::PostInitializeComponents
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerState::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::BeginReplication
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::BeginReplication
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::Constructor
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::BeginPlay
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerCharacter::PossessedBy
LogNetRole: [PIE0][ListenServer][SID=264] [Server] PlayerController::OnPossess
LogNetRole: [PIE1][Client][SID=-1] [Server] PlayerController::Constructor
LogNetRole: [PIE1][Client][SID=-1] [Server] HUD::Constuctor
LogNetRole: [PIE1][Client][SID=-1] [Server] PlayerCharacter::Constructor
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerController::OnRep_Pawn
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerCharacter::OnRep_Controller
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerController::BeginReplication
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerController::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Server] HUD::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerCharacter::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Server] PlayerCharacter::Constructor
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerCharacter::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerController::OnRep_Pawn
LogNetRole: [PIE1][Client][SID=-1] [Server] PlayerState::Constructor
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerState::PostInitializeComponents
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerState::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Server] PlayerState::Constructor
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerState::PostInitializeComponents
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerState::BeginPlay
LogNetRole: [PIE1][Client][SID=-1] [Client] PlayerCharacter::OnRep_PlayerState
LogNetRole: [PIE1][Client][SID=265] [Client] PlayerState::ClientInitialize
LogNetRole: [PIE1][Client][SID=265] [Client] PlayerController::OnRep_PlayerState
LogNetRole: [PIE1][Client][SID=265] [Client] PlayerCharacter::OnRep_PlayerState
LogNetRole: [PIE1][Client][SID=265] [Client] PlayerCharacter::OnRep_Controller
LogNetRole: [PIE1][Client][SID=265] [Client] PlayerCharacter::SetupPlayerInputComponent

Host 쪽에서의 순서는 Host 생성 -> 순차적으로 Client 생성으로 예측 가능한 범주지만, Client 쪽은 아무것도 보장되지 않는다. GPT에 따르면,Connection 이후에 액터 채널이 먼저 열린 것부터 생성한 뒤 데이터를 받는다고 한다. 그리고 생성 직후 BeginPlay가 실행되지만, 이 시점에 데이터 복사가 완료되지 않아 OnRep은 더 늦게 호출된다. 즉, 클라이언트는 BeginPlay 때 의존성 있는 요소가 모두 생성되었는 지 보장이 안되고, 생성되었어도 서버 데이터가 적용되었는 지 보장할 수 없다.

오류가 났던 상황을 검토해보자.

PlayerState는 AbilitySystemComponent를 가진다.
AbilitySystemComponent는 InitAbilityActorInfo라는 함수를 써서 초기화하는 과정이 서버와 클라이언트 모두에서 한번 필요한데, 이때 PlayerCharacter가 필요하다.
HUD는 AbilitySystemComponent를 통해 Player의 스탯을 출력한다.

서버의 경우, PlayerState->HUD->PlayerCharacter 순서대로 생성되므로 PlayerCharacter 생성 후 PossessedBy에서 InitAbilityActorInfo를 실행한 뒤, HUD의 BeginPlay에서 데이터를 읽도록 할 수 있다.
클라이언트의 경우, OnRep_PlayerState에서 InitAbilityActorInfo와 HUD의 데이터 읽기가 가능하다. 그런데 상황에 따라 순서가 바뀔 수도 있다.

생각해보니 로비에서부터 PlayerState를 만들고 넘기면 될 것 같기도...

Code in Coffee

[CPP] 1. 객체와 메모리

객체에 어떻게 접근할까? - 주소와 포인터

객체의 수명 - Stack, Heap, Static의 생명주기

객체는 어떻게 메모리에 배치되는가 - sizeof, alignment, padding

배열, 포인터, 연속 메모리

사라진 객체 - Dangling Pointer와 Undefined Behavior

Dangling Pointer

Undefined Behaviour

const와 메모리

const int*와 int* const

const &

함수 인자로의 const

[softeon-theme] Stitch와 Codex로 Jekyll Blog Theme 만들기

기능 기획

구현

느낀 점

[ProjectRE] 개발 일지 1

복기

개발 방식

LLM 도입

주요 구현

Experience System

GAS 기반 전투 시스템

Enhancement System

Widget Controller 기반 UI

BT 기반 Enemy

막힌 부분

기획과 에셋

Map 구현 방식

Enhancement System

Loading Screen

다음 개발 동안 생각해 볼 것

개발 방식

LLM Wiki 도입

은근히 거슬리는 폴더 구조

객체 지향

도입해 볼 만한 기술

PCG, Level Streaming

Motion Matching

Async Load

Gameplay Camera

흠...

[TinyRenderer] Lesson 1. Bresenham 직선 알고리즘

[TinyRenderer] Lesson 0. 시작하기

Heap, Hashmap, Set

Heap

Hashmap

Set

순열과 조합, 비트마스크

순열

조합

비트마스크

Lyra와 모듈형 게임플레이

Game Feature와 Experience

Modular Gameplay Actor와 Component

Lyra의 스킬 발동

Unreal Engine에서 기본 요소의 초기화 순서 (Host-Client)

실험 방법

Standalone

Listen Server (Host-Client)

객체는 어떻게 메모리에 배치되는가 - `sizeof`, alignment, padding

`const int`와 `int const`

함수 인자로의 `const`