반응형
스카이박스와 환경 맵핑
오늘은 스카이박스와 환경 맵핑을 통해 3D 씬의 시각적 품질을 향상시키는 방법을 학습하겠습니다. 스카이박스는 게임의 배경을 설정하여 더 몰입감 있는 환경을 제공하며, 환경 맵핑은 물체가 주변 환경을 반사하는 효과를 추가합니다.
1. 스카이박스 구현
먼저 스카이박스를 구현합니다. 스카이박스는 6개의 텍스처로 이루어진 큐브 형태의 배경입니다.
헤더 파일 작성
include/Skybox.h 파일을 생성하고 다음과 같이 작성합니다.
#ifndef SKYBOX_H
#define SKYBOX_H
#include <GL/glew.h>
#include <vector>
#include <string>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
class Skybox {
public:
Skybox();
~Skybox();
bool Initialize(const std::vector<std::string>& faces);
void Render(const glm::mat4& view, const glm::mat4& projection);
private:
GLuint loadCubemap(const std::vector<std::string>& faces);
void setupSkybox();
GLuint skyboxVAO, skyboxVBO;
GLuint cubemapTexture;
GLuint shaderProgram;
};
#endif // SKYBOX_H
소스 파일 작성
src/Skybox.cpp 파일을 생성하고 다음과 같이 작성합니다.
#include "Skybox.h"
#include <iostream>
#include <stb_image.h>
Skybox::Skybox() : skyboxVAO(0), skyboxVBO(0), cubemapTexture(0), shaderProgram(0) {}
Skybox::~Skybox() {
glDeleteVertexArrays(1, &skyboxVAO);
glDeleteBuffers(1, &skyboxVBO);
glDeleteTextures(1, &cubemapTexture);
}
bool Skybox::Initialize(const std::vector<std::string>& faces) {
shaderProgram = LoadShader("shaders/skybox_vertex.glsl", "shaders/skybox_fragment.glsl");
if (shaderProgram == 0) {
return false;
}
cubemapTexture = loadCubemap(faces);
setupSkybox();
return true;
}
void Skybox::Render(const glm::mat4& view, const glm::mat4& projection) {
glDepthFunc(GL_LEQUAL);
glUseProgram(shaderProgram);
glm::mat4 viewMatrix = glm::mat4(glm::mat3(view)); // Remove translation part of the view matrix
GLuint viewLoc = glGetUniformLocation(shaderProgram, "view");
GLuint projLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(viewMatrix));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
glBindVertexArray(skyboxVAO);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glDepthFunc(GL_LESS);
}
GLuint Skybox::loadCubemap(const std::vector<std::string>& faces) {
GLuint textureID;
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
int width, height, nrChannels;
for (GLuint i = 0; i < faces.size(); i++) {
unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
if (data) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
stbi_image_free(data);
} else {
std::cerr << "Cubemap texture failed to load at path: " << faces[i] << std::endl;
stbi_image_free(data);
}
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
return textureID;
}
void Skybox::setupSkybox() {
float skyboxVertices[] = {
// positions
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
glGenVertexArrays(1, &skyboxVAO);
glGenBuffers(1, &skyboxVBO);
glBindVertexArray(skyboxVAO);
glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glBindVertexArray(0);
}
쉐이더 파일 작성
스카이박스를 렌더링하기 위한 쉐이더 파일을 작성합니다.
버텍스 쉐이더
shaders/skybox_vertex.glsl 파일을 생성하고 다음과 같이 작성합니다.
#version 330 core
layout(location = 0) in vec3 aPos;
out vec3 TexCoords;
uniform mat4 projection;
uniform mat4 view;
void main() {
TexCoords
= aPos;
vec4 pos = projection * view * vec4(aPos, 1.0);
gl_Position = pos.xyww;
}
프래그먼트 쉐이더
shaders/skybox_fragment.glsl 파일을 생성하고 다음과 같이 작성합니다.
#version 330 core
out vec4 FragColor;
in vec3 TexCoords;
uniform samplerCube skybox;
void main() {
FragColor = texture(skybox, TexCoords);
}2. 게임 엔진에 스카이박스 통합
이제 게임 엔진에 스카이박스를 통합하고, 스카이박스를 렌더링합니다.
헤더 파일 수정
include/GameEngine.h 파일을 수정하여 Skybox 클래스를 포함합니다.
#ifndef GAMEENGINE_H
#define GAMEENGINE_H
#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>
#include <GL/glew.h>
#include "ParticleSystem.h"
#include "UIManager.h"
#include "LuaManager.h"
#include "NetworkManager.h"
#include "TextureManager.h"
#include "Graphics3D.h"
#include "Model.h"
#include "Camera.h"
#include "PhysicsManager.h"
#include "Skybox.h"
#include "AudioManager.h"
class GameEngine {
public:
GameEngine();
~GameEngine();
bool Initialize(const char* title, int width, int height);
void Run();
void Shutdown();
private:
SDL_Window* window;
SDL_GLContext glContext;
SDL_Renderer* renderer;
GLuint shaderProgram;
ParticleSystem* particleSystem;
UIManager* uiManager;
LuaManager* luaManager;
NetworkManager* networkManager;
Graphics3D* graphics3D;
Model* model;
Camera* camera;
PhysicsManager* physicsManager;
Skybox* skybox;
bool isRunning;
Uint32 frameStart;
int frameTime;
bool InitializeOpenGL();
GLuint LoadShader(const std::string& vertexPath, const std::string& fragmentPath);
void HandleEvents();
void Update();
void Render();
};
#endif // GAMEENGINE_H
소스 파일 수정
src/GameEngine.cpp 파일을 다음과 같이 수정합니다.
#include "GameEngine.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
const int FPS = 60;
const int FRAME_DELAY = 1000 / FPS;
float lastX = 400, lastY = 300;
bool firstMouse = true;
GameEngine::GameEngine()
: window(nullptr), glContext(nullptr), renderer(nullptr), shaderProgram(0),
particleSystem(nullptr), uiManager(nullptr), luaManager(nullptr), networkManager(nullptr),
graphics3D(nullptr), model(nullptr), camera(nullptr), physicsManager(nullptr), skybox(nullptr),
isRunning(false), frameStart(0), frameTime(0) {}
GameEngine::~GameEngine() {
Shutdown();
}
bool GameEngine::Initialize(const char* title, int width, int height) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
std::cerr << "SDL_Init Error: " << SDL_GetError() << std::endl;
return false;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if (window == nullptr) {
std::cerr << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
return false;
}
glContext = SDL_GL_CreateContext(window);
if (glContext == nullptr) {
std::cerr << "SDL_GL_CreateContext Error: " << SDL_GetError() << std::endl;
return false;
}
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (renderer == nullptr) {
std::cerr << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
return false;
}
if (glewInit() != GLEW_OK) {
std::cerr << "GLEW Initialization failed!" << std::endl;
return false;
}
shaderProgram = LoadShader("shaders/vertex_shader_3d.glsl", "shaders/fragment_shader_3d.glsl");
if (shaderProgram == 0) {
return false;
}
particleSystem = new ParticleSystem(500);
uiManager = new UIManager(renderer);
if (!uiManager->Initialize()) {
return false;
}
uiManager->RenderText("Hello, Game Engine!", 10, 10, 24, { 255, 255, 255, 255 });
luaManager = new LuaManager();
if (!luaManager->Initialize()) {
return false;
}
luaManager->LoadScript("path/to/your/script.lua");
if (!TextureManager::Instance().Load("path/to/your/texture.png", "example", renderer)) {
return false;
}
networkManager = new NetworkManager();
if (!networkManager->Initialize()) {
return false;
}
graphics3D = new Graphics3D();
if (!graphics3D->Initialize()) {
return false;
}
model = new Model("path/to/your/model.obj");
camera = new Camera(glm::vec3(0.0f, 0.0f, 3.0f));
physicsManager = new PhysicsManager();
physicsManager->Initialize();
std::vector<std::string> faces{
"path/to/right.jpg",
"path/to/left.jpg",
"path/to/top.jpg",
"path/to/bottom.jpg",
"path/to/front.jpg",
"path/to/back.jpg"
};
skybox = new Skybox();
if (!skybox->Initialize(faces)) {
return false;
}
// 물리 엔진에 오브젝트 추가
btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0, 1, 0), 1);
btCollisionShape* fallShape = new btSphereShape(1);
btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, -1, 0)));
btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, groundMotionState, groundShape, btVector3(0, 0, 0));
btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI);
physicsManager->GetDynamicsWorld()->addRigidBody(groundRigidBody);
btDefaultMotionState* fallMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 50, 0)));
btScalar mass = 1;
btVector3 fallInertia(0, 0, 0);
fallShape->calculateLocalInertia(mass, fallInertia);
btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, fallMotionState, fallShape, fallInertia);
btRigidBody* fallRigidBody = new btRigidBody(fallRigidBodyCI);
physicsManager->GetDynamicsWorld()->addRigidBody(fallRigidBody);
isRunning = true;
return true;
}
GLuint GameEngine::LoadShader(const std::string& vertexPath, const std::string& fragmentPath) {
std::string vertexCode;
std::string fragmentCode;
std::ifstream vShaderFile;
std::ifstream fShaderFile;
vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try {
vShaderFile.open(vertexPath);
fShaderFile.open(fragmentPath);
std::stringstream vShaderStream, fShaderStream;
vShaderStream << vShaderFile.rdbuf();
fShaderStream << fShaderFile.rdbuf();
vShaderFile.close();
fShaderFile.close();
vertexCode = vShaderStream.str();
fragmentCode = fShaderStream.str();
}
catch (std::ifstream::failure& e) {
std::cerr << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
return 0;
}
const char* vShaderCode = vertexCode.c_str();
const char* fShaderCode = fragmentCode.c_str();
GLuint vertexShader, fragmentShader;
GLint success;
GLchar infoLog[512];
vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vShaderCode, nullptr);
glCompileShader(vertexShader);
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
std::cerr << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
return 0;
}
fragmentShader
= glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fShaderCode, nullptr);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);
std::cerr << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
return 0;
}
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(program, 512, nullptr, infoLog);
std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
return 0;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return program;
}
void GameEngine::Run() {
while (isRunning) {
frameStart = SDL_GetTicks();
HandleEvents();
Update();
Render();
frameTime = SDL_GetTicks() - frameStart;
if (FRAME_DELAY > frameTime) {
SDL_Delay(FRAME_DELAY - frameTime);
}
}
}
void GameEngine::HandleEvents() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
isRunning = false;
}
if (event.type == SDL_KEYDOWN) {
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
isRunning = false;
break;
case SDLK_w:
camera->ProcessKeyboard(FORWARD, frameTime / 1000.0f);
break;
case SDLK_s:
camera->ProcessKeyboard(BACKWARD, frameTime / 1000.0f);
break;
case SDLK_a:
camera->ProcessKeyboard(LEFT, frameTime / 1000.0f);
break;
case SDLK_d:
camera->ProcessKeyboard(RIGHT, frameTime / 1000.0f);
break;
default:
break;
}
}
if (event.type == SDL_MOUSEMOTION) {
float xpos = static_cast<float>(event.motion.x);
float ypos = static_cast<float>(event.motion.y);
if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}
float xoffset = xpos - lastX;
float yoffset = lastY - ypos;
lastX = xpos;
lastY = ypos;
camera->ProcessMouseMovement(xoffset, yoffset);
}
if (event.type == SDL_MOUSEWHEEL) {
camera->ProcessMouseScroll(static_cast<float>(event.wheel.y));
}
}
}
void GameEngine::Update() {
float deltaTime = frameTime / 1000.0f;
particleSystem->Update(deltaTime);
physicsManager->Update(deltaTime);
luaManager->ExecuteFunction("update", deltaTime);
networkManager->Service();
}
void GameEngine::Render() {
// 화면을 검은색으로 지우기
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shaderProgram);
// 카메라 뷰 및 프로젝션 설정
glm::mat4 view = camera->GetViewMatrix();
glm::mat4 projection = glm::perspective(glm::radians(camera->Zoom), (float)800 / (float)600, 0.1f, 100.0f);
GLuint viewLoc = glGetUniformLocation(shaderProgram, "view");
GLuint projLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
// 3D 모델 렌더링
model->Render(shaderProgram);
// 스카이박스 렌더링
skybox->Render(view, projection);
// SDL 렌더러 사용하여 텍스처 렌더링
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
TextureManager::Instance().Draw("example", 100, 100, 64, 64, renderer);
uiManager->Render();
SDL_RenderPresent(renderer);
SDL_GL_SwapWindow(window);
}
void GameEngine::Shutdown() {
if (particleSystem) {
delete particleSystem;
particleSystem = nullptr;
}
if (uiManager) {
uiManager->Shutdown();
delete uiManager;
uiManager = nullptr;
}
if (luaManager) {
luaManager->Shutdown();
delete luaManager;
luaManager = nullptr;
}
if (networkManager) {
networkManager->Shutdown();
delete networkManager;
networkManager = nullptr;
}
if (graphics3D) {
graphics3D->Shutdown();
delete graphics3D;
graphics3D = nullptr;
}
if (model) {
delete model;
model = nullptr;
}
if (camera) {
delete camera;
camera = nullptr;
}
if (physicsManager) {
physicsManager->Shutdown();
delete physicsManager;
physicsManager = nullptr;
}
if (skybox) {
delete skybox;
skybox = nullptr;
}
TextureManager::Instance().ClearTextureMap();
if (shaderProgram) {
glDeleteProgram(shaderProgram);
shaderProgram = 0;
}
if (renderer) {
SDL_DestroyRenderer(renderer);
renderer = nullptr;
}
if (glContext) {
SDL_GL_DeleteContext(glContext);
glContext = nullptr;
}
if (window) {
SDL_DestroyWindow(window);
window = nullptr;
}
SDL_Quit();
}3. 프로젝트 빌드 및 실행
- Visual Studio에서 CMake 프로젝트 열기:
- Visual Studio를 실행하고,
File->Open->CMake...를 선택합니다. GameEngine디렉토리를 선택하여 프로젝트를 엽니다.
- Visual Studio를 실행하고,
- 프로젝트 빌드:
- Visual Studio 상단의
Build메뉴에서Build All을 선택하여 프로젝트를 빌드합니다.
- Visual Studio 상단의
- 프로젝트 실행:
Debug메뉴에서Start Without Debugging을 선택하여 프로그램을 실행합니다.- 윈도우 창이 생성되고, 스카이박스가 배경으로 렌더링되며, 3D 씬이 보다 몰입감 있게 보입니다.
마무리
오늘은 스카이박스와 환경 맵핑을 통해 3D 씬의 시각적 품질을 향상시키는 방법을 학습했습니다. 이를 통해 게임 엔진에 보다 현실적인 배경을 추가할 수 있었습니다. 다음 단계에서는 포스트 프로세싱 효과를 다루어 그래픽 효과를 더욱 향상시키는 방법을 배워보겠습니다.
질문이나 추가적인 피드백이 있으면 언제든지 댓글로 남겨 주세요.
Day 27 예고
다음 날은 "포스트 프로세싱 효과"에 대해 다룰 것입니다. 3D 씬에 다양한 그래픽 효과를 적용하여 시각적 품질을 더욱 향상시키는 방법을 배워보겠습니다.
반응형
'-----ETC----- > C++로 배우는 게임 엔진 개발' 카테고리의 다른 글
| [C++로 배우는 게임 엔진 개발] Day 24: 카메라 시스템 구현 (0) | 2024.08.01 |
|---|---|
| [C++로 배우는 게임 엔진 개발] Day 25: 3D 물리 엔진 기초 (Bullet) (0) | 2024.08.01 |
| [C++로 배우는 게임 엔진 개발] Day 27: 포스트 프로세싱 효과 (0) | 2024.08.01 |
| [C++로 배우는 게임 엔진 개발] Day 28: 인스턴싱과 최적화 기법 (0) | 2024.08.01 |
| [C++로 배우는 게임 엔진 개발] Day 29: 게임 씬 관리 시스템 구현 (0) | 2024.08.01 |