개발하는 리프터 꽃게맨입니다.

effective C++ - bad_alloc 에 대비하는 방법

파워꽃게맨 — Thu, 26 Jun 2025 15:08:37 +0900

new 로 동적메모리를 할당하려고 시도할 때, 메모리가 부족하다면 std::bad_alloc 예외를 뱉는다.

아예 nullptr를 뱉어버리는 malloc 보다는 처리하기 용이한 방식이다.

그런데 new를 사용할 때 마다. try ~ catch 를 하는건 코드를 복잡하게 만들 우려가 있다.

다행히도 new가 메모리 할당에 실패하면 std::bad_alloc 뿐만 아니라 std::new_handler 라는 함수를 호출한다.

이 함수는 전역적으로 관리되는 함수이며, 사용자가 직접 정의할 수도 있다.

new를 실패할 시 쓰레드는 my_new_handler에서 멈춘다.

한 번쯤 고민해봤던 사항이라 유익할 것 같아서 따로 기록해둔다.

Jam Engine 1차 개발 보고서

파워꽃게맨 — Sun, 8 Jun 2025 16:55:19 +0900

서론

캡스톤 디자인 2팀의 프로젝트는 자체적으로 개발한 엔진을 이용하여 게임을 제작하는 것이다. 해당 문서는 현재까지 개발된 엔진의 기본적인 메모리 관리부터 실시간 게임 루프, 개발에 유용한 유틸리티 등을 보고한다.

1. 개발환경

주 개발 언어는 C++ 20 을 사용하고 컴파일러는 MSVC 를 사용한다. 그래픽 API로는 DirectX 11 를 사용한다. 더하여 사용한 서드파티는 다음과 같다.

1) SDL3: 크로스 플랫폼 UI 및 미디어 라이브러리
2) Imgui: 즉시 렌더링 GUI
3) ENTT: 게임 루프 구성
4) nlohmann json: JSON 기반 직렬화 라이브러리
5) spdlog: 로깅 시스템
6) google flatbuffer: 바이너리 기반 직렬화 라이브러리

개발 OS는 Windows x64기반이며 크로스 플랫폼은 지원하지 않는다.

2. 메모리 관리

일반적으로 가변 길이 메모리의 경우 new / delete 를 사용하지만, 부지불식간에 할당, 해제되는 리소스는 고정 길이 메모리 풀을 이용하여 관리한다. 또한 상위 레벨에서는 참조 카운트 기반 자체적인 스마트 포인터를 제공한다.

고정길이 메모리 풀

힙 할당은 효율적이지만, 할당과 해제가 빈번한 루프 상황에서는 병합 비용이 체감될 정도로 크고 메모리 파편화 우려가 있다. 이러한 상황에 대처하기 위해 자주 사용되는 오브젝트에 대해 메모리를 미리 할당하여 따로 해제하지 않고 지속적으로 재사용하도록 한다.

캐시라인을 고려하여 4kb 정도의 힙 메모리를 미리 할당한뒤 고정 길이 (ex. 32byte) 로 자른뒤 메모리 요청이 들어오면 해당 블록의 포인터를 반환한다. 해제 요청이 들어오면 따로 메모리는 해제하지 않는다. 이러한 시스템을 고정길이 메모리 풀이라고 정의한다.

4kb 가 넘는 메모리 할당이 요구될 수도 있기 때문에, 필요에따라 동적으로 메모리 풀을 추가롤 할당하여 사용자 입장에서는 일반적인 힙 할당과 동일한 감각으로 사용할 수 있다. 메모리 풀마다 8byte의 링크를 추가하여 메모리 풀들 끼리는 연결 리스트 형태로 연결되어있고, 요청에 따라 순차적으로 파괴할 수 있다.

초기에는 힙 메모리를 모방하여 범용 메모리 풀을 개발하였으나 이 경우 메모리 사용량이 과하게 많이 증가하여 필요이상의 메모리를 할당하고 있는 문제가 발생했다. 그래서 범용 메모리의 경우 new delete 를 사용을 하고 할당 해제가 빈번한 객체만 메모리 풀을 이용하여 관리한다.

또 다른 문제점으로는 멀티스레드 환경에서의 critical section이 될 수 있다는 것인데, 스레드의 로컬 스토리지 마다 메모리 풀을 생성하면 이 문제를 해결할 수 있다.

참조 카운트 기반 포인터

메모리 관리를 편리하게 하기 위해 참조 카운트를 세어 0이 될 경우 자동으로 메모리 해제가 되도록하는 포인터의 얇은 래퍼이다. 언어 기반에서도 std::shared_ptr 라는 래퍼를 제공하나, 반드시 malloc free 를 사용해야하며 참조 카운트가 thread-safe 하기에 성능 저하가 발생한다는 단점이 있다. 싱글 스레드 기반 해당 엔진에서는 참조 카운트의 원자적 연산이 불필요하고, std::shared_ptr의 객체와 참조 카운터 블록간의 캐시 히트율이 떨어진다는 단점이 존재했기 때문에 직접 래퍼를 만들 필요가 있었다.

JSharedPtr은 카운터 블록과 객체간의 연속된 메모리를 보장하기 때문에 참조 카운트 간의 캐시 히트율이 매우 높고 참조 카운팅이 아토믹하지 않기 때문에 일반 std::shared_ptr 대비 30% 가량의 성능 향상을 이끌어 냈다. 앞서 설명한 메모리 풀과 결합할시 할당 및 해제 속도는 최대 8배까지 빨라진다.

3. 레이어 기반 어플리케이션 루프

어플리케이션에는 고정된 루프가 존재하고 Layer 인터페이스를 상속한 Layer 객체를 메인 어플리케이션에 부착하여 자연스럽게 루프에 간섭할 수 있다.

레이어 시스템

Layer란 프로그램의 서브 시스템 정도로 볼 수 있는데, 이런 서브 시스템기반 Layer 구조는 사용자가 원하는 방향으로 어플리케이션을 확장해나갈 수 있도록 한다. 기본적으로 엔진에서 제공하는 Layer로는 SceneLayer, EditorLayer 등이 있는데 SceneLayer는 게임루프를 제공하고 EditorLayer는 에디팅 시스템을 제공한다.

즉, 엔진 차원에서도 레이어를 확장하여 어플리케이션을 구축하고 사용자 입장에서도 레이어를 확장하여 여러가지 기능을 부착할 수 있다. 물리엔진을 위한 PhysicLayer를 부착할 수도 있고, 네트워크를 위한 NetworkLayer를 부착할 수도 있다.

레이어 간의 통신

Layer 들은 서로 이벤트를 발생시켜 통신한다. 원하는 데이터를 담은 이벤트 구조체를 최상위 어플리케이션에 전송하면 어플리케이션은 이벤트를 모든 레이어에 브로드캐스트한다. 각 레이어는 자신이 처리할 이벤트 리스너를 정의하고 임의의 이벤트를 수신했을 때 적절한 이벤트 리스너를 실행시킨다. 이러한 이벤트 기반 통신은 레이어가 서로의 존재를 몰라도 통신할 수 있다는 장점이 있다.

어플리케이션은 레이어 및 이벤트 기반 구조를 이용하여 항상 느슨한 결합을 유지하며, 이는 개발 유연성을 보장해준다.

4. Entity Component System

전통적으로 가장 애용된 게임 시스템은 Object Oriented Programming 을 기저에 둔 Object Component 구조이다. 이 구조는 Object 라는 상위 클래스를 상속하여 구체적인 클래스 내부에서 로직를 구성하고, Component라고 하는 여러 Object에서 재사용 가능한 요소들을 Object와 결합한다. Object는 Component 를 담은 컨테이너임과 동시에 스스로 게임 로직을 구성하는 요소이다.

그러나 이런 컴포넌트 객체는 메모리가 분산되어 있기 때문에 1초에 60~120회 루프를 돌아야하는 게임 시스템상 성능 저하가 발생할 수 있다. 캐시 히트라는 건 생각보다 성능을 엄청 좌우한다. 동일한 컴포넌트는 동일한 로직을 수행시키기 때문에 성능을 위주로 생각한다면 동일한 컴포넌트를 한 데 모아서 루프를 수행하는 것이 더 효과적이다. 이를 달성하기 위해서는 전통적인 Object Component 구조를 포기하고 다른 대안을 찾아야 한다.

Entity Component System은 이러한 문제에 대한 완벽한 해결책이다. Object가 Component의 컨테이너가 되는 것이 아니라 Component 는 각자 고유의 컨테이너를 가지고 있다. 해당 컨테이너는 메모리 상 연속적인 공간을 할당하여, 공간 지역성과 시간 지역성이 매우 높다. 이러한 특성 때문에 다형성을 사용하지 못하고 Component는 POD 타입에 가까운 구조체이다. Entity은 Component의 소유자를 가리키는 단순 정수이고 식별자 이외의 역할은 하지 않는다. System은 순수한 로직을 의미한다.

Entity Component System은 결국 Object Component 를 식별자 - 데이터 - 로직 3가지 순수한 단위로 나눈 것이다. 이렇게 각각을 분리하여 효율적인 게임 루프를 구성할 수 있고 사용자에게 원활한 사용감을 제공한다.

5. 렌더링

렌더링 API는 앞서 기술했듯 DirectX11을 사용한다. 그래픽스 API 특성상 복잡한 로직이 다수 존재하기에 얇은 래퍼로 감싼 퍼사드를 제공한다. DirectX11은 드라이버 수준에서 많은 최적화를 제공해주기 때문에 중복된 데이터에 대한 캐시를 제외하고는 특별한 최적화를 하진 않는다.

렌더링의 경우 사용자 의도대로 프로그래밍할 수 있도록 하기 위해 정해진 루프는 제공되지 않는다. 그러나 여타 게임 엔진과 동일하게 내부 구조를 잘 모르더라도 게임을 개발할 수 있도록 여러가지 헬퍼 혹은 built-in 된 렌더링 객체들을 제공한다.

Built-in 쉐이더

Built-in 된 그래픽스 알고리즘을 제공하기 위해서는 쉐이더 코드가 필수적이다. 일반적으로는 HLSL 파일 형태로 제공하며 파일을 로딩하여 컴파일 후 사용하는 것이 일반적이나, 이 경우 배포가 어렵다는 단점이 있다. 그래서 컴파일된 쉐이더의 바이너리 코드를 라이브러리에 포함시켜서 배포하는 방식을 선택했다.

HLSL을 변경할 때마다 바이너리 코드를 업데이트 해줘야한다는 단점이 있다. 이는 개발중인 HLSL을 추적하여 프로젝트를 빌드할 때마다 스크립트를 이용해 자동으로 컴파일하는 방법을 사용하여 해결하였다.

Physical Based Rendering

실제 물리현상을 모방하여 라이팅하는 기법이며 해당 엔진의 표준 쉐이더로 차용하고 있다. 배경이 방출하는 빛을 미리 계산하여 텍스처 형태로 저장하고, 그것을 이용하여 물리법칙에 의거한 빛 반사를 근사한다.

Post Process

이미 렌더링된 화면을 후처리를 이용하여 추가적인 효과를 제공하는 기법이다. Deferred Rendering 을 기반으로 동작하기 때문에 안티에일리어싱을 적용하기위해 FXAA 필터를 제공하고, 물리 기반 블러를 이용하여 자연스러운 빛 번짐, 발광 등을 구현한다.

추가적으로 안개 효과, 비네팅, 톤 매핑 등 영화적이고 엔터테이먼트 적인 후처리 효과도 이미지 필터 형태로 제공된다.

Lighting

전통 라이팅 기법은 오버헤드가 크기에 라이팅 볼륨을 이용하여 효율적으로 광원을 렌더링한다. 이 경우 광원을 1000개 이상 렌더링해도 실시간 게임 플레이에 문제없는 프레임 속도를 제공한다. 광원은 평행광, 점광, 스포트라이트 총 3종류를 제공하며 셋 다 직접적인 라이팅이 아닌 빛을 대변하는 지오메트리를 렌더링하여 빛 반사를 근사한다.

Shadow

쉐도우는 쉐도우 매핑 기반이며 광원의 종류 별로 1개씩만 만들어낼 수 있다. 렌더러가 Rasterizer 기반이기 때문에 그림자 렌더링에 상당한 오버헤드가 발생하기 때문에 제한할 수 밖에 없었다. 대부분의 겨우 평행광이 만들어내는 그림자가 가장 중요하기 때문에 극심한 오버헤드를 감수하고 무한정 그림자를 만들어내도록 구현할 이유는 없었다.

손전등같은 스포트라이트는 쉐도우 매핑을, 태양광같은 평행광은 레벨을 조정할 수 있는 Cascade Shadow Mapping을, 전구같은 점광에는 Omni-Directional Shadow Mapping 알고리즘이 수행된다.

Screen Space Ambient Occlusion

Deferred Rendering 을 기반으로 표준 쉐이더가 동작하기 때문에 차폐광을 저렴한 비용으로 도입할 수 있었다. 물체의 틈의 경우 빛이 도달하기 힘들기 때문에 오클루전이라는 그림자효과를 더하면 현실적인 느낌을 줄 수 있다. 실제로는 여러 번 Ray를 쏴서 계산해야하지만 G-buffer 데이터를 이용하여 근사할 수 있었다.

Pre Baked Texturing

빛과 그림자는 앞서 말했듯 비용이 매우 크기 때문에 미리 그림자를 계산하여 텍스처 매핑을 사용할 수 있다. 현재 이러한 텍스처링을 수행할 수는 있지만, 직접 굽는 기능은 제공되지 않는다. 이는 추후 개발할 과제로 남을 것이다.

앞으로 남은 과제

현재 과제로는 Rim light (테두리 효과), 애니메이션, 반사 효과, 반투명 효과등이 있다. 이는 본격적인 게임 개발을 시작하면서 점진적으로 개발할 계획이다.

리소스

초기에는 리소스를 미리 로딩하고 개발을 했지만, 메모리 공간은 한정되어 있기에 당장에 사용해야할 리소스와 아닌 리소스를 구분하여 필요할때 로딩하고 언로드할 필요성이 생겼다.

게임을 구성하는 기본적인 단위를 Scene이라고 부르는 데 Scene 별로 사용하는 리소스를 구분하여 로딩하는 것이 현실적인 해결방법이었다.

에셋 매니저

3D 모델, 텍스처 등을 에셋이라고 하고, 이들을 로드하고 저장하고 제공하는 클래스를 에셋 매니저라고 한다. 에셋 매니저는 씬 마다 하나씩 존재하며 해당 씬에서 사용하는 에셋 목록을 저장한다. 씬이 로드될 때 씬에서 필요한 자원을 한번에 로딩한다. 중복 로딩을 방지하기 위해서 씬이 변경되는 시점에서 중복된 에셋은 이전 씬의 에셋 포인터를 그대로 가져온다.

에셋은 게임이 배포되어도 정확하게 로딩되어야 하므로 각자의 경로를 저장하고 있고, 엔진 고유의 파일 시스템에 의해 엄격하게 관리된다.

모델 최적화

에셋 중에 가장 복잡하고 로딩시간이 긴 리소스는 모델이다. 모델은 적어도 3만개 이상의 버텍스로 이루어져 있기 때문에 원본 형식으로 로딩하면 모델 당 3 ~

5초 정도의 로딩시간이 걸린다. 이를 개선하기 위해 엔진은 고유의 모델 구조를 사용하며 바이너리 코드 형태로 관리한다. 엔진에 내장된 ModelImporter은 외부 형식 모델을 로딩하여 엔진 표준 형식으로 바꿔준다. 이러면 로딩시간을 10배 ~

15배 가량 단축할 수 있다.

직렬화

C++는 언어 특성상 빌드 시간이 매우 많이 걸린다. 이는 C++ 기반 게임 엔진인 언리얼 엔진도 가지고 있는 고질적인 문제이다. 이를 개선하기 위해서 최대한 개발 작업을 에디터를 이용하여 런타임에 진행할 수 있어야한다. 런타임에 개발한다는 것은 게임의 구성요소가 읽고 쓸 수 있는 데이터로 변환될 수 있어야한다는 것을 의미하기도 한다.

그래서 게임의 로직은 C++ 언어 기반으로 작성하되 오브젝트의 구성, 배치, 테스트, 씬 구성등을 데이터 형식으로 변환할 수만 있어도 생산성이 매우 올라간다.

로직 자체도 스크립트 언어를 사용하면 런타임에 구성할 수 있지만, 개발 시간 대비 리턴이 적다고 판단했기에 이번 프로젝트에 포함되지 않았다.

씬 데이터 직렬화

앞서말한 오브젝트의 구성, 배치, 씬 구성등 모두 씬을 직렬화/역직렬화 할 수 있다면 한 번에 달성할 수 있는 목표들이다. 여기서 핵심은 오브젝트의 직렬화인데, Entity Component System을 채용하는 게임 특성상 Component 가 부지기수적으로 늘어날 수 있기 때문에 직렬화하기 매우 까다롭다는 점이 문제점으로 다가왔다.

바꿀 수 없는 진실은 모든 컴포넌트가 직렬화 역직렬화 로직을 제공해야하며, 런타임에 추가 및 삭제를 제공해야한다는 점이다. 이를 위해서 컴포넌트들이 런타임 리플렉션을 제공하도록 매크로를 정의하였으며 매크로를 가지고 있지 않은 컴포넌트들이 있으면 아예 컴파일이 되지 않도록 막아버렸다.

이를 통해서 런타임에 씬 데이터를 모두 직렬화 및 역직렬화할 수 있는 기반을 마련했고 런타임에 게임을 구성할 수 있게 하였다.

GUI 기반 에디팅 시스템

런타임에 에셋을 로드하고 씬을 쉽게 구성할 수 있도록 GUI 기반 시스템을 제공한다. 버튼 조작으로 씬을 구성하고 데이터를 직렬화 및 역직렬화할 수 있고 게임 구성요소를 간단히 조작할 수 있다.

또한, 씬을 멈추고 프레임 단위로 분석하는 등 다양한 기능을 제공한다. 최대한 드래그 드랍을 이용하여 빠르게 제품을 생산할 수 있도록 하였다.

빌드 시스템

프로그램은 개발 시점과 배포 시점의 단계로 나눌 수 있으며, 이 둘은 달라야한다. 스크립트를 이용하여 배포할 수 있는 실행파일을 빌드할 수 있으며 아직 많은 테스트가 필요한 기능이며 게임 개발과 함께 점진적으로 개발해나갈 계획이다.

앞으로 남은 과제

생각보다 엔진 기반을 잡는데 오래 걸렸고 팀원들도 엔진 사용에 익숙하지 않으며, 테스트도 충분히 진행되지 않았기 때문에 방학동안은 게임을 만들기전 충분한 엔진 사용과 테스트를 이용하여 프로토타입 개발에 힘 쓸 계획이다.

뻘짓) 콘솔로 래스터라이제이션 기반 큐브 렌더링하기

파워꽃게맨 — Thu, 17 Apr 2025 14:43:52 +0900

한 3시간 걸린 것 같습니다.

재밌네요

전체코드

#include <iostream>

#define NOMINMAX

#include <Windows.h>

#include <cassert>

#include <chrono>

#include <vector>

#define PI 3.14159265358979323846f

#define DEG2RAD(x) ((x) * PI / 180.f)

struct ScreenBuffer

{

uint8_t* buffer;

uint32_t width;

uint32_t height;

};

struct Matrix4x4

{

float m[4][4];

static Matrix4x4 Identity()

{

Matrix4x4 result = {};

result.m[0][0] = 1.0f;

result.m[1][1] = 1.0f;

result.m[2][2] = 1.0f;

result.m[3][3] = 1.0f;

return result;

}

};

struct Vec3

{

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

Vec3 operator*(const float& scalar) const { return { x * scalar, y * scalar, z * scalar }; }

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

float Dot(const Vec3& other) const { return x * other.x + y * other.y + z * other.z; }

Vec3 Cross(const Vec3& other) const

{

return {

y * other.z - z * other.y,

z * other.x - x * other.z,

x * other.y - y * other.x

};

}

Vec3 Normalize() const

{

float length = sqrtf(x * x + y * y + z * z);

return { x / length, y / length, z / length };

}

float x, y, z;

};

struct Vec4

{

Vec4() = default;

Vec4(const Vec3& vec3, float w) : x(vec3.x), y(vec3.y), z(vec3.z), w(w) {}

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

float x, y, z, w;

};

struct GrayScale

{

float scale;

};

struct Vertex

{

Vec3 posL;

Vec3 normal;

GrayScale color;

};

struct PSInput

{

Vec4 posH;

Vec3 posW;

Vec3 normal;

GrayScale color;

};

struct Context

{

ScreenBuffer frontBuffer;

float* depthBuffer;

HANDLE mainConsole;

bool prevKeyInput[256];

bool keyInput[256];

float deltaTime;

std::chrono::high_resolution_clock::time_point lastTime;

PSInput(*vertexShader)(const Vertex&);

GrayScale(*pixelShader)(const PSInput&);

} g_context;

void InitContext(uint32_t width, uint32_t height);

void ReleaseContext();

void DrawPixel(const ScreenBuffer* in_buffer, uint32_t x, uint32_t y, uint8_t color);

void PresentToConsole(const ScreenBuffer* in_buffer);

char CvtColorToChar(uint8_t color);

void ClearScreenBuffer(const ScreenBuffer* in_buffer, uint8_t color);

void InitContext(uint32_t width, uint32_t height)

{

g_context.mainConsole = GetStdHandle(STD_OUTPUT_HANDLE);

g_context.frontBuffer.width = width;

g_context.frontBuffer.height = height;

g_context.frontBuffer.buffer = new uint8_t[width * height];

g_context.depthBuffer = new float[width * height];

g_context.lastTime = std::chrono::high_resolution_clock::now();

ClearScreenBuffer(&g_context.frontBuffer, 0);

PresentToConsole(&g_context.frontBuffer);

}

void ReleaseContext()

{

delete[] g_context.frontBuffer.buffer;

delete[] g_context.depthBuffer;

}

char CvtColorToChar(uint8_t color)

{

uint8_t key = (color / 255.f) * 9.f;

switch (key)

{

case 0: return ' ';

case 1: return '.';

case 2: return ':';

case 3: return '-';

case 4: return '=';

case 5: return '+';

case 6: return '*';

case 7: return '#';

case 8: return '%';

case 9: return '@';

default: return ' ';

}

void DrawPixel(const ScreenBuffer* in_buffer, uint32_t x, uint32_t y, uint8_t color)

{

if (x < in_buffer->width && y < in_buffer->height)

in_buffer->buffer[y * in_buffer->width + x] = CvtColorToChar(color);

}

void PresentToConsole(const ScreenBuffer* in_buffer)

{

DWORD written;

for (int y = 0; y < in_buffer->height; y++)

{

WriteConsoleA(g_context.mainConsole,

in_buffer->buffer + y * in_buffer->width,

in_buffer->width,

&written, nullptr);

WriteConsoleA(g_context.mainConsole,

"\n",

&written, nullptr);

}

SetConsoleCursorPosition(g_context.mainConsole, { 0, 0 });

}

void ClearScreenBuffer(const ScreenBuffer* in_buffer, uint8_t color)

{

std::memset(in_buffer->buffer, CvtColorToChar(color), in_buffer->width * in_buffer->height);

}

void ClearDepthBuffer(const ScreenBuffer* in_buffer, float depth)

{

std::memset(g_context.depthBuffer, depth, in_buffer->width * in_buffer->height * sizeof(float));

}

bool DepthTest(float depth, uint32_t x, uint32_t y)

{

if (depth > g_context.depthBuffer[y * g_context.frontBuffer.width + x])

{

g_context.depthBuffer[y * g_context.frontBuffer.width + x] = depth;

return true;

}

return false;

}

void UpdateInput()

{

for (int i = 0; i < 256; i++)

{

if (GetAsyncKeyState(i) & 0x8000)

g_context.keyInput[i] = true;

else

g_context.keyInput[i] = false;

}

std::memcpy(g_context.prevKeyInput, g_context.keyInput, sizeof(g_context.prevKeyInput));

}

void UpdateTimer()

{

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

g_context.deltaTime = std::chrono::duration<float>(now - g_context.lastTime).count();

g_context.lastTime = now;

}

bool IsKeyPressed(int key) { return g_context.keyInput[key] && !g_context.prevKeyInput[key]; }

bool IsKeyReleased(int key) { return !g_context.keyInput[key] && g_context.prevKeyInput[key]; }

bool IsKeyDown(int key) { return g_context.keyInput[key]; }

bool IsKeyUp(int key) { return !g_context.keyInput[key]; }

Matrix4x4 Multiply(const Matrix4x4& a, const Matrix4x4& b)

{

Matrix4x4 result;

for (int i = 0; i < 4; ++i)

{

for (int j = 0; j < 4; ++j)

{

result.m[i][j] = a.m[i][0] * b.m[0][j] +

a.m[i][1] * b.m[1][j] +

a.m[i][2] * b.m[2][j] +

a.m[i][3] * b.m[3][j];

}

return result;

}

Matrix4x4 Invert(const Matrix4x4& mat)

{

Matrix4x4 inv;

float det = 0.0f;

for (int i = 0; i < 4; ++i)

{

for (int j = 0; j < 4; ++j)

{

inv.m[i][j] = mat.m[j][i];

}

det = mat.m[0][0] * inv.m[1][1] * inv.m[2][2] * inv.m[3][3] +

mat.m[0][1] * inv.m[1][2] * inv.m[2][3] * inv.m[3][0] +

mat.m[0][2] * inv.m[1][3] * inv.m[2][0] * inv.m[3][1] +

mat.m[0][3] * inv.m[1][0] * inv.m[2][1] * inv.m[3][2];

return inv;

}

Matrix4x4 Transpose(const Matrix4x4& mat)

{

Matrix4x4 result;

for (int i = 0; i < 4; ++i)

{

for (int j = 0; j < 4; ++j)

result.m[i][j] = mat.m[j][i];

}

return result;

}

Vec4 TransformVector(const Matrix4x4& mat, const Vec4& vec)

{

Vec4 result;

result.x = mat.m[0][0] * vec.x + mat.m[0][1] * vec.y + mat.m[0][2] * vec.z + mat.m[0][3] * vec.w;

result.y = mat.m[1][0] * vec.x + mat.m[1][1] * vec.y + mat.m[1][2] * vec.z + mat.m[1][3] * vec.w;

result.z = mat.m[2][0] * vec.x + mat.m[2][1] * vec.y + mat.m[2][2] * vec.z + mat.m[2][3] * vec.w;

result.w = mat.m[3][0] * vec.x + mat.m[3][1] * vec.y + mat.m[3][2] * vec.z + mat.m[3][3] * vec.w;

return result;

}

Vec4 TransformVector(const Matrix4x4& mat, const Vec3& vec)

{

Vec4 result;

result.x = mat.m[0][0] * vec.x + mat.m[0][1] * vec.y + mat.m[0][2] * vec.z + mat.m[0][3] * 1.f;

result.y = mat.m[1][0] * vec.x + mat.m[1][1] * vec.y + mat.m[1][2] * vec.z + mat.m[1][3] * 1.f;

result.z = mat.m[2][0] * vec.x + mat.m[2][1] * vec.y + mat.m[2][2] * vec.z + mat.m[2][3] * 1.f;

result.w = mat.m[3][0] * vec.x + mat.m[3][1] * vec.y + mat.m[3][2] * vec.z + mat.m[3][3] * 1.f;

return result;

}

Matrix4x4 CreateWorld(const Vec3& translate, const Vec3& yawPitchRoll, const Vec3& scale)

{

Matrix4x4 world;

float cy = cos(yawPitchRoll.y);

float sy = sin(yawPitchRoll.y);

float cp = cos(yawPitchRoll.x);

float sp = sin(yawPitchRoll.x);

float cr = cos(yawPitchRoll.z);

float sr = sin(yawPitchRoll.z);

Matrix4x4 rotationYaw = {

cy, 0.0f, sy, 0.0f,

0.0f, 1.0f, 0.0f, 0.0f,

-sy, 0.0f, cy, 0.0f,

0.0f, 0.0f, 0.0f, 1.0f

};

Matrix4x4 rotationPitch = {

1.0f, 0.0f, 0.0f, 0.0f,

0.0f, cp, sp, 0.0f,

0.0f, -sp, cp, 0.0f,

0.0f, 0.0f, 0.0f, 1.0f

};

Matrix4x4 rotationRoll = {

cr, sr, 0.0f, 0.0f,

-sr, cr, 0.0f, 0.0f,

0.0f, 0.0f, 1.0f, 0.0f,

0.0f, 0.0f, 0.0f, 1.0f

};

Matrix4x4 rotation = Multiply(rotationYaw, Multiply(rotationPitch, rotationRoll));

world.m[0][0] = scale.x * rotation.m[0][0];

world.m[0][1] = scale.x * rotation.m[0][1];

world.m[0][2] = scale.x * rotation.m[0][2];

world.m[0][3] = translate.x;

world.m[1][0] = scale.y * rotation.m[1][0];

world.m[1][1] = scale.y * rotation.m[1][1];

world.m[1][2] = scale.y * rotation.m[1][2];

world.m[1][3] = translate.y;

world.m[2][0] = scale.z * rotation.m[2][0];

world.m[2][1] = scale.z * rotation.m[2][1];

world.m[2][2] = scale.z * rotation.m[2][2];

world.m[2][3] = translate.z;

world.m[3][0] = 0.0f;

world.m[3][1] = 0.0f;

world.m[3][2] = 0.0f;

world.m[3][3] = 1.0f;

return world;

}

Matrix4x4 CreateView(const Vec3& cameraPosition, const Vec3& lookDirection)

{

Vec3 zAxis = (lookDirection * -1.0f).Normalize();

Vec3 up = { 0.0f, 1.0f, 0.0f };

float dot = std::abs(up.Dot(zAxis));

if (dot > 0.999f)

{

up = { 0.0f, 0.0f, 1.0f };

if (std::abs(zAxis.Dot(up)) > 0.999f)

{

up = { 1.0f, 0.0f, 0.0f };

}

Vec3 xAxis = up.Cross(zAxis).Normalize();

Vec3 yAxis = zAxis.Cross(xAxis).Normalize();

Matrix4x4 view = {

xAxis.x, xAxis.y, xAxis.z, -xAxis.Dot(cameraPosition),

yAxis.x, yAxis.y, yAxis.z, -yAxis.Dot(cameraPosition),

zAxis.x, zAxis.y, zAxis.z, -zAxis.Dot(cameraPosition),

0.0f, 0.0f, 0.0f, 1.0f

};

return view;

}

Matrix4x4 CreateProjection(float fov, float aspect, float nearZ, float farZ)

{

float f = 1.0f / tanf(fov * 0.5f);

float rangeInv = 1.0f / (nearZ - farZ);

Matrix4x4 projection = {

f / aspect, 0.0f, 0.0f, 0.0f,

0.0f, f, 0.0f, 0.0f,

0.0f, 0.0f, (nearZ + farZ) * rangeInv, -1.0f,

0.0f, 0.0f, (2 * nearZ * farZ) * rangeInv, 0.0f

};

return projection;

}

void SetVertexShader(PSInput(*vertexShader)(const Vertex&))

{

g_context.vertexShader = vertexShader;

}

void SetPixelShader(GrayScale(*pixelShader)(const PSInput&))

{

g_context.pixelShader = pixelShader;

}

void Render(const Vertex* vertices, uint32_t vertexCount,

const uint32_t* indices, uint32_t indexCount)

{

assert(g_context.vertexShader && "Vertex shader not set");

assert(g_context.pixelShader && "Pixel shader not set");

std::vector<PSInput> rasterizerInput;

rasterizerInput.reserve(vertexCount);

// vertex shader

for (uint32_t i = 0; i < vertexCount; i++)

{

Vertex vertex = vertices[i];

PSInput psInput = g_context.vertexShader(vertex);

// perspective divide

psInput.posH.x /= psInput.posH.w;

psInput.posH.y /= psInput.posH.w;

psInput.posH.z /= psInput.posH.w;

psInput.posH.w = 1.0f;

// viewport transformation

psInput.posH.x = (psInput.posH.x + 1.0f) * 0.5f * g_context.frontBuffer.width;

psInput.posH.y = (-psInput.posH.y + 1.0f) * 0.5f * g_context.frontBuffer.height;

rasterizerInput.emplace_back(psInput);

}

// rasterization

for (size_t i = 0; i < indexCount / 3; ++i)

{

PSInput psInput1 = rasterizerInput[indices[i * 3]];

PSInput psInput2 = rasterizerInput[indices[i * 3 + 1]];

PSInput psInput3 = rasterizerInput[indices[i * 3 + 2]];

// back face culling

Vec3 edge1 = psInput2.posW - psInput1.posW;

Vec3 edge2 = psInput3.posW - psInput1.posW;

Vec3 normal = edge2.Cross(edge1);

if (normal.z > 0.0f)

continue;

// bounding box

int minX = std::min({ psInput1.posH.x, psInput2.posH.x, psInput3.posH.x });

int maxX = std::max({ psInput1.posH.x, psInput2.posH.x, psInput3.posH.x });

int minY = std::min({ psInput1.posH.y, psInput2.posH.y, psInput3.posH.y });

int maxY = std::max({ psInput1.posH.y, psInput2.posH.y, psInput3.posH.y });

minX = std::max(minX, 0);

maxX = std::min(maxX, static_cast<int>(g_context.frontBuffer.width) - 1);

minY = std::max(minY, 0);

maxY = std::min(maxY, static_cast<int>(g_context.frontBuffer.height) - 1);

// triangle rasterization

for (int y = minY; y <= maxY; ++y)

{

for (int x = minX; x <= maxX; ++x)

{

// barycentric coordinates

float alpha = ((psInput2.posH.y - psInput3.posH.y) * (x - psInput3.posH.x) +

(psInput3.posH.x - psInput2.posH.x) * (y - psInput3.posH.y)) /

((psInput2.posH.y - psInput3.posH.y) * (psInput1.posH.x - psInput3.posH.x) +

(psInput3.posH.x - psInput2.posH.x) * (psInput1.posH.y - psInput3.posH.y));

float beta = ((psInput3.posH.y - psInput1.posH.y) * (x - psInput3.posH.x) +

(psInput1.posH.x - psInput3.posH.x) * (y - psInput3.posH.y)) /

((psInput2.posH.y - psInput3.posH.y) * (psInput1.posH.x - psInput3.posH.x) +

(psInput3.posH.x - psInput2.posH.x) * (psInput1.posH.y - psInput3.posH.y));

float gamma = 1.0f - alpha - beta;

if (alpha >= 0 && beta >= 0 && gamma >= 0)

{

// interpolate color

uint8_t color = static_cast<uint8_t>(alpha * psInput1.color.scale +

beta * psInput2.color.scale +

gamma * psInput3.color.scale);

float z = alpha * psInput1.posH.z +

beta * psInput2.posH.z +

gamma * psInput3.posH.z;

if (!DepthTest(z, x, y))

continue;

PSInput input;

input.posH.x = x;

input.posH.y = y;

input.posH.z = z;

input.posH.w = 1.0f;

input.color.scale = color;

input.normal = psInput1.normal * alpha +

psInput2.normal * beta +

psInput3.normal * gamma;

input.posW = psInput1.posW * alpha +

psInput2.posW * beta +

psInput3.posW * gamma;

// pixel shader

GrayScale output = g_context.pixelShader(input);

uint8_t grayScale = output.scale * 255.f;

DrawPixel(&g_context.frontBuffer, x, y, grayScale);

}

//////////////////////////////////////////////////////////////////////////

// cube

Vertex vertices[36] = {

// front

{ { -1.f, -1.f, 1.f }, { 0.0f, 0.0f, 1.0f }, { 1.f } },

{ { 1.f, -1.f, 1.f }, { 0.0f, 0.0f, 1.0f }, { 1.f } },

{ { 1.f, 1.f, 1.f }, { 0.0f, 0.0f, 1.0f }, { 1.f } },

{ { -1.f, 1.f, 1.f }, { 0.0f, 0.0f, 1.0f }, { 1.f } },

// right

{ { 1.f, -1.f, 1.f }, { 1.0f, 0.0f, 0.0f }, { 1.f } },

{ { 1.f, -1.f, -1.f }, { 1.0f, 0.0f, 0.0f }, { 1.f } },

{ { 1.f, 1.f, -1.f }, { 1.0f, 0.0f, 0.0f }, { 1.f } },

{ { 1.f, 1.f, 1.f }, { 1.0f, 0.0f, 0.0f }, { 1.f } },

// top

{ { -1.f, 1.f, 1.f }, { 0.0f, 1.0f, 0.0f }, { 1.f } },

{ { 1.f, 1.f, 1.f }, { 0.0f, 1.0f, 0.0f }, { 1.f } },

{ { 1.f, 1.f, -1.f }, { 0.0f, 1.0f, 0.0f }, { 1.f } },

{ { -1.f, 1.f, -1.f }, { 0.0f, 1.0f, 0.0f }, { 1.f } },

// back

{ { 1.f, -1.f, -1.f }, { 0.0f, 0.0f, -1.0f }, { 1.f } },

{ { -1.f, -1.f, -1.f }, { 0.0f, 0.0f, -1.0f }, { 1.f } },

{ { -1.f, 1.f, -1.f }, { 0.0f, 0.0f, -1.0f }, { 1.f } },

{ { 1.f, 1.f, -1.f }, { 0.0f, 0.0f, -1.0f }, { 1.f } },

// left

{ { -1.f, -1.f, -1.f }, { -1.0f, 0.0f, 0.0f }, { 1.f } },

{ { -1.f, -1.f, 1.f }, { -1.0f, 0.0f, 0.0f }, { 1.f } },

{ { -1.f, 1.f, 1.f }, { -1.0f, 0.0f, 0.0f }, { 1.f } },

{ { -1.f, 1.f, -1.f }, { -1.0f, 0.0f, 0.0f }, { 1.f } },

// bottom

{ { -1.f, -1.f, -1.f }, { 0.0f, -1.0f, 0.0f }, { 1.f } },

{ { 1.f, -1.f, -1.f }, { 0.0f, -1.0f, 0.0f }, { 1.f } },

{ { 1.f, -1.f, 1.f }, { 0.0f, -1.0f, 0.0f }, { 1.f } },

{ { -1.f, -1.f, 1.f }, { 0.0f, -1.0f, 0.0f }, { 1.f } }

};

uint32_t indices[36] = {

0, 1, 2, 0, 2, 3,

4, 5, 6, 4, 6, 7,

8, 9, 10, 8, 10, 11,

12, 13, 14, 12, 14, 15,

16, 17, 18, 16, 18, 19,

20, 21, 22, 20, 22, 23

};

struct Transform

{

Vec3 translate;

Vec3 yawPitchRoll;

Vec3 scale;

} g_transform = { { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f } };

Transform g_cameraTransform = { { 0.0f, 0.0f, 15.f }, { 0.0f, 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f } };

struct Uniforms

{

Matrix4x4 worldMatrix;

Matrix4x4 worldInverseTransposeMatrix;

Matrix4x4 viewMatrix;

Matrix4x4 projectionMatrix;

Vec3 lightPosition;

Vec3 cameraPosition;

} g_uniforms;

PSInput VertexShader(const Vertex& vertex)

{

Vec3 posW = TransformVector(g_uniforms.worldMatrix, vertex.posL).ToVec3();

Vec3 normalW = TransformVector(g_uniforms.worldInverseTransposeMatrix, vertex.normal).ToVec3();

Matrix4x4 projViewMatrix = Multiply(g_uniforms.projectionMatrix, g_uniforms.viewMatrix);

Vec4 posP = TransformVector(projViewMatrix, posW);

PSInput input;

input.posH = posP;

input.posW = posW;

input.normal = normalW;

input.color = vertex.color;

return input;

}

GrayScale PixelShader(const PSInput& input)

{

GrayScale output;

Vec3 normal = input.normal.Normalize();

Vec3 lightDir = (g_uniforms.lightPosition - input.posW).Normalize();

Vec3 toEye = (g_uniforms.cameraPosition - input.posW).Normalize();

Vec3 halfVector = (lightDir + toEye).Normalize();

float diffuse = std::max(normal.Dot(lightDir), 0.0f);

float ambient = 0.2f;

output.scale = ambient + diffuse;

output.scale = std::max(output.scale, 0.0f);

output.scale = std::min(output.scale, 1.0f);

return output;

}

int main()

{

InitContext(240, 80);

g_uniforms.lightPosition = { 5.0f, 5.0f, 5.0f };

SetVertexShader(VertexShader);

SetPixelShader(PixelShader);

while (true)

{

UpdateInput();

UpdateTimer();

if (IsKeyDown(VK_ESCAPE))

break;

ClearScreenBuffer(&g_context.frontBuffer, 0);

ClearDepthBuffer(&g_context.frontBuffer, 0.f);

// Translate

if (IsKeyDown(VK_LEFT))

g_transform.translate.x -= 1.0f * g_context.deltaTime;

if (IsKeyDown(VK_RIGHT))

g_transform.translate.x += 1.0f * g_context.deltaTime;

if (IsKeyDown(VK_UP))

g_transform.translate.y += 1.0f * g_context.deltaTime;

if (IsKeyDown(VK_DOWN))

g_transform.translate.y -= 1.0f * g_context.deltaTime;

// Rotate

if (IsKeyDown('A'))

g_transform.yawPitchRoll.y -= 1.0f * g_context.deltaTime;

if (IsKeyDown('D'))

g_transform.yawPitchRoll.y += 1.0f * g_context.deltaTime;

if (IsKeyDown('W'))

g_transform.yawPitchRoll.x -= 1.0f * g_context.deltaTime;

if (IsKeyDown('S'))

g_transform.yawPitchRoll.x += 1.0f * g_context.deltaTime;

// Scale

if (IsKeyDown('Q'))

{

g_transform.scale.x -= 1.0f * g_context.deltaTime;

g_transform.scale.y -= 1.0f * g_context.deltaTime;

}

if (IsKeyDown('E'))

{

g_transform.scale.x += 1.0f * g_context.deltaTime;

g_transform.scale.y += 1.0f * g_context.deltaTime;

}

// camera position

if (IsKeyDown('Z'))

g_cameraTransform.translate.z -= 1.0f * g_context.deltaTime;

if (IsKeyDown('X'))

g_cameraTransform.translate.z += 1.0f * g_context.deltaTime;

// light position

if (IsKeyDown('I'))

g_uniforms.lightPosition.z -= 1.0f * g_context.deltaTime;

if (IsKeyDown('K'))

g_uniforms.lightPosition.z += 1.0f * g_context.deltaTime;

if (IsKeyDown('J'))

g_uniforms.lightPosition.x -= 1.0f * g_context.deltaTime;

if (IsKeyDown('L'))

g_uniforms.lightPosition.x += 1.0f * g_context.deltaTime;

if (IsKeyDown('U'))

g_uniforms.lightPosition.y -= 1.0f * g_context.deltaTime;

if (IsKeyDown('O'))

g_uniforms.lightPosition.y += 1.0f * g_context.deltaTime;

g_uniforms.worldMatrix = CreateWorld(g_transform.translate, g_transform.yawPitchRoll, g_transform.scale);

g_uniforms.worldInverseTransposeMatrix = Invert(Transpose(g_uniforms.worldMatrix));

g_uniforms.viewMatrix = CreateView(g_cameraTransform.translate, { 0.0f, 0.0f, -1.0f });

g_uniforms.projectionMatrix = CreateProjection(DEG2RAD(60.f),

1.66f, 0.1f, 100.f);

g_uniforms.cameraPosition = g_cameraTransform.translate;

Render(vertices, std::size(vertices), indices, std::size(indices));

PresentToConsole(&g_context.frontBuffer);

}

ReleaseContext();

}

Screen Space Ambient Occulusion

파워꽃게맨 — Mon, 14 Apr 2025 13:15:05 +0900

그렇게 눈에 띄는 효과는 아니지만

없으면 허전한게 앰비언트 오클루전 인 것 같습니다.

반구형 오프셋 커널을 만들어서

현재 픽셀을 일정 오프셋만큼 이동시켜줍니다.

그 다음 해당 픽셀의 깊이와 뎁스 버퍼에 저장된 깊이를 비교하여

뎁스 버퍼에 저장된 깊이가 더 얕다면 오클루전 팩터에 1씩 더합니다.

이것은 현재 픽셀 주변에 나를 가리는 차폐체가 있다는 것을 의미합니다.

그렇게 게산하면

이 장면에서

이렇게 차폐 정도를 계산할 수 있습니다.

이걸 라이팅 과정에서 앰비언트 부분에 곱해주면 SSAO 완성입니다.

좌: AO 가 적용되지 않음

우: AO 가 적용됨

차이가 좀 있는지요..?

제 눈에는 조금 납니다

좌: AO 가 적용되지 않음

우: AO 가 적용됨

현재는 샘플링수가 64, 노이즈의 크기는 4입니다. 꽤나 고품질이죠.

잘보면 AO 텍스처에 아티펙터같은게 있습니다.

블러링을 시도해봤습니다.

블러링을 해주면 아티펙트는 확실히 사라지는데 경계가 생깁니다.

다른 블러를 사용해야겠습니다.

저는 Separable Bilateral Blur 라는 블러를 사용해봤습니다.

기본적으로 가우시안 블러를 사용하는데, 픽셀 간의 깊이 차이를 고려하여 경계부분은 블러처리가 되지 않습니다.

블러가 없을 때

블러가 있을 때

격자 무늬가 사라진 것으로 만족입니다.

블러가 없을 때

블러가 있을 때

확실히 깔끔해진 모양

우려하던 경계 현상도 없어졌습니다.

라이트 볼륨을 이용한 대규모 라이팅

파워꽃게맨 — Sun, 13 Apr 2025 01:41:23 +0900

(그림자를 만들어내지 않는..) 빛 무려 1000개를 렌더링해도 60 프레임 유지!

라이트매핑 테스트 (Light Map)

파워꽃게맨 — Fri, 11 Apr 2025 03:08:20 +0900

조금 어둡네요 Direct Light 와 합치면 꽤나 자연스러울 것 같습니다.

숲 환경에서 렌더링하니까 매우 자연스럽습니다.

가장 보기 좋네요

퐁 모델 기반이라 그런지

PBR 과는 잘 안어울리는 것 같습니다.

쉐이더를 바꿔주거나, IBL 적용을 disable 시켜주면 훨 씬 자연스러울듯합니다.

대규모 모델 로딩 테스트

파워꽃게맨 — Mon, 7 Apr 2025 16:50:47 +0900

FlatBuffers 를 이용한 모델 로딩 최적화

파워꽃게맨 — Sat, 5 Apr 2025 13:16:05 +0900

3D 모델을 로딩한다고 하면 일반적으로 assimp를 이용해 fbx나 obj 파일을 로딩합니다.

fbx obj 의 경우 내부 데이터가 굉장히 복잡하기 떄문에 로딩하는데 다소 시간이 걸립니다.

만약 소프트웨어에서 필요한 데이터만 로딩할 수 있따면 로딩하는 시간이 훨씬 줄어듭니다.

먼저 fbx 파일을 로딩하는데 걸리는 시간을 보겠습니다.

드래곤 모델을 로딩하는데 1.586초가 소모되었습니다.

참고로 해당 모델은 약 114000 개 가량의 버텍스와 인덱스를 가지고 있습니다.

최초에는 Josn을 이용하여 버텍스(위치, 법선, 탄젠트, 비탄젠트, uv, 노말) 과 머테리얼 속성 (PBR 및 Phong, 텍스처 경로)를 저장했는데, 커스텀 타입의 저장 및 불러오기 시간이 과하게 많이 걸렸습니다. (파일 크기도 크구요)

그래서 선택한 것이 바이너리로 데이터를 저장하는 것이었습니다.

그 과정에서 사용한 것은 구글의 FlatBuffers 라는 라이브러리입니다.

https://github.com/google/flatbuffers

GitHub - google/flatbuffers: FlatBuffers: Memory Efficient Serialization Library

FlatBuffers: Memory Efficient Serialization Library - google/flatbuffers

github.com

이런 식으로 데이터 스키마를 정의한 다음에

열심히 exporter와 importer를 만들어줍니다.

결과입니다.

export 는 0.124초

import 는 0.109초 걸렸습니다.

기존 방법과 비교하면

1.586 -> 0.109

14.5배 가량 빨라졌습니다.

조금 더 큰 모델을 대상으로 진행해보겠습니다.

로드하는데 6초정도 걸리는 모델을 임포트해봤는데요

이 모델을 바이너리 방식으로 변환후 입력받으면..

익스포트에 0.736초

임포트에 0.68초 걸립니다.

Fast Approximate Anti-Aliasing

파워꽃게맨 — Wed, 2 Apr 2025 02:37:09 +0900

결과 먼저 확인하겠습니다.

1: X

2: 품질 중

3: 품질 상

참고 문헌

https://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf

FXAA는 준수한 성능을 보이면서 매우 성능이 좋은 안티에일리어싱 기법입니다.

FXAA는 LDR로 변환된 후의 디스플레이용 sRGB 색 공간에 적용하라고 합니다. 즉 HDR -> LDR의 톤매핑 적용 후 이미지필터처럼 적용하는 것이지요

HDR 이미지에 바로 FXAA를 적용하면 제대로 적용되지 않는다고 합니다.

아무래도 FXAA는 광도와 휘도를 이용하는 알고리즘에다가 [0, 1] 범위에서 동작하는 것을 전제로하기에 [0, ~] 의 범위를 가지는 HDR에서는 안티에일리어싱이 적용되지 않은 것과 유사하다고 합니다.

안티앨리어싱의 원리는 다음과 같습니다.

1. RGB 색상 데이터를 입력으로 받아 밝기 추정값으로 변환하고

2. FXAA는 지역적인 영역의 대비를 확인해서 엣지를 감지합니다.

3. 엣지를 수평성분과 수직 성분으로 분류합니다.

4. 엣지의 방향을 이용하여 대비가 가장 높은 픽셀만 선별합니다.

5. 엣지의 끝을 기준으로 엣지의 오프셋을 계산합니다. 이 오프셋을 통해서 입력 텍스처를 다시 샘플링합니다.

있는 것과 없는 것은 차이가 좀 큽니다. (??)

제 눈에는 예.. 좀 큽니다 ^^!

2D 이미지는 몰라도

확실히 3D 이미지는 안티 앨리어싱이 적용된것이 훨씬 그럴듯해보입니다.

Deferred Rendering + PBR

파워꽃게맨 — Tue, 1 Apr 2025 13:05:22 +0900

잘 나와서 기쁘네요

근데 잘보면

MSAA를 사용하지 않아서 다소 끝처리가 아쉽습니다.

직접 안티에일리어싱을 해줘야하는데

관련 코드는 바로 작성해보겠습니다.

개발하는 리프터 꽃게맨입니다.

effective C++ - bad_alloc 에 대비하는 방법

Jam Engine 1차 개발 보고서

서론

목차

1. 개발환경

2. 메모리 관리

고정길이 메모리 풀

참조 카운트 기반 포인터

3. 레이어 기반 어플리케이션 루프

레이어 시스템

레이어 간의 통신

4. Entity Component System

5. 렌더링

Built-in 쉐이더

Physical Based Rendering

Post Process

Lighting

Shadow

Screen Space Ambient Occlusion

Pre Baked Texturing

앞으로 남은 과제

리소스

에셋 매니저

모델 최적화

직렬화

씬 데이터 직렬화

GUI 기반 에디팅 시스템

빌드 시스템

앞으로 남은 과제

뻘짓) 콘솔로 래스터라이제이션 기반 큐브 렌더링하기

Screen Space Ambient Occulusion

라이트 볼륨을 이용한 대규모 라이팅

라이트매핑 테스트 (Light Map)

대규모 모델 로딩 테스트

FlatBuffers 를 이용한 모델 로딩 최적화

Fast Approximate Anti-Aliasing

Deferred Rendering + PBR