MENU
  1. ホーム
  2. C++
  3. C와 Vulkan으로 고성능 그래픽 렌더링 엔진 구축하기

C와 Vulkan으로 고성능 그래픽 렌더링 엔진 구축하기

C++

C 언어와 Vulkan API를 활용하여 고성능 그래픽 렌더링 엔진을 구축하는 방법을 소개합니다.

컴퓨터 그래픽스는 게임 개발, 시뮬레이션, 가상 현실(VR) 등 다양한 분야에서 필수적인 요소입니다. 기존의 OpenGL이나 DirectX에 비해 Vulkan API는 보다 저수준 접근 방식을 제공하여, 그래픽 하드웨어의 성능을 최대로 활용할 수 있도록 설계되었습니다.

본 기사에서는 C 언어와 Vulkan API를 활용하여 효율적인 그래픽 렌더링 엔진을 구축하는 방법을 설명합니다. Vulkan API의 기초 개념부터 시작하여, 그래픽 파이프라인 구성, 메모리 관리, 셰이더 활용, 그리고 성능 최적화 방법까지 단계별로 다룰 것입니다.

이제 Vulkan의 기본 개념부터 살펴보겠습니다.

Vulkan API 개요 및 그래픽 렌더링의 기초

Vulkan API란?

Vulkan API는 차세대 그래픽 및 컴퓨팅 애플리케이션을 위한 저수준(low-level) 그래픽 API입니다. OpenGL과 같은 기존 API보다 하드웨어에 대한 직접적인 제어가 가능하며, 고성능, 멀티스레드 렌더링 지원, 낮은 CPU 오버헤드 등의 장점이 있습니다.

Vulkan과 OpenGL의 차이점

특징VulkanOpenGL
API 수준저수준(Low-level)고수준(High-level)
멀티스레드지원 (최적화 가능)제한적
드라이버 오버헤드낮음높음
성능높은 성능 및 효율성일반적인 성능
플랫폼 지원Windows, Linux, Android 등Windows, macOS, Linux 등

Vulkan은 기존의 OpenGL과 달리 하드웨어 리소스를 직접 관리해야 하므로 복잡하지만, 최적화된 그래픽 성능을 제공할 수 있습니다.

그래픽 렌더링 엔진의 기본 원리

Vulkan을 활용한 그래픽 렌더링 엔진은 기본적으로 3D 장면을 GPU를 통해 화면에 출력하는 과정을 담당합니다. 주요 과정은 다음과 같습니다.

  1. 장면 데이터 준비: 3D 모델, 텍스처, 셰이더 등을 로드
  2. 그래픽 파이프라인 설정: 렌더링할 객체의 파이프라인을 구성
  3. 커맨드 버퍼 실행: GPU에 명령을 보내 렌더링 수행
  4. 화면 출력: 프레임 버퍼를 교체하여 최종 이미지 출력

이제 다음 단계로 Vulkan을 사용하기 위한 개발 환경을 설정하는 방법을 살펴보겠습니다.

Vulkan 개발 환경 설정 및 프로젝트 시작

1. Vulkan SDK 설치

Vulkan을 사용하려면 먼저 Vulkan SDK를 설치해야 합니다. Vulkan SDK는 Khronos Group에서 제공하며, 그래픽 프로그래밍에 필요한 라이브러리와 도구를 포함하고 있습니다.

Windows 환경에서 Vulkan SDK 설치
  1. LunarG의 Vulkan SDK 다운로드 페이지에서 최신 버전을 다운로드합니다.
  2. 설치 후 환경 변수를 자동으로 설정하도록 옵션을 선택합니다.
  3. VulkanInfo 유틸리티를 실행하여 Vulkan이 정상적으로 설치되었는지 확인합니다.
   vulkaninfo
  1. glslangValidator 명령어를 실행하여 GLSL 셰이더 컴파일러가 정상적으로 작동하는지 확인합니다.
   glslangValidator --version
Linux 환경에서 Vulkan SDK 설치
  1. 패키지 매니저를 사용하여 Vulkan 라이브러리를 설치합니다.
   sudo apt install vulkan-sdk
  1. Vulkan이 정상적으로 설치되었는지 vulkaninfo 명령으로 확인합니다.

2. C 기반 Vulkan 프로젝트 설정

C로 Vulkan 애플리케이션을 개발하려면 다음과 같은 라이브러리와 헤더 파일이 필요합니다.

필수 라이브러리 및 헤더
  • vulkan/vulkan.h (Vulkan API 헤더)
  • libvulkan.so 또는 vulkan-1.lib (Vulkan 런타임 라이브러리)
  • glfw (윈도우 생성 및 이벤트 처리용 라이브러리, 선택 사항)
CMake를 사용한 프로젝트 설정

CMake를 이용하여 Vulkan 프로젝트를 쉽게 구성할 수 있습니다.

  1. CMakeLists.txt 파일 생성
   cmake_minimum_required(VERSION 3.10)
   project(VulkanApp C)

   find_package(Vulkan REQUIRED)

   add_executable(VulkanApp main.c)
   target_link_libraries(VulkanApp Vulkan::Vulkan)
  1. 프로젝트 빌드
   mkdir build
   cd build
   cmake ..
   make
GCC를 사용한 수동 빌드 (Linux)

만약 CMake 없이 직접 빌드하려면 다음과 같이 컴파일할 수 있습니다.

gcc main.c -o VulkanApp -lvulkan

3. 기본 프로젝트 구조

프로젝트를 구성할 때 일반적으로 다음과 같은 디렉토리 구조를 사용합니다.

/VulkanApp
 ├── src/
 │   ├── main.c
 │   ├── renderer.c
 │   └── renderer.h
 ├── shaders/
 │   ├── vertex_shader.glsl
 │   ├── fragment_shader.glsl
 ├── CMakeLists.txt
 ├── README.md
 ├── build/

이제 Vulkan API의 핵심 개념을 알아보겠습니다.

Vulkan의 기본 개념: 인스턴스, 장치, 큐

Vulkan은 저수준 그래픽 API로, 하드웨어와 직접 상호작용하여 높은 성능을 제공합니다. Vulkan을 효과적으로 사용하려면 인스턴스, 논리적 장치, 큐 패밀리 등의 개념을 이해해야 합니다.

1. Vulkan 인스턴스 (Instance)

Vulkan API를 사용하려면 먼저 Vulkan 인스턴스를 생성해야 합니다.
인스턴스는 Vulkan 애플리케이션과 드라이버 간의 연결을 설정하는 역할을 합니다.

Vulkan 인스턴스 생성 코드 예제 (C)
VkInstance instance;
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

if (vkCreateInstance(&createInfo, NULL, &instance) != VK_SUCCESS) {
    printf("Vulkan 인스턴스 생성 실패!\n");
}

위 코드는 vkCreateInstance 함수를 사용하여 Vulkan 인스턴스를 생성하는 과정입니다.

2. 물리적 장치 (Physical Device)

Vulkan에서는 여러 개의 GPU를 사용할 수 있습니다.
각 GPU를 물리적 장치(Physical Device) 라고 하며, Vulkan API를 통해 사용 가능한 GPU를 검색할 수 있습니다.

사용 가능한 물리적 장치 나열하기
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, NULL);
VkPhysicalDevice devices[deviceCount];
vkEnumeratePhysicalDevices(instance, &deviceCount, devices);

printf("사용 가능한 GPU 개수: %d\n", deviceCount);

위 코드는 시스템에서 Vulkan을 지원하는 GPU 개수를 확인하는 과정입니다.

3. 논리적 장치 (Logical Device)

Vulkan은 직접 GPU를 제어하지 않고, 논리적 장치(Logical Device) 를 생성하여 사용합니다.
논리적 장치는 특정 GPU를 활용하기 위한 핸들 역할을 하며, 응용 프로그램이 GPU 리소스를 관리할 수 있도록 합니다.

논리적 장치 생성 코드
VkDevice device;
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

if (vkCreateDevice(devices[0], &deviceCreateInfo, NULL, &device) != VK_SUCCESS) {
    printf("논리적 장치 생성 실패!\n");
}

위 코드는 vkCreateDevice 함수를 이용해 논리적 장치를 생성하는 과정입니다.

4. 큐 패밀리 (Queue Family)

GPU는 여러 개의 큐(Queue) 를 가지고 있으며, 각 큐는 특정한 작업을 수행합니다.
Vulkan에서는 큐 패밀리를 통해 그래픽 처리용 큐와 연산 작업용 큐를 분리하여 사용할 수 있습니다.

큐 패밀리 검색 코드
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(devices[0], &queueFamilyCount, NULL);
VkQueueFamilyProperties queueFamilies[queueFamilyCount];
vkGetPhysicalDeviceQueueFamilyProperties(devices[0], &queueFamilyCount, queueFamilies);

printf("큐 패밀리 개수: %d\n", queueFamilyCount);

위 코드는 Vulkan에서 지원하는 큐 패밀리 개수를 출력하는 코드입니다.

5. 큐 생성 및 사용

큐는 논리적 장치와 함께 생성되며, 그래픽 렌더링을 수행하는 중요한 역할을 합니다.

VkQueue graphicsQueue;
vkGetDeviceQueue(device, 0, 0, &graphicsQueue);

위 코드는 논리적 장치에서 그래픽 처리용 큐를 가져오는 코드입니다.

정리

  • Vulkan 인스턴스: Vulkan API를 초기화하는 첫 번째 단계
  • 물리적 장치: Vulkan을 지원하는 GPU 목록 확인
  • 논리적 장치: GPU를 활용하기 위해 생성하는 가상 장치
  • 큐 패밀리: 특정 작업(그래픽, 연산 등)을 처리하는 GPU 큐

이제 Vulkan의 그래픽 파이프라인 구성 방법을 살펴보겠습니다.

Vulkan의 그래픽 파이프라인 구성하기

Vulkan에서 그래픽 파이프라인(Graphics Pipeline) 은 렌더링을 수행하는 핵심 구조입니다. 기존 OpenGL과 달리, Vulkan에서는 파이프라인을 사전 정의 해야 하며, 실행 중 변경할 수 없습니다. 따라서 적절한 파이프라인 구성 및 최적화 가 중요합니다.

1. 그래픽 파이프라인의 개념

그래픽 파이프라인은 입력 데이터를 받아 최종적으로 화면에 픽셀을 출력하는 과정입니다.
Vulkan에서의 그래픽 파이프라인 주요 단계는 다음과 같습니다.

Vulkan 그래픽 파이프라인 흐름

  1. 입력 어셈블러(Input Assembler)
  • 정점 데이터를 수집하여 그래픽 파이프라인에 전달
  1. 버텍스 셰이더(Vertex Shader)
  • 정점 데이터를 변환하고 좌표 연산 수행
  1. 테셀레이션(Tessellation, 선택적)
  • 고해상도 모델을 위해 정점 분할 수행
  1. 지오메트리 셰이더(Geometry Shader, 선택적)
  • 정점 그룹을 추가 변형
  1. 래스터라이제이션(Rasterization)
  • 3D 공간의 정점 데이터를 2D 화면 좌표로 변환
  1. 프래그먼트 셰이더(Fragment Shader)
  • 각 픽셀의 색상을 계산
  1. 색 혼합 및 출력(Color Blending & Output)
  • 최종 픽셀을 화면에 렌더링

2. 그래픽 파이프라인 생성 과정

① 셰이더 로딩

Vulkan은 GLSL이 아닌 SPIR-V 바이너리 셰이더 를 사용합니다.

VkShaderModuleCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = shaderSize;
createInfo.pCode = (uint32_t*)shaderCode;

VkShaderModule shaderModule;
vkCreateShaderModule(device, &createInfo, NULL, &shaderModule);

위 코드는 SPIR-V 셰이더를 Vulkan의 VkShaderModule 로 로드하는 과정입니다.

② 렌더 패스(Render Pass) 설정

렌더 패스는 여러 개의 프레임 버퍼 를 처리하기 위한 개념으로, 특정한 그래픽 연산을 정의합니다.

VkAttachmentDescription colorAttachment = {};
colorAttachment.format = VK_FORMAT_B8G8R8A8_SRGB;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;

VkRenderPassCreateInfo renderPassInfo = {};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;

VkRenderPass renderPass;
vkCreateRenderPass(device, &renderPassInfo, NULL, &renderPass);

위 코드는 컬러 버퍼를 포함하는 기본 렌더 패스 를 생성하는 과정입니다.

③ 그래픽 파이프라인 설정

Vulkan에서는 파이프라인 레이아웃(Pipeline Layout) 을 미리 정의해야 합니다.

VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;

VkPipelineLayout pipelineLayout;
vkCreatePipelineLayout(device, &pipelineLayoutInfo, NULL, &pipelineLayout);

위 코드는 그래픽 파이프라인의 구조를 정의 하는 과정입니다.

④ 그래픽 파이프라인 생성

모든 설정이 완료되면 Vulkan의 그래픽 파이프라인을 생성할 수 있습니다.

VkGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = 2;
pipelineInfo.pStages = shaderStages;
pipelineInfo.pVertexInputState = &vertexInputInfo;
pipelineInfo.pInputAssemblyState = &inputAssembly;
pipelineInfo.pViewportState = &viewportState;
pipelineInfo.pRasterizationState = &rasterizer;
pipelineInfo.pMultisampleState = &multisampling;
pipelineInfo.pDepthStencilState = NULL;
pipelineInfo.pColorBlendState = &colorBlending;
pipelineInfo.layout = pipelineLayout;
pipelineInfo.renderPass = renderPass;
pipelineInfo.subpass = 0;

VkPipeline graphicsPipeline;
vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, NULL, &graphicsPipeline);

위 코드는 렌더링을 위한 그래픽 파이프라인을 생성 하는 과정입니다.

3. 그래픽 파이프라인의 핵심 요소 정리

요소설명
셰이더 모듈(Shader Module)SPIR-V 형식의 버텍스/프래그먼트 셰이더
렌더 패스(Render Pass)프레임 버퍼와 함께 렌더링 프로세스를 정의
파이프라인 레이아웃(Pipeline Layout)셰이더와 렌더 패스를 결합하는 구조
그래픽 파이프라인(Graphics Pipeline)최종적인 그래픽 연산 수행

이제 실제로 삼각형을 렌더링하는 코드 를 구현해 보겠습니다.

Vulkan을 활용한 삼각형 렌더링 구현

이제 Vulkan을 이용해 가장 기본적인 삼각형을 화면에 출력하는 코드를 작성해 보겠습니다. Vulkan에서는 OpenGL과 달리 많은 초기 설정이 필요하지만, 성능 최적화를 위한 강력한 제어권을 제공합니다.

1. 삼각형 렌더링 개요

Vulkan에서 삼각형을 렌더링하기 위해 필요한 주요 단계는 다음과 같습니다.

  1. 버텍스 데이터 정의 (삼각형의 정점 정보)
  2. 버텍스 버퍼 생성 (GPU에 정점 데이터 저장)
  3. 셰이더 작성 및 로드 (버텍스 및 프래그먼트 셰이더)
  4. 그래픽 파이프라인 설정 (렌더링 과정 정의)
  5. 드로우 콜 수행 (삼각형을 화면에 출력)

2. 삼각형의 정점(Vertex) 정의

삼각형을 정의하려면 3개의 정점 좌표 가 필요합니다.
Vulkan에서는 정점 버퍼(Vertex Buffer) 를 이용해 정점 데이터를 GPU에 저장합니다.

① 삼각형의 정점 데이터 정의

typedef struct {
    float position[2];
    float color[3];
} Vertex;

Vertex vertices[] = {
    {{ 0.0f, -0.5f}, {1.0f, 0.0f, 0.0f}},  // 아래쪽 정점 (빨강)
    {{ 0.5f,  0.5f}, {0.0f, 1.0f, 0.0f}},  // 오른쪽 정점 (초록)
    {{-0.5f,  0.5f}, {0.0f, 0.0f, 1.0f}},  // 왼쪽 정점 (파랑)
};

각 정점은 (x, y) 좌표와 RGB 색상 값을 포함합니다.

3. 버텍스 버퍼 생성

버텍스 데이터를 GPU에 업로드하기 위해 버텍스 버퍼(Vertex Buffer) 를 생성해야 합니다.

② Vulkan 버퍼 생성 코드

VkBuffer vertexBuffer;
VkBufferCreateInfo bufferInfo = {};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = sizeof(vertices);
bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;

vkCreateBuffer(device, &bufferInfo, NULL, &vertexBuffer);

위 코드는 버텍스 데이터를 저장할 버퍼를 생성하는 과정입니다.

4. 셰이더 작성 (GLSL) 및 컴파일

Vulkan에서는 SPIR-V 바이너리 셰이더 를 사용하므로, GLSL 코드를 먼저 작성한 후 컴파일해야 합니다.

③ 버텍스 셰이더 (vertex_shader.glsl)

#version 450
layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 0) out vec3 fragColor;

void main() {
    gl_Position = vec4(inPosition, 0.0, 1.0);
    fragColor = inColor;
}

④ 프래그먼트 셰이더 (fragment_shader.glsl)

#version 450
layout(location = 0) in vec3 fragColor;
layout(location = 0) out vec4 outColor;

void main() {
    outColor = vec4(fragColor, 1.0);
}

셰이더를 SPIR-V로 변환하려면 glslangValidator 를 사용합니다.

glslangValidator -V vertex_shader.glsl -o vertex_shader.spv
glslangValidator -V fragment_shader.glsl -o fragment_shader.spv

5. 그래픽 파이프라인 구성

셰이더를 로드한 후, 그래픽 파이프라인을 설정해야 합니다.

⑤ 파이프라인 설정 코드

VkPipelineShaderStageCreateInfo vertexShaderStageInfo = {};
vertexShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertexShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertexShaderStageInfo.module = vertexShaderModule;
vertexShaderStageInfo.pName = "main";

VkPipelineShaderStageCreateInfo fragmentShaderStageInfo = {};
fragmentShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragmentShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragmentShaderStageInfo.module = fragmentShaderModule;
fragmentShaderStageInfo.pName = "main";

VkPipelineShaderStageCreateInfo shaderStages[] = {vertexShaderStageInfo, fragmentShaderStageInfo};

위 코드는 버텍스 및 프래그먼트 셰이더를 Vulkan 파이프라인에 연결하는 과정입니다.

6. 삼각형 렌더링 수행

모든 설정이 완료되었으면 드로우 콜(Draw Call) 을 수행하여 삼각형을 화면에 출력합니다.

⑥ Vulkan 드로우 콜 코드

vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
VkBuffer vertexBuffers[] = {vertexBuffer};
VkDeviceSize offsets[] = {0};
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
vkCmdDraw(commandBuffer, 3, 1, 0, 0);

위 코드는 버텍스 버퍼를 바인딩하고, 삼각형을 화면에 그리는 과정입니다.

7. 실행 결과

위 과정을 수행하면 다음과 같이 빨강, 초록, 파랑으로 구성된 삼각형이 화면에 출력됩니다.

+-----------+
|           |
|   ▲       |
|  / \      |
| /___\     |
|           |
+-----------+

✔️ Vulkan이 성공적으로 설정되었다면, GPU 가속을 이용한 고성능 삼각형 렌더링이 완료됩니다.

정리

단계설명
정점 정의삼각형의 정점 데이터(위치 및 색상) 생성
버텍스 버퍼정점 데이터를 GPU에 저장
셰이더 작성GLSL을 이용한 버텍스 및 프래그먼트 셰이더 작성
파이프라인 구성셰이더, 렌더 패스, 그래픽 상태 설정
드로우 콜 실행Vulkan을 이용하여 삼각형을 렌더링

이제 Vulkan에서 메모리 관리 및 버퍼 활용 방법을 살펴보겠습니다.

Vulkan에서 메모리 관리 및 버퍼 활용

Vulkan은 다른 그래픽 API와 달리 메모리를 직접 관리해야 하므로, 효율적인 메모리 관리가 중요 합니다. 본 섹션에서는 Vulkan 메모리 모델, 버퍼 할당 및 최적화 기법을 설명합니다.

1. Vulkan의 메모리 모델

Vulkan에서 GPU 메모리는 크게 호스트(Host) 메모리 와 디바이스(Device) 메모리 로 나뉩니다.

메모리 유형설명
호스트 메모리CPU가 직접 접근할 수 있는 RAM
디바이스 메모리GPU가 사용하는 VRAM, 빠르지만 CPU 접근 불가
공유 메모리CPU와 GPU가 모두 접근 가능한 메모리 (일부 시스템에서 지원)

Vulkan에서는 버퍼(Buffer)와 이미지(Image) 를 생성한 후, 적절한 GPU 메모리에 할당해야 합니다.

2. Vulkan 버퍼(Buffer) 개념

버퍼 는 정점(Vertex), 인덱스(Index), 유니폼(Uniform) 데이터 등을 저장하는 객체입니다.
Vulkan에서는 VkBuffer 객체를 사용하여 GPU 메모리에 데이터를 저장합니다.

① Vulkan 버퍼 생성 코드

VkBufferCreateInfo bufferInfo = {};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = sizeof(vertices);
bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

VkBuffer vertexBuffer;
vkCreateBuffer(device, &bufferInfo, NULL, &vertexBuffer);

위 코드는 Vulkan에서 정점 데이터를 저장할 버퍼를 생성하는 과정입니다.

3. GPU 메모리 할당

Vulkan에서는 VkDeviceMemory 객체를 사용하여 메모리를 명시적으로 할당해야 합니다.

② 메모리 요구사항 조회

VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(device, vertexBuffer, &memRequirements);

위 코드는 버퍼에 필요한 메모리 크기 및 유형을 조회하는 과정입니다.

③ 적절한 메모리 유형 찾기

uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) {
    VkPhysicalDeviceMemoryProperties memProperties;
    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);

    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
        if ((typeFilter & (1 << i)) && 
            (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
            return i;
        }
    }
    return -1;
}

위 코드는 적절한 GPU 메모리 유형을 찾는 함수입니다.

④ 메모리 할당 및 바인딩

VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, 
                                           VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | 
                                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);

VkDeviceMemory vertexBufferMemory;
vkAllocateMemory(device, &allocInfo, NULL, &vertexBufferMemory);
vkBindBufferMemory(device, vertexBuffer, vertexBufferMemory, 0);

위 코드는 버퍼에 GPU 메모리를 할당하고 바인딩하는 과정입니다.

4. CPU에서 GPU로 데이터 전송 (메모리 매핑)

CPU 메모리에서 GPU 메모리로 데이터를 전송하려면 메모리 매핑(Memory Mapping) 이 필요합니다.

⑤ 버퍼 데이터를 GPU에 복사

void* data;
vkMapMemory(device, vertexBufferMemory, 0, bufferInfo.size, 0, &data);
memcpy(data, vertices, (size_t) bufferInfo.size);
vkUnmapMemory(device, vertexBufferMemory);

위 코드는 CPU에서 GPU로 데이터를 복사하는 과정입니다.

5. 버퍼 최적화 (전용 메모리 vs 공유 메모리)

Vulkan에서 GPU 성능을 극대화하려면, 데이터를 효율적으로 관리해야 합니다.

버퍼 유형사용 사례성능
호스트 가시적 메모리 (Host Visible)CPU에서 직접 접근할 때느림
디바이스 전용 메모리 (Device Local)GPU에서만 접근할 때빠름
호스트 코히런트 메모리 (Host Coherent)CPU-GPU 동기화 필요 시중간

✔️ GPU에서 자주 사용하는 데이터 (정점, 텍스처)는 “디바이스 전용 메모리”에 저장하는 것이 성능에 유리합니다.

6. Vulkan 버퍼 활용 예제 (정리)

아래는 Vulkan에서 버텍스 버퍼를 생성하고, 데이터를 GPU에 로드하는 전체 과정입니다.

// 1. 버퍼 생성
VkBuffer vertexBuffer;
VkBufferCreateInfo bufferInfo = {};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = sizeof(vertices);
bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
vkCreateBuffer(device, &bufferInfo, NULL, &vertexBuffer);

// 2. 메모리 요구사항 조회
VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(device, vertexBuffer, &memRequirements);

// 3. 메모리 할당
VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, 
                                           VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | 
                                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
VkDeviceMemory vertexBufferMemory;
vkAllocateMemory(device, &allocInfo, NULL, &vertexBufferMemory);

// 4. 버퍼에 메모리 바인딩
vkBindBufferMemory(device, vertexBuffer, vertexBufferMemory, 0);

// 5. CPU에서 GPU로 데이터 복사
void* data;
vkMapMemory(device, vertexBufferMemory, 0, bufferInfo.size, 0, &data);
memcpy(data, vertices, (size_t) bufferInfo.size);
vkUnmapMemory(device, vertexBufferMemory);

위 코드를 실행하면 정점 데이터가 GPU에 업로드되며, 이후 렌더링을 수행할 수 있습니다.

7. Vulkan 메모리 관리 최적화

Vulkan에서는 메모리 최적화 기법 을 적용하여 성능을 향상시킬 수 있습니다.

  1. 큰 메모리 블록 할당 (Memory Pooling)
  • 작은 메모리를 여러 번 할당하는 대신 한 번에 큰 메모리를 할당하여 관리
  1. 버퍼 재사용 (Buffer Reuse)
  • 여러 개의 작은 버퍼를 만들기보다, 큰 버퍼를 생성하여 필요한 부분만 사용
  1. 전용 메모리 활용
  • 자주 사용하는 데이터는 디바이스 전용(Device Local) 메모리 에 저장

정리

단계설명
버퍼 생성VkBufferCreateInfo 를 사용하여 버퍼 생성
메모리 할당vkAllocateMemory() 를 이용해 GPU 메모리 확보
버퍼 바인딩vkBindBufferMemory() 로 버퍼와 메모리 연결
데이터 복사vkMapMemory() 를 사용하여 CPU → GPU 데이터 전송
메모리 최적화전용 메모리 활용, 메모리 풀링, 버퍼 재사용

이제 Vulkan을 이용한 텍스처 매핑 및 셰이더 활용 방법을 살펴보겠습니다.

Vulkan을 이용한 텍스처 매핑 및 셰이더

Vulkan에서 텍스처 매핑(Texture Mapping) 은 3D 모델의 표면을 더욱 현실감 있게 표현하는 데 필수적인 기법입니다. OpenGL과 달리, Vulkan에서는 텍스처를 수동으로 관리해야 하므로 이미지 생성, 샘플러 설정, 셰이더 연결 등의 단계가 필요합니다.

목차
  1. 1. 텍스처 매핑 개요
  2. 2. 텍스처 이미지 생성
    1. ① VkImage 생성
  3. 3. 텍스처 이미지 메모리 할당 및 바인딩
    1. ② 메모리 할당
  4. 4. CPU에서 GPU로 텍스처 데이터 전송
    1. ③ CPU에서 텍스처 데이터를 로드 및 업로드
  5. 5. 텍스처 샘플러(Sampler) 생성
    1. ④ 샘플러 생성 코드
  6. 6. GLSL 셰이더에서 텍스처 활용
    1. ⑤ 버텍스 셰이더 (vertex_shader.glsl)
    2. ⑥ 프래그먼트 셰이더 (fragment_shader.glsl)
  7. 7. 텍스처 매핑을 위한 그래픽 파이프라인 설정
    1. ⑦ 파이프라인 레이아웃 추가
  8. 8. 실행 결과
  9. 9. Vulkan 텍스처 매핑 최적화
  10. 정리
    1. Vulkan의 성능 최적화 및 멀티스레딩 적용
  11. 1. Vulkan 성능 최적화 기법
    1. ① GPU 메모리 최적화
    2. ② 그래픽 파이프라인 최적화
    3. ③ 커맨드 버퍼(Command Buffer) 최적화
  12. 2. Vulkan에서 멀티스레딩 적용
    1. ① 멀티스레드 렌더링 구조
    2. ② 멀티스레드 커맨드 버퍼 생성
    3. ③ 멀티스레드 큐 패밀리 활용
  13. 3. Vulkan 성능 최적화 체크리스트
  14. 4. Vulkan 성능 최적화 결과
    1. 🎯 최적화 적용 전 vs 후
  15. 정리
    1. 요약

1. 텍스처 매핑 개요

텍스처 매핑 과정은 다음과 같이 진행됩니다.

  1. 이미지 로드 및 Vulkan 텍스처 생성 (PNG, JPG 등)
  2. 이미지를 GPU 메모리에 업로드
  3. 텍스처 샘플러(Sampler) 설정
  4. 셰이더에서 텍스처 좌표(UV) 적용
  5. 그래픽 파이프라인에서 텍스처 활용

2. 텍스처 이미지 생성

Vulkan에서 텍스처 이미지는 VkImage 객체로 생성되며, GPU가 효율적으로 접근할 수 있도록 메모리를 할당해야 합니다.

① VkImage 생성

VkImageCreateInfo imageInfo = {};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.width = texWidth;
imageInfo.extent.height = texHeight;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

VkImage textureImage;
vkCreateImage(device, &imageInfo, NULL, &textureImage);

✔️ VkImage 객체는 GPU에 저장될 텍스처 데이터를 의미합니다.

3. 텍스처 이미지 메모리 할당 및 바인딩

이미지를 생성한 후, GPU 메모리에 할당하고 바인딩해야 합니다.

② 메모리 할당

VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(device, textureImage, &memRequirements);

VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, 
                                           VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

VkDeviceMemory textureImageMemory;
vkAllocateMemory(device, &allocInfo, NULL, &textureImageMemory);
vkBindImageMemory(device, textureImage, textureImageMemory, 0);

✔️ 이미지 데이터가 GPU에서 올바르게 사용될 수 있도록 메모리를 바인딩합니다.

4. CPU에서 GPU로 텍스처 데이터 전송

CPU에서 GPU로 데이터를 전송하기 위해 VkBuffer를 이용한 스테이징(Staging) 과정이 필요합니다.

③ CPU에서 텍스처 데이터를 로드 및 업로드

void* data;
vkMapMemory(device, stagingBufferMemory, 0, imageSize, 0, &data);
memcpy(data, pixels, static_cast<size_t>(imageSize));
vkUnmapMemory(device, stagingBufferMemory);

✔️ 이미지를 CPU에서 Vulkan의 VkBuffer를 통해 GPU로 전송합니다.

5. 텍스처 샘플러(Sampler) 생성

샘플러는 텍스처에서 특정 픽셀을 읽어오는 방식을 정의합니다.

④ 샘플러 생성 코드

VkSamplerCreateInfo samplerInfo = {};
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.anisotropyEnable = VK_TRUE;
samplerInfo.maxAnisotropy = 16;
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
samplerInfo.unnormalizedCoordinates = VK_FALSE;

VkSampler textureSampler;
vkCreateSampler(device, &samplerInfo, NULL, &textureSampler);

✔️ 샘플러를 설정하여 텍스처 좌표(UV) 변환 방식을 정의합니다.

6. GLSL 셰이더에서 텍스처 활용

텍스처를 사용할 때, 셰이더에서 UV 좌표를 이용하여 샘플링 해야 합니다.

⑤ 버텍스 셰이더 (vertex_shader.glsl)

#version 450
layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec2 inTexCoord;
layout(location = 0) out vec2 fragTexCoord;

void main() {
    gl_Position = vec4(inPosition, 0.0, 1.0);
    fragTexCoord = inTexCoord;
}

✔️ 버텍스 셰이더에서 UV 좌표를 전달합니다.

⑥ 프래그먼트 셰이더 (fragment_shader.glsl)

#version 450
layout(location = 0) in vec2 fragTexCoord;
layout(set = 0, binding = 0) uniform sampler2D textureSampler;
layout(location = 0) out vec4 outColor;

void main() {
    outColor = texture(textureSampler, fragTexCoord);
}

✔️ 프래그먼트 셰이더에서 UV 좌표를 이용해 텍스처 색상을 출력합니다.

7. 텍스처 매핑을 위한 그래픽 파이프라인 설정

텍스처를 적용하려면 그래픽 파이프라인에서 텍스처 관련 정보를 추가해야 합니다.

⑦ 파이프라인 레이아웃 추가

VkDescriptorSetLayoutBinding samplerLayoutBinding = {};
samplerLayoutBinding.binding = 0;
samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
samplerLayoutBinding.descriptorCount = 1;
samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;

✔️ 셰이더에서 텍스처를 사용할 수 있도록 파이프라인에 추가합니다.

8. 실행 결과

위 과정을 수행하면 이미지가 삼각형 표면에 텍스처로 적용됩니다.

+-----------+
|           |
|  ████▓▓▓▓ |
|  ████▓▓▓▓ |
|  ████▓▓▓▓ |
|           |
+-----------+

✔️ 텍스처가 정상적으로 적용되었다면, GPU에서 샘플링된 색상이 출력됩니다.

9. Vulkan 텍스처 매핑 최적화

  1. 비트맵 압축 (BC7, ASTC, ETC2)
  • 텍스처 크기를 줄여 GPU 메모리 사용량 감소
  1. Mipmap 사용
  • 작은 텍스처를 자동 생성하여 성능 향상
  1. Anisotropic Filtering 활성화
  • 샘플링 품질을 높여 선명한 이미지 출력

정리

단계설명
VkImage 생성Vulkan에서 텍스처 이미지를 생성
GPU 메모리 할당vkAllocateMemory() 로 GPU에 텍스처 저장
CPU에서 GPU로 데이터 복사vkMapMemory() 를 사용하여 텍스처 업로드
샘플러 설정VkSamplerCreateInfo 로 샘플링 방식 정의
셰이더에서 텍스처 적용GLSL에서 texture() 함수를 사용하여 샘플링

이제 Vulkan의 성능 최적화 및 멀티스레딩 적용 방법을 살펴보겠습니다.

Vulkan의 성능 최적화 및 멀티스레딩 적용

Vulkan의 가장 큰 장점 중 하나는 저수준 제어를 통한 성능 최적화가 가능하다는 점입니다.
특히 멀티스레딩을 활용하여 GPU 부하를 분산하고, 커맨드 버퍼 관리를 최적화하면 렌더링 성능을 크게 향상시킬 수 있습니다.

1. Vulkan 성능 최적화 기법

Vulkan은 OpenGL과 달리 드라이버 최적화가 거의 없기 때문에, 개발자가 직접 성능을 조정해야 합니다.

① GPU 메모리 최적화

  1. 전용 메모리(Device Local Memory) 사용
  • 자주 사용하는 데이터를 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT 메모리에 배치
  • vkAllocateMemory() 를 최소화하여 불필요한 메모리 할당 방지
  1. 큰 메모리 블록 할당
  • 여러 개의 작은 버퍼를 생성하는 대신, 한 번에 큰 메모리를 할당하여 효율성 증가

코드 예제: 전용 메모리 할당

VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memoryRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memoryRequirements.memoryTypeBits, 
                                           VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);

✔️ 전용 메모리를 활용하여 GPU에서 빠르게 접근할 수 있도록 설정합니다.

② 그래픽 파이프라인 최적화

  1. 파이프라인 상태 최소 변경
  • 여러 개의 VkPipeline 객체를 미리 생성하고, vkCmdBindPipeline() 으로 변경
  1. 프레임버퍼(Render Pass) 최적화
  • VK_ATTACHMENT_LOAD_OP_CLEAR 사용을 최소화하여 프레임 버퍼 초기화 비용 절감
  • 깊이(Depth) 및 색상(Color) 버퍼 재사용

코드 예제: 파이프라인 캐싱

VkPipelineCacheCreateInfo pipelineCacheInfo = {};
pipelineCacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;

VkPipelineCache pipelineCache;
vkCreatePipelineCache(device, &pipelineCacheInfo, NULL, &pipelineCache);

✔️ 파이프라인 캐싱을 사용하여 재컴파일 비용을 줄입니다.

③ 커맨드 버퍼(Command Buffer) 최적화

Vulkan은 모든 렌더링 명령을 커맨드 버퍼(Command Buffer) 에 기록한 후 GPU에서 실행합니다.
CPU 부하를 줄이기 위해 커맨드 버퍼를 효율적으로 관리하는 것이 중요합니다.

  1. 1프레임마다 커맨드 버퍼를 재생성하지 않기
  • vkResetCommandBuffer() 를 활용하여 기존 커맨드를 재사용
  1. 다중 커맨드 버퍼 사용
  • 여러 개의 커맨드 버퍼를 생성하여 GPU 사용률 최적화

코드 예제: 커맨드 버퍼 기록 최적화

VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = commandPool;
allocInfo.commandBufferCount = 1;

VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);

✔️ 사전에 커맨드 버퍼를 생성하고, 프레임마다 재사용하여 성능을 향상시킵니다.

2. Vulkan에서 멀티스레딩 적용

Vulkan은 멀티스레드 환경에서 최적의 성능을 발휘할 수 있도록 설계되었습니다.
특히 멀티스레드 렌더링을 구현하면 CPU 활용도를 극대화할 수 있습니다.

① 멀티스레드 렌더링 구조

멀티스레드를 활용하여 Vulkan을 최적화하는 방법은 다음과 같습니다.

방법설명
멀티스레드 커맨드 버퍼 생성여러 개의 스레드가 개별적으로 커맨드 버퍼를 생성
큐 패밀리(Queue Family) 활용여러 개의 GPU 큐(Graphics/Compute) 활용
비동기 렌더링(Async Rendering)그래픽 연산과 컴퓨팅 연산을 동시에 수행

② 멀티스레드 커맨드 버퍼 생성

여러 개의 스레드가 독립적으로 커맨드 버퍼를 생성하면, CPU 성능을 극대화할 수 있습니다.

코드 예제: 멀티스레드에서 커맨드 버퍼 생성

void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t frameIndex) {
    VkCommandBufferBeginInfo beginInfo = {};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

    vkBeginCommandBuffer(commandBuffer, &beginInfo);

    vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);

    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
    vkCmdDraw(commandBuffer, 3, 1, 0, 0);

    vkCmdEndRenderPass(commandBuffer);

    vkEndCommandBuffer(commandBuffer);
}

// 스레드마다 개별적인 커맨드 버퍼 생성
std::thread thread1(recordCommandBuffer, commandBuffer1, 0);
std::thread thread2(recordCommandBuffer, commandBuffer2, 1);
thread1.join();
thread2.join();

✔️ 각 스레드가 독립적인 커맨드 버퍼를 생성하여 성능을 극대화합니다.

③ 멀티스레드 큐 패밀리 활용

Vulkan은 그래픽(Graphics), 전송(Transfer), 연산(Compute) 등의 큐 패밀리를 제공합니다.
멀티스레드를 활용하여 각 큐에서 병렬 연산을 수행할 수 있습니다.

코드 예제: 별도의 큐를 이용한 연산

VkQueue computeQueue;
vkGetDeviceQueue(device, computeQueueFamilyIndex, 0, &computeQueue);

VkCommandBuffer computeCommandBuffer;
// 커맨드 버퍼에 연산(Compute) 작업 추가
vkQueueSubmit(computeQueue, 1, &submitInfo, VK_NULL_HANDLE);

✔️ 그래픽 연산과 컴퓨팅 연산을 동시에 수행하여 성능을 향상시킵니다.

3. Vulkan 성능 최적화 체크리스트

✔ 메모리 최적화

  • 전용 메모리(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)를 적극 활용
  • 큰 블록 할당을 통해 메모리 관리 비용 감소

✔ 그래픽 파이프라인 최적화

  • 파이프라인 상태 변경을 최소화
  • VkPipelineCache 를 활용하여 재사용

✔ 멀티스레드 활용

  • 여러 개의 스레드에서 독립적으로 커맨드 버퍼를 생성
  • 그래픽 큐와 연산 큐를 동시에 활용

✔ 커맨드 버퍼 재사용

  • vkResetCommandBuffer() 를 사용하여 불필요한 커맨드 재생성 방지

4. Vulkan 성능 최적화 결과

위의 최적화 기법을 적용하면 Vulkan 애플리케이션의 성능이 크게 향상됩니다.

🎯 최적화 적용 전 vs 후

구분최적화 적용 전최적화 적용 후
CPU 부하높음 (단일 스레드)낮음 (멀티스레드 커맨드 버퍼)
GPU 부하최적화 부족파이프라인 캐싱, 메모리 최적화
프레임 속도(FPS)낮음향상됨

✔ 멀티스레딩과 메모리 최적화를 적용하면 Vulkan의 최대 성능을 활용할 수 있습니다.

정리

최적화 기법설명
메모리 최적화전용 메모리 활용 및 큰 블록 할당
파이프라인 캐싱VkPipelineCache 를 사용하여 성능 향상
멀티스레딩커맨드 버퍼 병렬 생성 및 연산 큐 활용

이제 Vulkan API를 활용한 웹 기사의 요약을 살펴보겠습니다.

요약

본 기사에서는 C 언어와 Vulkan API를 활용한 고성능 그래픽 렌더링 엔진 구축 방법을 다루었습니다. Vulkan의 핵심 개념인 인스턴스, 논리적 장치, 큐 패밀리를 이해하고, 그래픽 파이프라인과 커맨드 버퍼를 구성하는 방법을 설명했습니다.

또한 삼각형 렌더링, 텍스처 매핑, GPU 메모리 관리, 그리고 멀티스레딩을 활용한 성능 최적화 기법을 적용하여 Vulkan의 성능을 극대화하는 방법을 소개했습니다.

Vulkan은 낮은 오버헤드와 강력한 멀티스레딩 지원을 제공하므로, 게임 엔진 개발이나 실시간 그래픽 응용 프로그램에서 중요한 역할을 합니다.

✔ Vulkan의 핵심 최적화 포인트

  • 메모리 최적화: VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT 활용
  • 파이프라인 캐싱: VkPipelineCache로 성능 향상
  • 멀티스레딩: 커맨드 버퍼 병렬 생성 및 연산 큐 활용
  • 텍스처 관리: VkSampler를 사용한 효율적인 텍스처 샘플링

이제 Vulkan을 활용하여 보다 복잡한 렌더링 기법(예: 셰도잉, 후처리 효과, 애니메이션) 을 구현하면 더욱 강력한 그래픽 엔진을 개발할 수 있습니다. 🚀

C++
C Vulkan 게임 개발 그래픽 렌더링
목차
  1. 1. 텍스처 매핑 개요
  2. 2. 텍스처 이미지 생성
    1. ① VkImage 생성
  3. 3. 텍스처 이미지 메모리 할당 및 바인딩
    1. ② 메모리 할당
  4. 4. CPU에서 GPU로 텍스처 데이터 전송
    1. ③ CPU에서 텍스처 데이터를 로드 및 업로드
  5. 5. 텍스처 샘플러(Sampler) 생성
    1. ④ 샘플러 생성 코드
  6. 6. GLSL 셰이더에서 텍스처 활용
    1. ⑤ 버텍스 셰이더 (vertex_shader.glsl)
    2. ⑥ 프래그먼트 셰이더 (fragment_shader.glsl)
  7. 7. 텍스처 매핑을 위한 그래픽 파이프라인 설정
    1. ⑦ 파이프라인 레이아웃 추가
  8. 8. 실행 결과
  9. 9. Vulkan 텍스처 매핑 최적화
  10. 정리
    1. Vulkan의 성능 최적화 및 멀티스레딩 적용
  11. 1. Vulkan 성능 최적화 기법
    1. ① GPU 메모리 최적화
    2. ② 그래픽 파이프라인 최적화
    3. ③ 커맨드 버퍼(Command Buffer) 최적화
  12. 2. Vulkan에서 멀티스레딩 적용
    1. ① 멀티스레드 렌더링 구조
    2. ② 멀티스레드 커맨드 버퍼 생성
    3. ③ 멀티스레드 큐 패밀리 활용
  13. 3. Vulkan 성능 최적화 체크리스트
  14. 4. Vulkan 성능 최적화 결과
    1. 🎯 최적화 적용 전 vs 후
  15. 정리
    1. 요약