[OpenGL] Shader

■ Shader

셰이더는 GPU에서 동작하는 작은 프로그램으로 각자 그래픽 파이프라인의 특정 부분을 맡아 수행한다.
기본적인 의미에서 셰이더는 입력값을 받아 변환시켜 출력값을 반환하는 프로그램이다.
셰이더는 독립적인 프로그램으로 서로 소통할 수 없으며 입력값과 출력값을 통해서만 소통할 수 있다.

■ GLSL

셰이더는 C언어와 비슷한 GLSL로 작성된다.
셰이더는 버전 선언, 입출력 변수, uniform, main 함수로 구성된다.

셰이더의 대표적인 구조

#version version_number

in type in_variable_name;
out type out_variable_name;

uniform type uniform_name;
  
void main()
{
	// 입력 값을 받아 그래픽 작업 처리된 것을 출력 변수로 출력
    out_variable_name = weird_stuff_we_processed;
}

- GLSL은 C언어와 같이 기본적인 타입 (int, float, double, uint, bool)을 가지고 있으며 GLSL의 컨테이너 타입 vector와 matrices가 있다.

● Vector

vector는 기본적인 타입의 요소를 1~4개 가진 컨테이너이다.

- vecn : n개의 float 타입 요소를 가지는 vector
- bvecn : n개의 boolean 타입 요소를 가지는 vector
- ivecn : n개의 integer 타입 요소를 가지는 vector
- uvecn : n개의 unsigned integer 타입 요소를 가지는 vector
- dvecn : n개의 double 타입 요소를 가지는 vector
ex) vec3 : 3개의 float 타입 요소를 가지는 vector

- Vector의 요소들은 '.' 을 통해 접근할 수 있다.
- 첫 번째, 두 번째, 세 번째, 네 번째 요소들을 각각 접근하기 위해 .x, .y, .z, .w를 사용할 수 있다. 
- GLSL에서 컬러는 rgba를 사용하여 나타낼 수 있고, 텍스쳐 좌표는 stpq를 사용하여 나타낼 수 있다.

● Swizzling
Swizzling은 벡터 타입의 변수에서 구성 요소를 선택하고 재배치하는 기능으로 코드의 간결성을 높이고 벡터 연산을 직관적으로 수행할 수 있게 도와준다.

 

vec4 v = vec4(1.0, 2.0, 3.0, 4.0);

// 선택
float x = v.x;

// 재배치
vec2 xy = v.xy;
vec3 yzx = v.yzx;

// 조합
vec3 rgb = v.xyz;

* 동일한 구성 요소를 중복해서 선택할 수도 있다. (v.xx)
* 읽기와 쓰기를 동시에 할 수는 없다. (v.xy = v.zw 같은 코드는 불가능)

● 입력과 출력

셰이더는 각각의 작은 프로그램이기 때문에 세이더마다 입력과 출력이 필요하다.
GLSL은 'in' 과 'out' 키워드로 입력과 출력을 정의하고 넘긴다.

- Vertex Shader
Vertex Shader에서 각각의 입력 변수는 Vertex Attribute라고 부른다.
* 하드웨어에 의해 Vertex Attribute를 선언할 수 있는 최대 갯수가 정해져 있다.

layout (location = 0) in vec3 aPos;
out vec4 vertexColor;

- layout 키워드로 변수의 특정 속성을 설정하며 (location = 0) 명시를 통해 이 입력 변수가 0번 위치에 매핑되었음을 의미한다.
- in 키워드로 이 변수가 Vertex Shader의 입력임을 나타낸다.
- out 키워드로 Vertex Shader의 출력 변수임을 나타내고 Fragment Shader에 전달할 데이터를 담는다. (여기서는 vec4타입으로 색상 데이터를 저장)

- Fragment Shader

in vec4 vertexColor;
out vec4 FragColor;

- 타입과 이름이 같게 선언하여 vertexColor 변수를 Vertex Shader의 출력 변수와 연결시킨다.

● Uniforms

uniform은 CPU의 응용 프로그램에서 GPU의 셰이더로 데이터를 전달하는 변수 타입이다.
uniform 변수는 CPU에서 설정되고 GPU에서 읽기 전용으로 사용된다.

○ 특징
- global : uniform 변수는 셰이더 프로그램 객체마다 유니크하고 셰이더 프로그램의 모든 단계의 셰이더에서 접근이 가능하다.
- readonly : uniform의 값을 설정하면 reset되거나 update되기 전까지 그 값을 유지한다.

○ 선언
shader에 타입, 이름과 함께 uniform 키워드를 추가한다.

uniform vec4 ourColor;

* 코드에서 사용되지 않는 uniform을 선언했다면 자동으로 해당 변수는 컴파일러에 의해 컴파일 된 버전에서는 삭제되므로 주의

○ 사용
먼저 shader에서 uniform attribute의 index / location을 찾아야 한다. 찾은 뒤에 값을 변경할 수 있다.

// color value로 변하는 값 지정 (0~1 사이 왕복)
float timeValue = glfwGetTime();
float greenValue = (sin(timeValue) / 2.0f) + 0.5f;

// ourColor의 location을 확인
int vertexColorLocation = glGetUniformLocation(shaderProgram, "ourColor");

// 유니폼 변수의 값을 설정
glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);

- glGetUniformLocation(셰이더 프로그램, uniform 이름);
uniform 변수의 location을 찾는다.
* 함수가 -1을 반환한다면 location을 찾지 못한 것

- glUniform4f(location, float값 1, float값 2, float값 3, float값 4);
uniform 변수에 4개의 float 값을 설정한다. (uniform 변수를 통해 셰이더에 데이터를 전달)
* 값 전달 전 해당 uniform 변수가 포함된 셰이더 프로그램이 활성화 되어 있어야 한다. (glUseProgram 먼저 호출 필요)
* OpenGL은 타입 오버로딩을 지원하지 않기 때문에 접미사를 붙여 새 함수를 정의한다. (f, i, ui, 3f, fv...)

● 소스 코드

https://learnopengl.com/code_viewer_gh.php?code=src/1.getting_started/3.1.shaders_uniform/shaders_uniform.cpp

■ Attribute 추가하기

// 기존 위치데이터에 컬러 데이터 추가
float vertices[] = {
    // 위치              // 컬러
     0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // 우측 하단
    -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // 좌측 하단
     0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 위 
};

- Vertex Shader

#version 330 core
layout (location = 0) in vec3 aPos;   // 위치 변수는 attribute position 0을 가진다.
layout (location = 1) in vec3 aColor; // 컬러 변수는 attribute position 1을 가진다.
out vec3 ourColor; // 컬러를 fragment shader로 출력

void main()
{
    gl_Position = vec4(aPos, 1.0);
    ourColor = aColor; // vertex data로부터 가져온 입력값을 출력 변수 ourColor에 설정
}

- Fragment Shader

#version 330 core
in vec3 ourColor;
out vec4 FragColor;

void main()
{
    FragColor = vec4(ourColor, 1.0);
}

- 레이아웃을 알기 때문에 glVertexAttribPointer 함수를 사용하여 vertex 형식을 수정할 수 있다.

// 위치 attribute
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// 컬러 attribute
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3* sizeof(float)));
glEnableVertexAttribArray(1);

* 매개변수 설명
1. location (위치 attribute는 location 0, 컬러 attribute는 location 1에 설정)
2. attribute 구성 요소의 개수 (3개의 float x,y,z)
3. 구성 요소의 데이터 타입 (GL_FLOAT)
4. 정규화 여부 (GL_FALSE)
5. stride 크기 : 다음 attribute까지의 바이트 수 (위치 3개, 컬러 3개 총 6개의 float = 6 * sizeof(float))
6. offset : VBO의 시작 위치로부터 해당 attribute가 시작되는 위치 (위치 attribute는 시작 위치가 0, 컬러 attribute는 위치 attribute가 끝난 다음이므로 시작 위치가 3 * sizeof(float))

 

● 소스 코드

https://learnopengl.com/code_viewer_gh.php?code=src/1.getting_started/3.2.shaders_interpolation/shaders_interpolation.cpp

- 이 결과는 Fragment Shader의 Fragment Interpolation이라고 불린다. (정점 사이의 모든 프래그먼트에 대해 속성을 보간하여 계산)

■ Shader 클래스

Shader들을 읽고 컴파일하고 연결한 후 오류를 확인하는 클래스를 생성한다.
이후 main에서 #include <Shader.h> 하여 사용

 

#ifndef SHADER_H
#define SHADER_H

#include <glad/glad.h>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader
{
public:
    // Program ID
    unsigned int ID;

    // 생성자에서 Shader를 읽고 생성
    Shader(const char* vertexPath, const char* fragmentPath)
    {
        // 1. 파일 경로를 통해 Vertex/Fragment Shader 소스 코드를 검색한다.
        std::string vertexCode;
        std::string fragmentCode;
        std::ifstream vShaderFile;
        std::ifstream fShaderFile;

        // 예외 처리를 위한 ifsteam 객체
        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;

            // 파일의 버퍼 내용을 읽어 stream에 저장
            vShaderStream << vShaderFile.rdbuf();
            fShaderStream << fShaderFile.rdbuf();

            // 파일 핸들러 닫기
            vShaderFile.close();
            fShaderFile.close();

            // stream을 string으로 변환
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
        }
        catch (std::ifstream::failure& e)
        {
            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << e.what() << std::endl;
        }

        const char* vShaderCode = vertexCode.c_str();
        const char* fShaderCode = fragmentCode.c_str();

        // 2. Shader를 컴파일한다.
        unsigned int vertex, fragment;

        // Vertex Shader
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex, 1, &vShaderCode, NULL);
        glCompileShader(vertex);
        checkCompileErrors(vertex, "VERTEX");

        // Fragment Shader
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment, 1, &fShaderCode, NULL);
        glCompileShader(fragment);
        checkCompileErrors(fragment, "FRAGMENT");

        // Shader Program
        ID = glCreateProgram();
        glAttachShader(ID, vertex);
        glAttachShader(ID, fragment);
        glLinkProgram(ID);
        checkCompileErrors(ID, "PROGRAM");

        // 프로그램에 연결되어 필요 없어진 Shader들 제거
        glDeleteShader(vertex);
        glDeleteShader(fragment);
    }

    void use()
    {
        glUseProgram(ID);
    }

    void setBool(const std::string& name, bool value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
    }

    void setInt(const std::string& name, int value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
    }

    void setFloat(const std::string& name, float value) const
    {
        glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
    }

private:
    // 컴파일, 연결 오류 체크
    void checkCompileErrors(unsigned int shader, std::string type)
    {
        int success;
        char infoLog[1024];
        if (type != "PROGRAM")
        {
            glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
            if (!success)
            {
                glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
        else
        {
            glGetProgramiv(shader, GL_LINK_STATUS, &success);
            if (!success)
            {
                glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
    }
};

#endif