[OpenGL] Phong 조명 모델

■ Phong 조명 모델

OpenGL에서의 조명은 현실을 단순화한 모델을 사용하여 근사화한다. 이 모델들은 처리하기 훨씬 쉽고 현실과 비교적 유사하게 보인다.

OpenGl에서 주로 사용하는 조명 모델 중 Phong 조명 모델이 있다. Phong 조명 모델의 주요 구성 요소는 Ambient(주변광, 환경광), Diffuse(분산광, 난반사광), Specular(반사광, 정반사광) 조명으로 이루어져 있다.

 

 

■ Ambient Lighting

어두운 환경에서도 빛은 산란하여 오브젝트에 간접적으로 영향을 준다. 이를 시뮬레이션하기 위해 오브젝트 Fragment의 최종 컬러에 추가할 작은 상수 (빛) 컬러를 사용한다. 이는 직접적인 광원이 없다고 하더라도 항상 퍼지는 빛이 있는 것처럼보이게 만든다.

void main()
{
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;

    vec3 result = ambient * objectColor;
    FragColor = vec4(result, 1.0);
}

이 오브젝트는 어둡지만 Ambient Lighting이 적용되었기 때문에 완전히 어둡지는 않다.

 

■ Diffuse Lighting

광원과 오브젝트가 이루는 각도에 따라 빛의 영향이 달라진다. 광원에서 나온 빛이 오브젝트에 수직으로 향한다면 빛은 가장 많은 영향을 준다. Diffuse Lighting을 계산하기 위해서는 Vertex의 면에 수직인 Normal Vector (법선 벡터)와 The directed light ray (방향을 가진 광선) : 빛에서 Fragment로 향하는 방향 벡터가 필요하다.

● 법선 벡터

법선 벡터는 Vertex의 면에 수직인 (단위) 벡터이다. Vertex는 그저 하나의 점이기 때문에 Vertex의 면을 알아내기 위해 주변의 Vertex들을 사용하여 법선 벡터를 구한다. (여기서는 수작업으로 대입)

float vertices[] = {
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f, 
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f, 
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f, 
    -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f, 
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f, 

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

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

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

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

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

 

- Vertex Shader

Vertex 배열에 데이터를 추가했으므로 Lighting Vertex Shader를 수정한다.

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
...

 

 

Vertex Attribute Pointer에 새 Vertex 배열의 크기를 반영한다.

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

 

모든 빛에 대한 계산은 Fragment Shader에서 완료되므로 Vertex Shader의 법선 벡터를 Fragement Shader에 전달한다.

out vec3 Normal;

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    Normal = aNormal;
}

 

- Fragment Shader

Fragment Shader에 해당하는 입력 변수를 선언한다.

in vec3 Normal;

 

● Diffuse Color 계산

이제 각 Vertex에 대한 법선 벡터를 가지게 되었고, 빛의 방향 벡터를 구하기 위해 Fragment 위치 벡터와 빛의 위치 벡터가 필요하다.

- 변수 선언

빛의 위치는 하나의 정적 변수이기 때문에 Fragment Shader에 uniform으로 선언한다.

uniform vec3 lightPos;

 

렌더 루프에서 해당 uniform을 업데이트한다.

glUniform3fv(glGetUniformLocation(lightingShader.ID, "lightPos", 1, lightPos);

 

 

우리는 모든 빛에 대한 계산을 World Space에서 할 것이므로 World Space에 있는 Vertex 위치가 필요하다. 이는 Vertex 위치 Attribute를 model 행렬과 곱하여 World Space 좌표로 변환할 수 있다.

Vertex Shader에서 출력 변수 FragPos를 선언하고 계산한다.

out vec3 FragPos;  
out vec3 Normal;
  
void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    FragPos = vec3(model * vec4(aPos, 1.0));
    Normal = aNormal;
}

 

 

Fragment Shader에 해당하는 입력 변수를 선언한다.

in vec3 FragPos;

 

이제 필요한 모든 변수들이 설정되었고 Fragment Shader에서 빛에 대한 계산을 시작할 수 있다.

- 계산
광원의 위치 벡터에서 Fragment의 위치 벡터를 빼서 빛의 방향 벡터를 구하고 정규화한다.
* Lambertian 반사 모델에서는 Fragment에서 광원을 향하는 방향 벡터를 사용한다.
* 빛 계산 시 크기는 상관 없고 방향만 필요하기 때문에 정규화하여 단위 벡터로 수행한다.

vec3 norm = normalize(Normal);
vec3 lightDir = normalize(lightPos - FragPos);

 

다음으로 법선 벡터와 방향 벡터를 내적하여 실제 Diffuse 효과를 계산한다. 최종적으로 두 벡터 사이의 각도가 클수록 Diffuse 요소는 어두워진다.

float diff = max(dot(norm, lightDir), 0.0);
vec3 diffuse = diff * lightColor;

 

두 벡터 사이의 각도가 90도 보다 크면 내적의 결과가 음수가 되어 음의 Diffuse 요소를 가지게 된다. 이를 방지하기 위해 max 함수를 사용하여 Diffuse 요소와 컬러가 음의 값을 가질 수 없게 한다.

 

- 적용

계산한 Ambient와 Diffuse 요소를 사용하여 최종 Fragment의 컬러를 결정한다.

vec3 result = (ambient + diffuse) * objectColor;
FragColor = vec4(result, 1.0);

 

● 결과

 

● 소스 코드

https://learnopengl.com/code_viewer_gh.php?code=src/2.lighting/2.1.basic_lighting_diffuse/basic_lighting_diffuse.cpp

● 법선 행렬

현재는 법선 벡터를 Vertex Shader에서 Fragment Shader로 보내기만 했다. 하지만 Frament Shader에서 수행한 계산들은 모두 World Space 좌표에서 수행되므로 법선 벡터를 World Space 좌표로 변환해야 하지 않을까? 기본적으로는 맞다. 하지만 이를 단순히 model 행렬과 곱하는 것보다 복잡하다.

먼저 법선 벡터는 오직 방향 벡터로 공간에서 특정한 위치를 나타내지 않는다. 또한 법선 벡터는 동차 좌표 (w 요소)를 가지고 있지 않다. 이는 이동 변환이 법선 벡터에 아무 효과가 없다는 것을 의미한다. 그리고 법선 벡터에 model 행렬을 곱하고 싶다면 model 행렬 좌측 상단 3x3 행렬을 취하여 이동 행렬의 일부를 지워야 한다. 우리가 법선 벡터에 적용할 것은 스케일과 회전 변환이다.

두 번째로 model 행렬이 불균일 스케일을 수행하면 Vertex들이 수정되어 법선 벡터가 더 이상 해당 면과 수직이 되지 않는다. 따라서 이 model 행렬로 법선 벡터를 변환할 수 없다.

 

 

이를 해결하기 위해 특별히 법선 벡터에 맞춰 만들어진 다른 model 행렬을 사용하는 것이다. 이 행렬은 법선 행렬이라고 불리며 법선 벡터를 잘못된 형태로 스케일링하는 효과를 지워주는 연산을 사용한다.

Vertex Shader에서 inverse, transpose 함수를 사용해 법선 행렬을 생성할 수 있다. 이는 행렬을 3x3 행렬로 변환하므로 이동 속성을 잃지만 vec3 법선 벡터와 곱셈을 할 수 있다.

// 법선 행렬
Normal = mat3(transpose(inverse(model))) * aNormal;

 

현재는 오브젝트에 어떤 스케일 연산도 수행하지 않았기 때문에 괜찮지만 나중에 불균일 스케일을 수행한다면 법선 벡터에 반드시 이 법선 행렬을 곱해주어야 한다.

* 역행렬로 변환하는 것은 비용이 많이 드는 연산이므로 CPU에서 법선 행렬을 계산하고 렌더링 하기 전에 uniform을 통해 Shader로 전달하도록 하자. (model 행렬처럼)

 

■ Specular Lighting

Diffuse Lighting과 마찬가지로 Specular Lighting은 빛의 방향 벡터와 오브젝트의 법선 벡터를 기반으로 하지만, 플레이어가 Fragment를 바라보고 있는 방향에 대한 View 벡터도 기반으로 한다. 오브젝트의 면을 거울이라고 생각하면 이 면에서 반사되어진 빛을 보는 Specular Lighting은 가장 센 빛일것이다.

 

 

법선 벡터를 기준으로 빛의 방향을 반사하여 반사 벡터를 계산한 다음 이 반사 벡터와 View 벡터 사이의 Angular Distance (각 거리)를 계산한다. 두 벡터 사이의 각이 가까울수록 Specular Light의 강도는 강해진다.

View 벡터는 Specular Lighting에 필요한 변수로 Viewer의 World Space 위치와 Fragment들의 위치를 사용하여 계산할 수 있다. 그런 다음 Specular의 강도를 계산하고 이를 빛의 색상과 곱하여 Ambient, Diffuse 요소에 추가한다.

Viewer의 World Space 좌표를 얻기 위해서 카메라 오브젝트(Viewer)의 위치 벡터를 사용하면 된다. 이제 Fragment Shader에 다른 uniform을 추가하고 해당 카메라 위치 벡터를 Fragment Shader에 전달한다.

// Fragment Shader
uniform vec3 viewPos;

 

// main
glUniform3fv(glGetUniformLocation(lightingShader.ID, "viewPos"), 1, &(camera.Position)[0]);

 

이제 필요한 모든 변수가 준비되었으므로 Specular 세기를 계산할 수 있다.

float specularStrength = 0.5f;

 

그 다음 View 방향 벡터와 해당 반사 벡터를 계산한다.

vec3 viewDir = normalize(viewPos - FragPos);
vec3 reflectDir = reflect(-lightDir, norm);

 

* lightDir 벡터는 Fragment로부터 광원으로 향하는 벡터이므로 reflect 함수에서 사용하기 위해 부호를 반대로 바꾸어 사용한다.

 

최종 Specular 요소를 계산한다.

float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
vec3 specular = specularStrength * spec * lightColor;

 

먼저 View 벡터와 Reflect 벡터를 내적한 뒤 32제곱 한다. 이 값이 높을 수록 빛을 주변에 퍼지게 하지 않고 반사한다.

* 내적한 값이 음수가 되지 않도록 한다.

마지막으로 이 요소를 Ambient와 Diffuse 요소에 추가하고 오브젝트 컬러의 결과값에 곱해 혼합한다.

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

 

● 결과

 

■ 최종 소스 코드

- main

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

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

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

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(1.2f, 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[] = {
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
         0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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();
        //lightingShader.setVec3("objectColor", 1.0f, 0.5f, 0.31f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "objectColor"), 1.0f, 0.5f, 0.31f);
        //lightingShader.setVec3("lightColor", 1.0f, 1.0f, 1.0f);
        glUniform3f(glGetUniformLocation(lightingShader.ID, "lightColor"), 1.0f, 1.0f, 1.0f);
        //lightingShader.setVec3("lightPos", lightPos);
        glUniform3fv(glGetUniformLocation(lightingShader.ID, "lightPos"), 1, &lightPos[0]);
        //lightingShader.setVec3("viewPos", camera.Position);
        glUniform3fv(glGetUniformLocation(lightingShader.ID, "viewPos"), 1, &(camera.Position)[0]);

        // 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();
        //lightingShader.setMat4("projection", projection);
        glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        //lightingShader.setMat4("view", view);
        glUniformMatrix4fv(glGetUniformLocation(lightingShader.ID, "view"), 1, GL_FALSE, glm::value_ptr(view));

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

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

        // 광원 큐브 렌더
        lightCubeShader.use();
        //lightCubeShader.setMat4("projection", projection);
        glUniformMatrix4fv(glGetUniformLocation(lightCubeShader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
        //lightCubeShader.setMat4("view", view);
        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
        //lightCubeShader.setMat4("model", model);
        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));
}

 

- Vertex Shader

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;

out vec3 FragPos;
out vec3 Normal;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main()
{
    FragPos = vec3(model * vec4(aPos, 1.0));
    Normal = aNormal;  
    
    gl_Position = projection * view * vec4(FragPos, 1.0);
}

 

- Fragment Shader

#version 330 core
out vec4 FragColor;

in vec3 Normal;  
in vec3 FragPos;  
  
uniform vec3 lightPos; 
uniform vec3 viewPos; 
uniform vec3 lightColor;
uniform vec3 objectColor;

void main()
{
    // ambient
    float ambientStrength = 0.1;
    vec3 ambient = ambientStrength * lightColor;
  
    // diffuse 
    vec3 norm = normalize(Normal);
    vec3 lightDir = normalize(lightPos - FragPos);
    float diff = max(dot(norm, lightDir), 0.0);
    vec3 diffuse = diff * lightColor;
    
    // specular
    float specularStrength = 0.5;
    vec3 viewDir = normalize(viewPos - FragPos);
    vec3 reflectDir = reflect(-lightDir, norm);  
    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
    vec3 specular = specularStrength * spec * lightColor;  
        
    vec3 result = (ambient + diffuse + specular) * objectColor;
    FragColor = vec4(result, 1.0);
}

 

- 링크

https://learnopengl.com/code_viewer_gh.php?code=src/2.lighting/2.2.basic_lighting_specular/basic_lighting_specular.cpp