Z-buffering
โข
Z-buffer๋ ํ๋ฉด์ ๊ฐ ์ (pixel)์ด ์ผ๋ง๋ ์นด๋ฉ๋ผ์์ ๋ฉ๋ฆฌ ์๋์ง๋ฅผ ์ ์ฅํ๋ ํ
โข
์ด๊ฑธ ์ด์ฉํด์ ๋ ๊ฐ๊น์ด ๋ฌผ์ฒด๋ง ๋ณด์ด๊ฒ ํ๊ณ , ๋ค์ ์๋ ๊ฑด ๊ฐ๋ฆผ
โข
์ปดํจํฐ๊ฐ ๋ฌผ์ฒด๋ฅผ ํ๋ฉด์ ๊ทธ๋ฆฌ๋ ค๊ณ ํ ๋, ๊ทธ ๋ฌผ์ฒด์ ํฝ์
์ด ํ๋ฉด์ ์ด๋์ ์์นํ ์ง๋ฅผ ๊ณ์ฐํ๊ณ , ๊ทธ ํฝ์
์ Z๊ฐ(๊น์ด)์ ํ์ธ โ ๋ง์ฝ ๊ทธ ํฝ์
์ด ๋ ์์ ์๋ค๋ฉด, ๊ธฐ์กด ๊ฒ์ ๋ฎ์ด์ฐ๊ณ Z-buffer๋ ์
๋ฐ์ดํธ. ๋ง์ฝ ๋ค์ ์๋ค๋ฉด, ๋ฌด์ํ๊ณ ์๋ ์๋ ๊ฑธ ๊ทธ๋๋ก ๋๋ค.
semicolon
โข
glsl ๊ฐ๋ฐํ ๋ ๋ฐ๋์ ์ธ๋ฏธ์ฝ๋ก ์ ์์ง ๋ง ๊ฒ.
vec: ivec, bvec
โข
ivec: int vector
โข
bvec: bool vector
vertext shader, fragment shader
โข
void๋ฅผ returnํ๋ main function์ด ๋ฐ๋์ ์กด์ฌํด์ผ ํจ
โข
vertex shader๋ gl_Position์ ๊ฐ์, fragment shader๋ gl_FragColor, gl_FragCoord์ ๊ฐ์ ํ ๋นํ ์ ์๋ค.
uniforms
โข
uniforms๋ฅผ ํตํด javascript์์ ๋ง๋ ๊ฐ์ shader์ ์ ๋ฌํ ์ ์๋ค.
const uniforms = {
u_time: { value: 0.0 },
u_mouse: { value: { x: 0.0, y: 0.0 } },
u_resolution: { value: { x: 0.0, y: 0.0 } },
u_color: { value: new THREE.Color(0, 1, 1) },
};
const material = new THREE.ShaderMaterial({
uniforms,
vertexShader: vshader,
fragmentShader: fshader,
});
JavaScript
๋ณต์ฌ
sin, cos
โข
-1 ~ 1 ์ฌ์ด์ ๊ฐ ๋ฐํ
โข
(sin(u_time) + 1.0)/2: ์๊ฐ์ ํ๋ฆ์ ๋ฐ๋ผ sin(u_time)์ -1 ~ 1 ์ฌ์ด์ ๊ฐ์ ๋ฐํ. -1์ด color์ rgba ๊ฐ์ผ๋ก ๋ค์ด๊ฐ๋ฉด ์๋๋ฏ๋ก ์ด ๊ฒฝ์ฐ์๋ + 1์ ํด์ค๋ค. ๋ฐ๋๋ก sin(u_time)์ด 1์ผ ๋๋ 1์ ์ด๊ณผํ๊ฒ ๋๋ฏ๋ก 2๋ก ๋๋ ์ค๋ค.
mix
โข
์ ํ ๋ณด๊ฐ ํจ์
โข
float x, y, a: 3๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ๋๋ค.
โข
(x, y, 0) = x
โข
(x, y, 1) = y
โข
x * (1-a) + y * a
varying
โข
varying: vertex shader โ fragment shader๋ก ๋๊ธธ ์ ์๋ ๊ฐ์ ํค์๋๋ก ์ ์ธ
โข
vec2 uv: (0~1, 0~1):varying vec2 v_uv
โข
vec3 position: (-1~1, -1~1, -1~1)
clamp
โข
n, min, max 3๊ฐ์ ํ๋ผ๋ฏธํฐ: clamp(n, min, max)
โข
x ๊ฐ์ด minVal๋ณด๋ค ์์ผ๋ฉด โ minVal์ ๋ฐํ
โข
x ๊ฐ์ด maxVal๋ณด๋ค ํฌ๋ฉด โ maxVal์ ๋ฐํ
โข
๊ทธ ์ฌ์ด๋ฉด โ x ๊ทธ๋๋ก ๋ฐํ
clamp(n, 1, 5)
- n=0) 1
- n=6) 5
- n=3) 3
JavaScript
๋ณต์ฌ
โข
์ด๋ค ๊ฐ์ "์ต์~์ต๋ ๋ฒ์ ์"์ผ๋ก ๋ง์ถฐ์ฃผ๋ ํจ์
โข
์ธ์ ์ฐ๋๊ฐ
โฆ
์์ ๊ฐ์ 0~1 ์ฌ์ด๋ก ์ ํํ ๋ โ clamp(color, 0.0, 1.0)
โฆ
๋ฌผ์ฒด๊ฐ ํ๋ฉด ๋ฐ์ผ๋ก ์ ๋๊ฐ๊ฒ ํ ๋
โฆ
๋ฐ๊ธฐ, ์์, ๊ฑฐ๋ฆฌ ๋ฑ์ ์ ํด์ง ๋ฒ์ ๋ด๋ก ์กฐ์ ํ ๋
step
โข
step(edge, n) : 0 ๋๋ 1 ๋ฐํ
โข
๊ฐ n์ด edge๋ณด๋ค ํฌ๋ฉด 1.0, ์์ผ๋ฉด 0.0์ ๋ฐํํ๋ ๊ณ๋จ ํจ์
๋์ด๊ณต์ ์
์ฅํ ๋ ํค 140cm ์ด์์ด๋ฉด ์
์ฅ ๊ฐ๋ฅ
step(140.0, 130.0) // ๊ฒฐ๊ณผ: 0.0 (์
์ฅ ๋ถ๊ฐ)
step(140.0, 150.0) // ๊ฒฐ๊ณผ: 1.0 (์
์ฅ ๊ฐ๋ฅ)
GLSL
๋ณต์ฌ
โข
์ธ์ ์ฐ๋๊ฐ
โฆ
์ด๋ค ๊ธฐ์ค๋ณด๋ค ํฌ๋ ์๋์ ๋ฐ๋ผ ์, ํฌ๋ช
๋ ๋ฑ์ ๋ฑ ๋๋ ๋
โฆ
๋ง์คํฌ ํจ๊ณผ ๋ง๋ค ๋
smoothstep
โข
smoothstep(edge0, edge1, n)
โข
๋ถ๋๋ฝ๊ฒ 0์์ 1๋ก ๋์ด๊ฐ๊ฒ ํด์ฃผ๋ ํจ์
ํด๊ฐ ์ฒ์ฒํ ์ง๋ฉด์ ํ๋์ด ์ด๋์์ง๋ ๊ฒ์ฒ๋ผ, ๋ถ๋๋ฝ๊ฒ ๋ฐ๊ธฐ(0โ1)๊ฐ ๋ฐ๋๋ ๋๋
smoothstep(0.0, 1.0, 0.0) // ๊ฒฐ๊ณผ: 0.0
smoothstep(0.0, 1.0, 0.5) // ๊ฒฐ๊ณผ: 0.5 (์ค๊ฐ)
smoothstep(0.0, 1.0, 1.0) // ๊ฒฐ๊ณผ: 1.0
GLSL
๋ณต์ฌ
โข
n์ด edge0๋ณด๋ค ์์ผ๋ฉด: 0
โข
n์ด edge1๋ณด๋ค ํฌ๋ฉด: 1
โข
๊ทธ ์ฌ์ด๋ฉด: ๋ถ๋๋ฝ๊ฒ 0 โ 1๋ก ๋ณํ
โข
์ธ์ ์ฐ๋๊ฐ
โฆ
๊ทธ๋ผ๋ฐ์ด์
ํจ๊ณผ
โฆ
๋ถ๋๋ฌ์ด ํ
๋๋ฆฌ
โฆ
์์ฐ์ค๋ฌ์ด ์ ํ
length
โข
๋ฒกํฐ(ํ์ดํ)์ ๊ธธ์ด(๊ฑฐ๋ฆฌ)๋ฅผ ๊ตฌํ๋ ํจ์:
โข
(0, 0)์์ (3, 4)๊น์ง ๊ฑธ์ด๊ฐ๋ฉด, ๊ฑธ์ ๊ฑฐ๋ฆฌ = 5 (ํผํ๊ณ ๋ผ์ค)
โฆ
length(vec2(3.0, 4.0)) // ๊ฒฐ๊ณผ: 5.0
โข
์ธ์ ์ฐ๋๊ฐ
โฆ
์ด๋ค ์ ์ด ์ค์ฌ์์ ์ผ๋ง๋ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๋์ง ๊ณ์ฐํ ๋
โฆ
์ํ ๊ทธ๋ผ๋ฐ์ด์
๋ง๋ค๊ธฐ
โฆ
๋ง์ฐ์ค ๊ฑฐ๋ฆฌ ๊ธฐ๋ฐ ๋ฐ์ ๋ง๋ค๊ธฐ
์ฑ๋ฆฐ์ง! length๋ก ๋
ธ๋์ ์ ๋ง๋ค์ด๋ณด๊ธฐ!
์์ด๋์์ If ๋ฌธ์ด ๋๋ฆฐ ์ด์ : ๋ถ๊ธฐ ๋ฐ์ฐ
rect(custom function)
float rect(vec2 pt, vec2 size, vec2 center) {
vec2 p = pt - center;
vec2 halfsize = size * 0.5;
float horz = step(-halfsize.x, p.x) - step(halfsize.x, p.x);
float vert = step(-halfsize.y, p.y) - step(halfsize.y, p.y);
return horz * vert;
}
GLSL
๋ณต์ฌ
โข
yellow square
void main (void) {
vec3 color = vec3(1.0,1.0, 0.0) * rect(v_position.xy, vec2(1.0), vec2(0.0));
gl_FragColor = vec4(color, 1.0);
}
GLSL
๋ณต์ฌ
(cos, sin)
โข
์์ผ๋ก ์์ง์ด๊ฒ ๋ง๋ค ๋ ์ฌ์ฉ
mat2
โข
2*2 ํ๋ ฌ ๋ฐ์ดํฐ
fract
โข
1.5 โ 0.5, 6.5 โ 0.5
โข
์ ์๋ฅผ ๋ฒ๋ฆผ
dot
โข
dot(d, p)๋ ํฝ์
์ด ๋ฐ๋(p) ๋ฐฉํฅ์ผ๋ก ์ผ๋ง๋ ๊ฐ๊น์ด ์๋์ง ์ธก์
โฆ
๋ ๋ฒกํฐ d, p๋ฅผ ๋ฃ์ผ๋ฉด "์ผ๋ง๋ ๊ฐ์ ๋ฐฉํฅ์ ๋ณด๊ณ ์๋์ง" ์๋ ค์ฃผ๋ ํจ์
dot(a, b) = a.x * b.x + a.y * b.y (+ a.z * b.z ... 3D์ธ ๊ฒฝ์ฐ)
GLSL
๋ณต์ฌ
โข
๊ฐ์ ๋ฐฉํฅ์ผ ์๋ก ๊ฐ์ด ์ปค์ง๊ณ , ๋ฐ๋๋ฐฉํฅ์ผ ์๋ก ๊ฐ์ ์์์ง๋ค.
โข
dot(a, b)๋ 1 โ ์์ ๊ฐ์ ๋ฐฉํฅ
โข
0 โ 90๋ (์์ง)
โข
1 โ ์์ ๋ฐ๋ ๋ฐฉํฅ

