[OpenGL] Lighting Maps

■ Lighting Map

실제 세계의 객체들은 일반적으로 여러 재질(Material)로 이루어져 있으며 각 부분마다 다른 재질 속성을 가지고 있다. 따라서 Diffuse, Specular Map을 이용하여 Material 시스템을 확장하고 객체를 좀 더 정확하게 묘사할 수 있게 한다.

● Diffuse Map

객체의 각 개별 Fragment에 대해 Diffuse Color를 설정할 수 있는 방법, 즉 Fragment의 객체 상 위치에 따라 색상 값을 가져올 수 있는 시스템이 필요하다.

이것은 텍스처와 기본적으로 같은 원리를 사용한다. 객체를 감싼 이미지를 사용하여 Fragment별로 고유한 색상 값을 얻는 것이다. 조명이 있는 장면에서 이것은 일반적으로 확산 맵(Diffuse Map)이라고 부른다.

확산 맵을 설명하기 위해 다음 이미지를 사용할 것이다.

 

텍스처를 Material Struct 내부에 sampler2D로 저장하고 이전에 정의한 vec3 diffuse 컬러를 diffuse map으로 수정한다.

* sampler2D는 불투명 타입(Opaque Type)이라고 불리며, 이는 우리가 이러한 타입을 인스턴스화할 수 없고, 단지 유니폼으로만 정의할 수 있음을 의미한다. 만약 이 구조체가 유니폼이 아닌 다른 방식으로(예를 들어 함수 매개변수로) 인스턴스화된다면, GLSL은 이상한 오류를 발생시킬 수 있다. (불투명 타입을 포함하는 구조체에도 동일하게 적용된다)

또한 ambient 컬러는 대부분의 경우에 diffuse 컬러와 동일하므로 ambient material 컬러 벡터는 따로 저장하지 않는다.

struct Material
{
    sampler2D diffuse;
    vec3 specular;
    float shininess;
}; 
...
in vec2 TexCoords;

 

Fragment Shader에서 텍스처 좌표가 필요하므로 추가 입력 변수를 선언한다. 그런 다음 단순히 텍스처에서 샘플링하여 프래그먼트의 diffuse 색상 값을 가져온다.

vec3 diffuse = light.diffuse * diff * texture(material.diffuse, TexCoords).rgb;

 

또한 ambient 머티리얼 색상 값도 diffuse 머티리얼 색상 값과 동일하게 설정한다.

vec3 ambient = light.ambient * texture(material.diffuse, TexCoords).rgb;

 

이를 작동시키려면 텍스처 좌표가 포함된 Vertex 데이터를 업데이트하고, 이를 Vertex Attribute로 Fragment Shader에 전달하며 텍스처를 로드하고 적절한 텍스처 유닛에 텍스처를 바인딩해야 한다.

 

- 수정된 Vertex 데이터 : https://learnopengl.com/code_viewer.php?code=lighting/vertex_data_textures

 

이 Vertex 데이터는 큐브의 각 Vertex에 대해 Vertex 위치, 법선 벡터, 텍스처 좌표를 포함하고 있다. 이제 Vertex Shader를 텍스처 좌표를 Attribute로 받아 Fragment Shader로 전달하도록 수정한다.

 

- Vertex Shader

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;
...
out vec2 TexCoords;

void main()
{
	...
	TexCoords = aTexCoords;
}

 

두 개의 VAO 모두 새로운 Vertex 데이터에 맞추어 수정하고(stride 속성을 '8 * sizeof(float)'으로 수정), 컨테이너 이미지를 텍스처로 불러온다. 컨테이너를 그리기 전에 텍스처 유닛을 material.diffuse uniform sampler에 할당하고 컨테이너 텍스처를 이 텍스처 유닛에 바인딩해야 한다.

- main

// 텍스처 객체 생성
unsigned int diffuseMap;

// 상하 반전 설정
stbi_set_flip_vertically_on_load(true);

// 텍스처 바인딩
glGenTextures(1, &diffuseMap);
glBindTexture(GL_TEXTURE_2D, diffuseMap);

// Wrapping 옵션 설정
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

// Filtering 옵션 설정
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

// 이미지 로드 (png)
int width, height, nrChannels;
unsigned char* data = stbi_load("Textures/container2.jpg", &width, &height, &nrChannels, 0);

// 텍스처 생성 (RGBA)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);

// 메모리 반환
stbi_image_free(data);

// shader configuration
lightingShader.setInt("material.diffuse", 0);

...

// render loop - bind diffuse map
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, diffuseMap);

 

○ 소스 코드
https://learnopengl.com/code_viewer_gh.php?code=src/2.lighting/4.1.lighting_maps_diffuse_map/lighting_maps_diffuse.cpp

● Specular map

현재 오브젝트의 철 부분에만 Specular 하이라이트를 주고, 나무 부분에는 Specular 하이라이트를 없앨 것이다. 이를 위해 Specular 하이라이트를 위한 텍스처 맵을 사용한다. 이는 오브젝트의 각 부분의 Specular 세기를 정의하는 흑백(원한다면 컬러) 텍스처를 생성해야한다는 것을 의미한다. 예제의 Specular map은 다음과 같다.

 

Specular 하이라이트의 세기는 이 이미지의 각 픽셀의 '밝기'에 의해 얻을 수 있다. Fragment Shader에서 Specular map 각 픽셀의 컬러 값을 샘플링하고 이 값과 light의 Specular 세기와 곱한다. 픽셀이 흰색과 가까울수록 최종 결과가 증가하여 오브젝트의 Specular 요소가 밝아진다.

이 컨테이너의 이미지 나무 부분의 하이라이트를 없애기 위해 Diffuse 텍스처의 나무로된 부분은 검정색으로 처리한다. 검정색 부분은 어떠한 Specular 하이라이트도 가지지 않는다. 컨테이너의 철로된 모서리는 각자 다른 Specular 세기를 가진다.

 

○ Specular map 샘플링

Specular map은 다른 텍스처들과 비슷하다. Diffuse map과 같이 적절한 이미지를 로드하고 텍스처 객체를 생성한다. Fragment Shader에서 다른 텍스처 샘플러를 사용하기 때문에 Specular map에 다른 텍스처 유닛을 사용해야 한다. 그리고 렌더링하기 전에 적절한 텍스처 유닛을 바인딩하게 한다.

// main
lightingShader.use();
glUniform1i(glGetUniformLocation(lightingShader.ID, "material.specular"), 1);

...

// render loop
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, specularMap);

 

그런 다음 Fragment Shader의 material 속성 중 specular 요소를 vec3 대신에 sampler2D로 받을 수 있도록 수정한다.

// Fragment Shader
struct Material
{
    sampler2D diffuse;
    sampler2D specular;
    float shininess;
};

 

 

마지막으로 Fragment의 해당 Specular 세기를 가져오기 위해 Specular map을 샘플링한다.

vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords));
vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords));  
vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords));
FragColor = vec4(ambient + diffuse + specular, 1.0);

 

Specular map을 사용함으로써 오브젝트의 어떠한 부분이 실제로 빛나야하는지에 대해 상세하게 지정할 수 있고 그에 따른 세기도 설정할 수 있다. 따라서 Specular map은 Diffuse map의 위에 레이어를 추가하게 해준다.

○ 결과

 

○ 소스 코드
- main

#include <glad/glad.h>
#include <GLFW/glfw3.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <Shader.h>
#include <Camera.h>
#include <iostream>

unsigned int loadTexture(char const* path);
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void processInput(GLFWwindow* window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

// camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
float lastX = SCR_WIDTH / 2.0f;
float lastY = SCR_HEIGHT / 2.0f;
bool firstMouse = true;

// timing
float deltaTime = 0.0f;
float lastFrame = 0.0f;

// lighting
glm::vec3 lightPos = glm::vec3(2.0f, 1.0f, 2.0f);

int main()
{
    // ---------- [ 1. GLFW, GLAD 세팅 ] ----------

    // GLFW 초기화 및 설정
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // GLFW 윈도우 생성
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    // 콜백 함수들 등록
    glfwSetCursorPosCallback(window, mouse_callback);
    glfwSetScrollCallback(window, scroll_callback);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // 마우스 커서 숨기기
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    // GLAD - OpenGL 함수 포인터를 로드
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // 셰이더 프로그램 빌드 및 컴파일
    Shader lightingShader("Shaders/colors.vs", "Shaders/colors.fs");
    Shader lightCubeShader("Shaders/light_cube.vs", "Shaders/light_cube.fs");

    // ---------- [ 2. 정점 데이터 입력 / 정점 속성 구성 ] ----------

    float vertices[] = {
        // positions          // normals           // texture coords
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,   0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,  0.0f, 1.0f
    };

    // 깊이 테스트 활성화
    glEnable(GL_DEPTH_TEST);

    // VAO, VBO 생성
    // VAO: VBO와 정점 속성 포인터의 상태를 저장하기 위한 객체 
    // VBO: GPU 메모리에 정점 데이터를 저장하기 위한 버퍼 객체
    unsigned int VBO, cubeVAO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &VBO);

    // 정점 버퍼 객체(VBO)를 바인딩
    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    // 바인딩된 버퍼 객체에 vertices 데이터를 복사하고,버퍼 객체의 크기와 데이터 설정
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // 정점 배열 객체(VAO) 바인딩
    glBindVertexArray(cubeVAO);

    // Position Attribute 구성
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // Normal Attribute 구성
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);

    // Texture(Diffuse Map) Attribute 구성
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2);

    // 광원 큐브용 VAO 생성
    unsigned int lightCubeVAO;
    glGenVertexArrays(1, &lightCubeVAO);
    glBindVertexArray(lightCubeVAO);

    // VBO 바인드만 하면 된다 (이미 데이터 포함되어 있음)
    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // ---------- [ 3. Diffuse map, Specular map 로드 (함수화) ] ----------

    unsigned int diffuseMap = loadTexture("Textures/container2.png");
    unsigned int specularMap = loadTexture("Textures/container2_specular.png");

    // shader configuration
    lightingShader.use();
    glUniform1i(glGetUniformLocation(lightingShader.ID, "material.diffuse"), 0);
    glUniform1i(glGetUniformLocation(lightingShader.ID, "material.specular"), 1);

    // ---------- [ 4. 렌더 루프 ] ----------

    while (!glfwWindowShouldClose(window))
    {
        // 프레임 사이 deltaTime 측정
        float currentFrame = static_cast<float>(glfwGetTime());
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // 입력 처리
        processInput(window);

        // 배경 렌더
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // ---------- Uniform 변수 할당 ----------
        lightingShader.use();

        // 카메라 위치 속성
        glUniform3fv(glGetUniformLocation(lightingShader.ID, "viewPos"), 1, &(camera.Position)[0]);
        
        // 광원 위치 속성
        glUniform3fv(glGetUniformLocation(lightingShader.ID, "light.position"), 1, &lightPos[0]);

        // 광원 색상 속성
        glm::vec3 lightColor = glm::vec3(1.0f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "light.ambient"), 0.2f, 0.2f, 0.2f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "light.diffuse"), 0.5f, 0.5f, 0.5f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "light.specular"), 1.0f, 1.0f, 1.0f);

        // 머티리얼 속성 (diffuse: 원래 오브젝트의 색상을 의미, 조명 모델에서 Diffuse 조명 계산 시 사용)
        glUniform3f(glGetUniformLocation(lightingShader.ID, "material.specular"), 0.5f, 0.5f, 0.5f);
        glUniform1f(glGetUniformLocation(lightingShader.ID, "material.shininess"), 64.0f);

        // View / Projection 변환
        glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
        glm::mat4 view = camera.GetViewMatrix();
        glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "view"), 1, GL_FALSE, glm::value_ptr(view));

        // World 변환
        glm::mat4 model = glm::mat4(1.0f);
        glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "model"), 1, GL_FALSE, glm::value_ptr(model));

        // Diffuse map 바인딩
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, diffuseMap);

        // Specular map 바인딩
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, specularMap);

        // 큐브 렌더
        glBindVertexArray(cubeVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // 광원 큐브 렌더
        lightCubeShader.use();
        glUniformMatrix4fv(glGetUniformLocation(lightCubeShader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        glUniformMatrix4fv(glGetUniformLocation(lightCubeShader.ID, "view"), 1, GL_FALSE, glm::value_ptr(view));
        model = glm::mat4(1.0f);
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(0.2f)); // a smaller cube
        glUniformMatrix4fv(glGetUniformLocation(lightCubeShader.ID, "model"), 1, GL_FALSE, glm::value_ptr(model));

        glBindVertexArray(lightCubeVAO);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // 프론트, 백 버퍼 교체
        glfwSwapBuffers(window);

        // 이벤트 처리
        glfwPollEvents();
    }

    // VAO, VBO 메모리 해제
    glDeleteVertexArrays(1, &cubeVAO);
    glDeleteVertexArrays(1, &lightCubeVAO);
    glDeleteBuffers(1, &VBO);

    // 사용된 리소스 해제, 초기화 및 정리 작업
    glfwTerminate();
    return 0;
}

// 사용자 입력 처리 함수
void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
}

// 윈도우 사이즈 변경 콜백 함수
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    glViewport(0, 0, width, height);
}

// 마우스 이동 콜백 함수
void mouse_callback(GLFWwindow* window, double xposIn, double yposIn)
{
    float xpos = static_cast<float>(xposIn);
    float ypos = static_cast<float>(yposIn);

    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

// 마우스 휠 콜백 함수
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(static_cast<float>(yoffset));
}

// 텍스처 로드 함수
unsigned int loadTexture(char const* path)
{
    unsigned int textureID;
    glGenTextures(1, &textureID);

    int width, height, nrComponents;
    unsigned char* data = stbi_load(path, &width, &height, &nrComponents, 0);
    if (data)
    {
        GLenum format{};
        if (nrComponents == 1)
            format = GL_RED;
        else if (nrComponents == 3)
            format = GL_RGB;
        else if (nrComponents == 4)
            format = GL_RGBA;

        glBindTexture(GL_TEXTURE_2D, textureID);
        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        stbi_image_free(data);
    }
    else
    {
        std::cout << "Texture failed to load at path: " << path << std::endl;
        stbi_image_free(data);
    }

    return textureID;
}

 

- Fragment Shader

#version 330 core
out vec4 FragColor;

struct Material
{
    sampler2D diffuse;
    sampler2D specular;
    float shininess;
};

struct Light
{
    vec3 position;
    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

in vec3 Normal;  
in vec3 FragPos;
in vec2 TexCoords;

uniform vec3 viewPos;
uniform Material material;
uniform Light light;

void main()
{
    // ambient
    vec3 ambient = light.ambient * texture(material.diffuse, TexCoords).rgb;

    // diffuse 
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(light.position - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = light.diffuse * diff * texture(material.diffuse, TexCoords).rgb;  
    
    // specular
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 reflectDir = reflect(-lightDir, norm);  
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
    vec3 specular = light.specular * spec * texture(material.specular, TexCoords).rgb;  
    
    vec3 result = ambient + diffuse + specular;
    FragColor = vec4(result, 1.0);
}

 

- 링크
https://learnopengl.com/code_viewer_gh.php?code=src/2.lighting/4.2.lighting_maps_specular_map/lighting_maps_specular.cpp

● Emission map

Emission map은 Fragment의 Emission 값을 저장하는 텍스처이다. Emission 값은 오브젝트가 광원을 자체적으로 가지고 있다면 그 빛을 방출(Emit)하는 컬러이다. 이 방법으로 오브젝트는 빛의 상황에 상관없이 빛날 수 있다.

다른 map과 마찬가지로 Fragment Shader의 material에 sampler2D emission 요소를 추가하고, 텍스처를 로드하고 바인딩한다.

 

// Fragment Shader
struct Material
{
    sampler2D diffuse;
    sampler2D specular;
    sampler2D emission;
    float shininess;
};

...
vec3 emission = texture(material.emission, TexCoords).rgb;
vec3 result = ambient + diffuse + specular;