[OpenGL] Lighting Caster

■ Light Caster

지금까지 사용한 조명은 한 점에서 나오는 단일 소스에서 비롯되었다. 하지만 현실 세계에서는 서로 다르게 작용하는 여러 종류의 조명이 존재한다. 물체에 빛을 비추는 광원을 Light caster라고 한다. 다양한 광원을 시뮬레이션하는 방법을 배우는 것은 환경을 더욱 풍부하게 만드는 또 하나의 도구이다.

■ Directional Light (방향성 광원)

광원이 무한히 멀리 있을 때 모든 광선들이 동일한 방향(이는 광원의 위치에 독립적이다)을 가지기 때문에 이 광원을 Directional Light라고 부른다.

Directional Light의 좋은 예는 우리가 알고있는 태양이다. 태양은 우리와 무한정으로 멀리 있지는 않지만 lighting 계산에서 무한정으로 멀리 있다고 간주할 정도로 우리와 멀리 떨어져 있다. 태양에서 오는 모든 광선들은 서로 평행하다.

모든 광선들이 평행하기 때문에 각 오브젝트들이 광원의 위치와 어떠한 관계가 있는지에 대해서는 상관이 없다. 빛의 방향은 scene에 존재하는 각각의 오브젝트에 모두 동일하기 때문이다. 빛의 방향 벡터가 동일하게 유지되기 때문에 lighting 계산이 scene에 존재하는 각 오브젝트들에게 비슷하게 적용된다.

빛에 대한 위치 벡터 대신에 방향 벡터를 정의하면 이러한 Directional Light를 만들 수 있다. shader 계산은 대부분 동일하지만 이번에는 빛의 position 벡터를 사용하여 계산된 lightDir 벡터 대신에 빛의 direction 벡터를 직접적으로 사용할 것이다.

 

struct Light
{
    // Directional Light의 경우에 position은 필요하지 않다.
    // vec3 position;
    vec3 direction;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;
};

...

void main()
{
    vec3 lightDir = normalize(-light.direction);
    ...
}

 

지금까지 사용한 lighting 계산은 Fragment로부터 광원으로 향하는 빛의 방향이 필요했으나 Directional Light는 광원으로부터 Fragment로 향하는 방향을 구하여 사용한다. (부호 반대)

광원의 방향을 직접 지정한다.

// main
lightingShader.setVec3("light.direction", -0.2f, -1.0f, -0.3f);

* 벡터의 타입은 빛의 유형을 판단할 수 있는 역할도 한다. w 요소가 1.0이라면 빛의 위치 벡터이고, 0.0이라면 빛의 방향벡터인 것이다.

■ Point Light (점 광원)

씬 전체에 산란되는 광원으로 world 어딘가에 주어진 위치를 갖고 모든 방향으로 빛을 밝히며 광선은 점점 희미해진다.

● Attenuation (감쇠)

광선이 지나간 거리에 따라 빛의 세기가 줄어드는 것을 Attenuation(감쇠)라고 부른다. 다음 공식은 광원과 Fragment 사이의 거리를 기반으로 하는 Attenuation 값을 계산하는 공식이다. 나중에 이 값을 빛의 세기 벡터에 곱할 것이다.

 

 

- d : Fragment에서 광원까지의 거리
- Kc : 일반적으로 1.0을 유지하는 상수항 (분모를 1보다 작게 만들지 않게 함)
- Kl : 거리 값과 곱해져 1차원적으로 세기를 감소시키는 1차항
- Kq : 거리의 사분면과 곱해지고 2차원적으로 세기를 감소시키는 2차항

다음 그래프는 이러한 Attenuation이 가지는 효과를 보여준다.

 

 

Attenuation을 구현하기 위해 Fragment에 3개의 값이 추가로 필요하다. (상수항, 일차항, 이차항)

// Fragment Shader
struct Light
{
    vec3 position;  

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;

    float constant; // 상수항
    float linear; // 일차항
    float quadratic; // 이차항
};

 

공식을 기반으로 Attenuation 값을 계산하고 ambient, diffuse, specular 요소에 곱하기만 하면 된다.

float distance = length(light.position - FragPos);
float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));

ambient  *= attenuation;
diffuse  *= attenuation;
specular *= attenuation;

 

그 다음 OpenGL에서 적절한 값을 설정한다.

// main
glUniform1f(glGetUniformLocation(lightingShader.ID, "light.constant"), 1.0f);
glUniform1f(glGetUniformLocation(lightingShader.ID, "light.linear"), 0.09f);
glUniform1f(glGetUniformLocation(lightingShader.ID, "light.quadratic"), 0.032f);

 

 

● 결과

 

■ Spotlight (스포트라이트)

Spotlight는 환경의 어딘가에 위치한 광원으로 모든 방향으로 광선을 쏘지 않고 특정 방향으로만 쏜다. 결과적으로 Spotlight 방향의 특정 반지름 내부에 있는 오브젝트만 밝아지고 나머지는 어두워진다.

OpenGL의 Spotlight는 World Space에서의 위치, 방향, cutoff 각(Spotlight의 반지름 지정)으로 표현된다. 각 Fragment에 대해 Spotlight의 cutoff 방향 사이(원뿔 내부)에 있는지 계산하여 만약 그렇다면 그에 맞춰서 Fragment를 밝게 한다. 다음 이미지는 Spotlight가 어떻게 동작하는지에 대한 개념을 보여준다.

 

 

- LightDir : Fragment에서 광원까지의 방향 벡터
- SpotDir : Spotlight가 바라보는 방향
- Phi Φ : Spotlight의 반지름을 정하는 cutoff 각, 이 각 외부는 Spotlight에 의한 빛을 받지 못한다.
- Theta θ : LightDir 벡터와 SpotDir 벡터 사이의 각도. Spotlight의 내부에 있기 때문에 θ 값은 Φ 값보다 작아야한다.

그래서 우리가 필요한 것은 LightDir 벡터와 SpotDir 벡터를 내적하여 이를 cutoff 각 Φ와 비교하는 것이다. 

● Flashlight

Flashlight는 Viewer의 위치에 있고 일반적으로 플레이어의 관점을 향하고 있는 Spotlight이다. 기본적으로 Flashlight는 일반적인 Spotlight이지만 위치와 방향이 플레이어의 위치와 방향에 따라 계속해서 업데이트된다는 점이 특징이다.

그래서 Fragment Shader를 위해 필요한 값들은 Spotlight의 위치 벡터(빛의 방향을 계산하기 위해), 방향 벡터, cutoff 각이다. 이 값들을 Light struct에 저장한다.

// Fragment Shader
struct Light
{
    vec3 position;
    vec3 direction;
    float cutOff;
    ...
};

 

그리고 적절한 값을 설정한다.

// main
lightingShader.setVec3("light.position", camera.Position);
lightingShader.setVec3("light.direction", camera.Front);
lightingShader.setFloat("light.cutOff", glm::cos(glm::radians(12.5f)));

 

* Cutoff 값을 각도로 설정하지 않고 각에 대한 코사인 값을 계산하고 이 값을 Fragment Shader로 전달하는 것을 볼 수 있다. 이유는 Fragment Shader에서 LightDir와 SpotDir 벡터의 내적을 계산하고 있는데 내적은 각이 아닌 코사인 값을 반환하므로 코사인 값과 각도를 직접 비교할 수 없기 때문이다. 각을 구하기 위해서는 내적의 결과에 대해 코사인의 역함수를 사용해야 하는데 이는 비용이 많이 드는 연산이다. 따라서 약간의 성능 향상을 위해 주어진 cutoff 각에 대한 코사인 값을 계산하고 이 결과를 Fragment Shader에 전달한다.

이제 남은 것은 Theta θ 값을 계산하고 이를 cutoff Φ 값과 비교하여 Spotlight의 내부에 있는지 외부에 있는지 판단하는 것이다.

float theta = dot(lightDir, normalize(-light.direction));

if (theta > light.cutOff) 
{
    // Lighting 계산 수행
}
else // Spotlight 외부에 있더라도 주변광(Ambient Light)이 있어 완전히 어둡지는 않다.
{
    color = vec4(light.ambient * vec3(texture(material.diffuse, TexCoords)), 1.0);
}

 

 

먼저 lightDir 벡터와 부호를 바꾼 light의 direction 벡터(광원으로부터 나오는 것이 아닌 광원을 향하는 벡터가 필요하기 때문)의 내적을 계산한다. (관련된 모든 벡터들을 정규화 했는지 확인한다)

theta와 light.cutOff는 코사인 값이기 때문에 각도가 0도일 때 코사인 값 1 로, 90도일 때 코사인 값 0 으로 나타내어진다. 따라서 theta가 light.cutOff보다 클 때 Fragment가 Spotlight 내부에 위치하는 것을 의미한다.

● 결과

 

● 부드러운 외곽선

보다시피 Spotlight가 명백한 외곽선을 가지고 있다. 현실적인 Spotlight는 외곽선에서 점차적으로 빛을 감소시킨다.

부드러운 외곽선을 가진 Spotlight를 생성하기 위해 inner(내부) 원뿔과 outer(외부) 원뿔을 가지는 Spotlight를 시뮬레이션해야 한다. 내부 원뿔은 이전에 정의했던 원뿔로 설정하고 내부 원뿔에서 외부 원뿔로 갈수록 점점 빛이 어두워지는 효과를 낼 것이다.

외부 원뿔을 생성하기 위해 간단히 Spotlight의 방향 벡터와 외부 원뿔의 벡터(원뿔의 반지름) 사이의 각에 대한 코사인 값을 정의하면 된다. 그 다음 Fragment가 내부 원뿔과 외부 원뿔 사이에 있으면 빛의 세기 값을 0.0 ~ 1.0 사이로 계산한다. Fragment가 내부 원뿔 안에 존재한다면 빛의 세기는 1.0과 같고 외부 원뿔의 바깥에 존재한다면 0.0과 같다.

다음 공식을 사용하여 값들을 계산할 수 있다.

 

 

여기서 𝜖 (엡실론)은 내부 원뿔(𝜙)과 외부 원뿔(𝛾) 사이의 코사인 값의 차이이다. I 값은 현재 Fragment에서의 Spotlight의 강도가 된다.

이제 우리는 빛의 세기 값을 가지고 있지만 이 값은 Spotlight 외부에 있으면 음수 값을 가지고, 내부 원뿔에 있을 때는 1.0보다 큰 값을 가지게 된다. 이 값을 적절하게 보정한 다음 계산된 세기 값을 light 요소들에 곱해줄 수 있다.

float theta = dot(lightDir, normalize(-light.direction));
float epsilon = light.cutOff - light.outerCutOff;
float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);    
...
// ambient에는 영향을 미치지 않는다.
diffuse  *= intensity;
specular *= intensity;
...

* 첫 번째 파라미터를 0.0 ~ 1.0 사이의 값으로 clamp 하여 세기 값이 [0, 1] 범위에서 벗어나지 않도록 한다.
* outerCutOff 값을 Light struct에 추가하고 응용 프로그램에서 이것의 unifrom 값을 설정한다. (내부 cutoff 각 12.5, 외부 cutoff 각 17.5)

● 결과

 

■ 소스 코드

- 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
    };

    // world space positions of our cubes
    glm::vec3 cubePositions[] = {
        glm::vec3(0.0f,  0.0f,  0.0f),
        glm::vec3(2.0f,  5.0f, -15.0f),
        glm::vec3(-1.5f, -2.2f, -2.5f),
        glm::vec3(-3.8f, -2.0f, -12.3f),
        glm::vec3(2.4f, -0.4f, -3.5f),
        glm::vec3(-1.7f,  3.0f, -7.5f),
        glm::vec3(1.3f, -2.0f, -2.5f),
        glm::vec3(1.5f,  2.0f, -2.5f),
        glm::vec3(1.5f,  0.2f, -1.5f),
        glm::vec3(-1.3f,  1.0f, -1.5f)
    };

    // 깊이 테스트 활성화
    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, &camera.Position[0]);
        glUniform3fv(glGetUniformLocation(lightingShader.ID, "light.direction"), 1, &camera.Front[0]);
        glUniform1f(glGetUniformLocation(lightingShader.ID, "light.cutOff"), glm::cos(glm::radians(12.5f)));
        glUniform1f(glGetUniformLocation(lightingShader.ID, "light.outerCutOff"), glm::cos(glm::radians(17.5f)));

        // 광원 색상 속성
        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.8f, 0.8f, 0.8f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "light.specular"), 1.0f, 1.0f, 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.ID, "light.constant"), 1.0f);
        glUniform1f(glGetUniformLocation(lightingShader.ID, "light.linear"), 0.09f);
        glUniform1f(glGetUniformLocation(lightingShader.ID, "light.quadratic"), 0.032f);

        // 머티리얼 속성 (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);

        // render boxes
        glBindVertexArray(cubeVAO);
        for (unsigned int i = 0; i < 10; i++)
        {
            // calculate the model matrix for each object and pass it to shader before drawing
            glm::mat4 model = glm::mat4(1.0f);
            model = glm::translate(model, cubePositions[i]);
            float angle = 20.0f * i;
            model = glm::rotate(model, glm::radians(angle), glm::vec3(1.0f, 0.3f, 0.5f));

            glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "model"), 1, GL_FALSE, glm::value_ptr(model));

            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 direction;
    float cutOff;
    float outerCutOff;

    vec3 ambient;
    vec3 diffuse;
    vec3 specular;

    float constant;
    float linear;
    float quadratic;
};

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;  
    
    // Attenuation (감쇠)
    float distance = length(light.position - FragPos);
    float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));
    ambient *= attenuation;
    diffuse *= attenuation;
    specular *= attenuation;

    // Spotlight (부드러운 외곽선)
    float theta = dot(lightDir, normalize(-light.direction)); 
    float epsilon = (light.cutOff - light.outerCutOff);
    float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
    diffuse *= intensity;
    specular *= intensity;

    vec3 result = ambient + diffuse + specular;
    FragColor = vec4(result, 1.0);
}

 

- 링크

https://learnopengl.com/code_viewer_gh.php?code=src/2.lighting/5.4.light_casters_spot_soft/light_casters_spot_soft.cpp