์์ด๋๋ GPU์ ์กด์ฌํ๋ ์์ ํ๋ก๊ทธ๋จ๋ค๋ก, ๊ทธ๋ํฝ ํ์ดํ๋ผ์ธ์ ํน์ ๋ถ๋ถ๋ง๋ค ์คํ๋ฉ๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก, ์์ด๋๋ ์ ๋ ฅ์ ์ถ๋ ฅ์ผ๋ก ๋ณํํ๋ ํ๋ก๊ทธ๋จ์ ๋ถ๊ณผํฉ๋๋ค.
์์ด๋๋ ์๋ก ํต์ ํ ์ ์๋ ๋งค์ฐ ๋ ๋ฆฝ์ ์ธ ํ๋ก๊ทธ๋จ์ด๋ฉฐ, ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ํตํด์๋ง ํต์ ํ ์ ์์ต๋๋ค.
์ด์ ์ฅ์์ ์ฐ๋ฆฌ๋ ์์ด๋์ ๊ทธ ์ฌ์ฉ ๋ฐฉ๋ฒ์ ๋ํด ๊ฐ๋จํ ๋ค๋ฃจ์์ต๋๋ค. ์ด์ ์์ด๋, ํนํ OpenGL Shading Language์ ๋ํด ์ข ๋ ์ผ๋ฐ์ ์ผ๋ก ์ค๋ช ํ๊ฒ ์ต๋๋ค.
GLSL
์์ด๋๋ C์ ์ ์ฌํ ์ธ์ด์ธ GLSL๋ก ์์ฑ๋ฉ๋๋ค. GLSL์ ๊ทธ๋ํฝ์ฉ์ผ๋ก ์ ์๋์์ผ๋ฉฐ ๋ฒกํฐ์ ํ๋ ฌ ์กฐ์์ ํนํ๋ ์ ์ฉํ ๊ธฐ๋ฅ์ ํฌํจํ๊ณ ์์ต๋๋ค.
์์ด๋๋ ํญ์ ๋ฒ์ ์ ์ธ์ผ๋ก ์์ํ ํ, ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ ๋ณ์, ์ ๋ํผ ๋ฐ ๋ฉ์ธ ํจ์์ ๋ชฉ๋ก์ด ์ด์ด์ง๋๋ค.
๊ฐ ์์ด๋์ ์ง์ ์ ์ ์ ๋ ฅ ๋ณ์๋ฅผ ์ฒ๋ฆฌํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅ ๋ณ์์ ์ถ๋ ฅํ๋ ๋ฉ์ธ ํจ์์ ๋๋ค.
์ ๋ํผ์ด ๋ฌด์์ธ์ง ๋ชจ๋ฅด๋๋ผ๋ ๊ฑฑ์ ํ์ง ๋ง์ธ์. ์ฐ๋ฆฌ๋ ๊ณง ๊ทธ๊ฒ์ ๋ํด ์ค๋ช ํ ๊ฒ์ ๋๋ค.
์์ด๋๋ ์ผ๋ฐ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋๋ค.
#version version_number
in type in_variable_name;
in type in_variable_name;
out type out_variable_name;
uniform type uniform_name;
void main()
{
// ์
๋ ฅ ์ฒ๋ฆฌ ๋ฐ ์ผ๋ถ ๊ทธ๋ํฝ ์์
์ํ
...
// ์ฒ๋ฆฌ๋ ๋ด์ฉ์ ์ถ๋ ฅ ๋ณ์์ ์ถ๋ ฅ
out_variable_name = weird_stuff_we_processed;
}
์ ์ ์์ด๋์ ๊ดํด์๋, ๊ฐ ์ ๋ ฅ ๋ณ์๋ฅผ ์ ์ ์์ฑ์ด๋ผ๊ณ ๋ ํฉ๋๋ค.
ํ๋์จ์ด์ ์ํด ์ ํ๋๋ ์ ์ ์์ฑ์ ์ต๋ ๊ฐ์๊ฐ ์์ผ๋ฉฐ, OpenGL์ ํญ์ ์ต์ 16๊ฐ์ 4-์ปดํฌ๋ํธ ์ ์ ์์ฑ์ ๋ณด์ฅํฉ๋๋ค.
ํ์ง๋ง ์ผ๋ถ ํ๋์จ์ด์์๋ ๋ ๋ง์ ๊ฒ์ ํ์ฉํ ์ ์์ผ๋ฉฐ, GL_MAX_VERTEX_ATTRIBS๋ฅผ ์กฐํํ์ฌ ํ์ธํ ์ ์์ต๋๋ค.
int nrAttributes;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
std::cout << "Maximum nr of vertex attributes supported: " << nrAttributes << std::endl;
Types
GLSL์ ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ฒ๋ผ, ์ฐ๋ฆฌ๊ฐ ์์ ํ๊ณ ์ ํ๋ ๋ณ์์ ์ข ๋ฅ๋ฅผ ์ง์ ํ๊ธฐ ์ํ ๋ฐ์ดํฐ ํ์ ์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
GLSL์๋ C ์ธ์ด์ ๊ฐ์ ์ธ์ด์์ ์๊ณ ์๋ ๋๋ถ๋ถ์ ๊ธฐ๋ณธ ๊ธฐ๋ณธ ํ์ ์ด ์์ต๋๋ค.
int, float, double, uint, bool. ๋ํ GLSL์๋ ๋ฒกํฐ์ ํ๋ ฌ ๋ ๊ฐ์ง ์ปจํ ์ด๋ ํ์ ์ด ์์ผ๋ฉฐ, ์ด๋ค์ ์์ฃผ ์ฌ์ฉ๋ ๊ฒ์ ๋๋ค.
ํ๋ ฌ์ ๋ํด์๋ ๋์ค์ ๋ค๋ฃฐ ์์ ์ ๋๋ค.
Vectors
GLSL์ ๋ฒกํฐ๋ ๋ฐฉ๊ธ ์ธ๊ธํ ๊ธฐ๋ณธ ํ์ ์ 2, 3, ๋๋ 4๊ฐ ๊ตฌ์ฑ ์์๋ฅผ ๊ฐ์ง ์ปจํ ์ด๋์ ๋๋ค.
๋ค์๊ณผ ๊ฐ์ ํํ๋ฅผ ์ทจํ ์ ์์ต๋๋ค(n์ ๊ตฌ์ฑ ์์์ ์๋ฅผ ๋ํ๋ ๋๋ค)
vecn: n๊ฐ์ float๋ก ๊ตฌ์ฑ๋ ๊ธฐ๋ณธ ๋ฒกํฐ.
bvecn: n๊ฐ์ boolean์ผ๋ก ๊ตฌ์ฑ๋ ๋ฒกํฐ.
ivecn: n๊ฐ์ integer๋ก ๊ตฌ์ฑ๋ ๋ฒกํฐ.
uvecn: n๊ฐ์ unsigned integer๋ก ๊ตฌ์ฑ๋ ๋ฒกํฐ.
dvecn: n๊ฐ์ double ๊ตฌ์ฑ ์์๋ก ๊ตฌ์ฑ๋ ๋ฒกํฐ.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ, float์ด๋ฉด ์ถฉ๋ถํ๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ณธ์ ์ธ vecn์ ์ฌ์ฉํ ๊ฒ์ ๋๋ค.
๋ฒกํฐ์ ๊ตฌ์ฑ ์์๋ vec.x์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ์ฌ๊ธฐ์ x๋ ๋ฒกํฐ์ ์ฒซ ๋ฒ์งธ ๊ตฌ์ฑ ์์์ ๋๋ค.
.x, .y, .z, .w๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๊ฐ ์ฒซ ๋ฒ์งธ, ๋ ๋ฒ์งธ, ์ธ ๋ฒ์งธ, ๋ค ๋ฒ์งธ ๊ตฌ์ฑ ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค.
GLSL์ ์์์ ๋ํด rgba๋ ํ ์ค์ฒ ์ขํ์ ๋ํด stpq๋ฅผ ์ฌ์ฉํ์ฌ ๋์ผํ ๊ตฌ์ฑ ์์์ ์ ๊ทผํ ์ ์๋๋ก ํ์ฉํฉ๋๋ค.
๋ฒกํฐ ๋ฐ์ดํฐ ํ์ ์ ์ค์์ฆ๋ง์ด๋ผ๊ณ ๋ถ๋ฆฌ๋ ํฅ๋ฏธ๋กญ๊ณ ์ ์ฐํ ๊ตฌ์ฑ ์์ ์ ํ์ ํ์ฉํฉ๋๋ค.
์ค์์ฆ๋ง์ ์ฌ์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ฌธ๋ฒ์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
vec2 someVec;
vec4 differentVec = someVec.xyxx;
vec3 anotherVec = differentVec.zyw;
vec4 otherVec = someVec.xxxx + anotherVec.yxzy;
์ต๋ 4๊ฐ์ ๋ฌธ์๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก์ด ๋ฒกํฐ(๋์ผํ ํ์ )๋ฅผ ์์ฑํ ์ ์์ผ๋ฉฐ, ์๋ ๋ฒกํฐ๊ฐ ํด๋น ๊ตฌ์ฑ ์์๋ฅผ ๊ฐ์ง๊ณ ์๋ ํ ๊ฐ๋ฅํฉ๋๋ค;
์๋ฅผ ๋ค์ด, vec2์ .z ๊ตฌ์ฑ ์์์ ์ ๊ทผํ๋ ๊ฒ์ ํ์ฉ๋์ง ์์ต๋๋ค.
๋ํ ๋ฒกํฐ๋ฅผ ๋ค๋ฅธ ๋ฒกํฐ ์์ฑ์ ํธ์ถ์ ์ธ์๋ก ์ ๋ฌํ์ฌ ํ์ํ ์ธ์์ ์๋ฅผ ์ค์ผ ์ ์์ต๋๋ค.
vec2 vect = vec2(0.5, 0.7);
vec4 result = vec4(vect, 0.0, 0.0);
vec4 otherResult = vec4(result.xyz, 1.0);
๋ฐ๋ผ์ ๋ฒกํฐ๋ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ์ฉํ ์ ์๋ ์ ์ฐํ ๋ฐ์ดํฐ ํ์ ์ ๋๋ค.
์ด ์ฑ ์ ํตํด ๋ฒกํฐ๋ฅผ ์ฐฝ์์ ์ผ๋ก ๊ด๋ฆฌํ๋ ๋ค์ํ ์๋ฅผ ๋ณผ ์ ์์ ๊ฒ์ ๋๋ค.
Ins and outs
์์ด๋๋ ์์ฒด์ ์ผ๋ก ๋ฉ์ง ์์ ํ๋ก๊ทธ๋จ์ด์ง๋ง, ์ ์ฒด์ ์ผ๋ถ๋ก ๋์ํ๊ธฐ ๋๋ฌธ๋ฐ
๊ฐ๋ณ ์์ด๋์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ด ์์ด์ผ ํฉ๋๋ค. ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ด๋์ํฌ ์ ์์ต๋๋ค.
GLSL์ ์ด ๋ชฉ์ ์ ์ํด in๊ณผ out ํค์๋๋ฅผ ์ ์ํ์ต๋๋ค.
์ถ๋ ฅ ๋ณ์๊ฐ ๋ค์ ์์ด๋ ๋จ๊ณ์ ์ ๋ ฅ ๋ณ์์ ์ผ์นํ ๊ฒฝ์ฐ ์ ๋ฌ๋ฉ๋๋ค.
vertex shader๋ ์ด๋ค ํํ์ ์ ๋ ฅ์ ๋ฐ์์ผ ํ๋ฉฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด ๊ต์ฅํ ๋นํจ์จ์ ์ด๊ฒ ๋ฉ๋๋ค.
์ ์ ์์ด๋๋ ์ ๋ ฅ์ ์ ์ ๋ฐ์ดํฐ๋ก ๋ถํฐ ์ง์ ๋ฐ๋๋ค๋ ์ ์์ ๋ค๋ฆ ๋๋ค.
์ ์ ๋ฐ์ดํฐ์ ๊ตฌ์ฑ์ ์ ์ํ๊ธฐ ์ํด ์์น ๋ฉํ๋ฐ์ดํฐ์ ํจ๊ป ์ ๋ ฅ ๋ณ์๋ฅผ ์ง์ ํ์ฌ CPU์์ ์ ์ ์์ฑ์ ๊ตฌ์ฑํ ์ ์์ต๋๋ค.
์ด์ ์ฅ์์ laouy(location = 0) ์ผ๋ก ์ด๋ฅผ ๋ณด์์ต๋๋ค.
๋ฐ๋ผ์ ์ ์ ์์ด๋๋ ์ ์ ๋ฐ์ดํฐ์ ์ฐ๊ฒฐํ๊ธฐ ์ํด ์ ๋ ฅ์ ๋ํ ์ถ๊ฐ ๋ ์ด์์ ์ฌ์์ด ํ์ํฉ๋๋ค.
fragment shader๋ vec4 ์์ ์ถ๋ ฅ ๋ณ์๊ฐ ํ์ํฉ๋๋ค.
์์ ์ถ๋ ฅ์ ์ง์ ํ์ง ์์ผ๋ฉด ์ผ๋ฐ์ ์ผ๋ก OpenGL์ ์ด๋ฅผ ๊ฒ์์์ด๋ ํฐ์์ผ๋ก ๋ ๋๋ง ํฉ๋๋ค.
ํ์ ๊ณผ ์ด๋ฆ์ด ์์ชฝ ์์ด๋์์ ๋์ผํ๋ฉด OpenGL์ ์ด๋ฌํ ๋ณ์๋ฅผ ์ฐ๊ฒฐํ๊ณ ํ๋ก๊ทธ๋จ ๊ฐ์ฒด๋ฅผ ์ฐ๊ฒฐํ ๋
์์ด๋ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ณด๋ผ ์ ์์ต๋๋ค.
Vertex Shader
#version 330 core
layout (location = 0) in vec3 aPos; // the position variable has attribute position 0
out vec4 vertexColor; // specify a color output to the fragment shader
void main()
{
gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor
vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color
}
Fragment Shader
#version 330 core
out vec4 FragColor;
in vec4 vertexColor; // the input variable from the vertex shader (same name and same type)
void main()
{
FragColor = vertexColor;
}
์์์ ์ ์ ์์ด๋์ vec4 ์ถ๋ ฅ์ผ๋ก vertexColor ๋ณ์๋ฅผ ์ ์ธํ๊ณ ์ค์ ํ๊ณ ,
fragment shader์์ vertexColor๋ฅผ ์ ๋ ฅ์ผ๋ก ์ ์ธํ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
๋ ๋ณ์ ๋ชจ๋ ๊ฐ์ ํ์ ๊ณผ ์ด๋ฆ์ ๊ฐ์ง๋ฏ๋ก, ์กฐ๊ฐ ์์ด๋์ vertexColor๋ ์ ์ ์์ด๋์ vertexColor์ ์ฐ๊ฒฐ๋ฉ๋๋ค.
์ ์ ์์ด๋์์ ์์์ ์ด๋์ด ๋นจ๊ฐ์์ผ๋ก ์ค์ ํ๊ธฐ ๋๋ฌธ์, ๊ฒฐ๊ณผ์ ์ผ๋ก ์์ฑ๋๋ ์กฐ๊ฐ๋ค๋ ์ด๋์ด ๋นจ๊ฐ์์ด์ด์ผ ํฉ๋๋ค. ๋ค์ ์ด๋ฏธ์ง๋ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ์ค๋๋ค.

'๐ธ OpenGL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Learn OpenGL] Shaders - 3 (0) | 2023.11.18 |
|---|---|
| [Learn OpenGL] Shaders - 2 (0) | 2023.11.18 |
| [Learn OpenGL] Hello Triangle - 4 (0) | 2023.11.18 |
| [Learn OpenGL] Hello Triangle - 3 (0) | 2023.11.17 |
| [Learn OpenGL] Hello Triangle - 2 (0) | 2023.11.17 |