자체 엔진에 Global Illumination을 적용하기 위한 삽질기 2

1. Mesh에서 SDF Volume Texture로 변환하기

2. SDF Volume Texture를 레이마칭으로 표현하기

3. SDF Reflection Map 생성하기

4. 레거시 렌더링에 적용하기

렌더링 플로우

1. Mesh에서 SDF Volume Texture로 변환하기

매쉬에서 SDF의 볼륨 텍스쳐로 변환하기까지 여러 방법들이 있습니다. 저는 여기서 쉽고 빠르게 할 수 있는 방법을 사용했죠!

바로 x, y, z축으로 일정 간격으로 렌더링해서 저장하는 방식을 사용하게 되었습니다!

z축 종횡비가 안맞는 문제

OpenGL에서 다르게 적용되는 데이터 구성

int index = (z * size * size) + (y * size) + (x);

2. SDF Volume Texture를 레이마칭으로 표현하기

1. 레이의 AABB Box 형식의 Intersection 판단

2. 볼륨 텍스쳐 내부에서의 레이마칭

1단계 : 레이의 AABB Box 형식의 Intersection 판단

vec2 RayAABBIntersection(vec3 ro, vec3 rd) {

    vec3 aabbmin = vec3(-AABB_SIZE/2.) * 0.5;
    vec3 aabbmax =  vec3(AABB_SIZE/2.) * 0.5;

    vec3 invR = vec3(1.0) / rd;

    vec3 tbbmin = invR * (aabbmin - ro);
    vec3 tbbmax = invR * (aabbmax - ro);

    vec3 tmin = min(tbbmin, tbbmax);
    vec3 tmax = max(tbbmin, tbbmax);

    float tnear = max(max(tmin.x, tmin.y), tmin.z);
    float tfar  = min(min(tmax.x, tmax.y), tmax.z);

    return tfar > tnear ? vec2(tnear, tfar) : vec2(-999.);
}

...중락...

vec3 renderTexture(vec3 origin, vec3 direction) {
    vec2 isct = RayAABBIntersection(origin, direction);

    if (isct.x <= -999.) {
        return vec3(0.);
    }

		...중략...

2단계 : 볼륨 텍스쳐 내부에서의 레이마칭

		float D = abs(isct.y - isct.x);

    vec3 wp = origin + direction * isct.x;
    vec3 vol_size = vec3(AABB_SIZE);
    vec3 tp = wp + (vol_size * 0.5);
    float steps = D / 512.f; // steps를 잘게 자르면 자를 수록 표현 정확도가 높아집니다.

    // D만큼의 거리를 지나갑니다
    for (float t = 0.0; t < D; t += steps) {
        // 레이의 방향을 향해 레이를 전진시킵니다.
        vec3 currentPos = tp + direction * t;

        // 밀도값과 함께 RGB값을 가져옵니다.
        vec4 density = texture(u_sdf_tex, currentPos / vol_size);

        // 추가적인 데이터 포팅을 진행할 수 있지만 지금은 RGB값으로만 적용해봅니다.
        vec4 src = vec4(density);

        if (density.a > 0.5) {
						// restore color
            return (src.rgb + src.a * src.rgb * 1.5) * (1. - (t / D) * 2.);
        }
    }

3. SDF Reflection Map 생성하기

사실 구글에 쉽게 검색할 수 있는 SDF를 이용한 GI기술은 대부분 옛날의 다이나믹 디퓨즈만을 지원하는 논문과 포스트글입니다.

왼쪽은 쉽게 접할 수 있는 논문 중 하나인 SDFDDGI(Signed Distance Fields Dynamic Diffuse Global Illumination)입니다.

이 논문을 간단하게 요약해보자면 당시 RTXGI의 기법에서 영감을 받아 SDF로 소프트웨어 렌더링을 통해 다이나믹 디퓨즈 렌더링을 하는 내용입니다.

 

말이 길어졌네요! 이제 구현단계로 들어가보겠습니다.

이번엔 전체 화면에서 좀 특이하게 레이를 쏘게 됩니다. 왜냐하면 리플렉션 맵은 각 프로브에 해당하는 요소에 6면이 들어있는 큐브맵 형태로 렌더링을 해야하기 때문이죠.

그래서 오른쪽과 같은 형태는 무난하게 레이마칭으로 렌더링할 때의 모습이라면, 이번엔 각 가로 세로를 일정 크기에 맞게 나눠서 UV값을 재할당 시켜줍니다.

UV를 재구성하는 코드는 다음과 같이 작성됩니다.

float index_pos_y = u_node_size.x * u_node_size.y * u_node_size.z;
vec2 new_uv = vec2(1. - fract(v_textureCoordOut.x / (1./6.)),
                       fract(v_textureCoordOut.y / (1. / index_pos_y)));

...

vec2 p = vec2(2. * (new_uv - 0.5));

const float c_pv_d = 1.0;

const mat3 c_pv_m0 = mat3(
vec3(0., 0., 1.),
vec3(0., -1., 0.),
vec3(1., 0., 0.)
);
const mat3 c_pv_m1 = mat3(
vec3(0., 0., -1.),
vec3(0., -1., 0.),
vec3(-1., 0., 0.)
);

...중략...

const mat3 c_pv_m5 = mat3(
vec3(1., 0., 0.),
vec3(0., -1., 0.),
vec3(0., 0., -1.)
);

// camera
vec3 ro = vec3(0, 0, 0) - pos * u_node_space + u_node_size * u_node_space * 0.5;

// Setting View Matrix
mat3 viewMat = mat3(0.);
{
    int i = int(mod(node_index, 6.));
    if(i == 0) viewMat = c_pv_m0;
    if(i == 1) viewMat = c_pv_m1;
    if(i == 2) viewMat = c_pv_m2;
    if(i == 3) viewMat = c_pv_m3;
    if(i == 4) viewMat = c_pv_m4;
    if(i == 5) viewMat = c_pv_m5;
}

// ray direction
vec3 rd = viewMat * normalize(vec3(p.xy, c_pv_d));

4. 레거시 렌더링에 적용하기

1. 2D 텍스쳐를 큐브맵 텍스쳐처럼 렌더링 해야함

2. 프로브 위치값에 맞게 큐브맵 텍스쳐를 선택해야함

3. 각 프로브마다 존재하는 큐브맵 텍스쳐를 자연스럽게 처리해야함

void cubemap(vec3 r, out float texId, out vec2 st) {
	vec3 uvw;
	vec3 absr = abs(r);
	if (absr.x > absr.y && absr.x > absr.z) {
		// x major
		float negx = step(r.x, 0.0);
		uvw = vec3(r.zy, absr.x) * vec3(mix(-1.0, 1.0, negx), -1, 1);
		texId = negx;
	} else if (absr.y > absr.z) {
		// y major
		float negy = step(r.y, 0.0);
		uvw = vec3(r.xz, absr.y) * vec3(1.0, mix(1.0, -1.0, negy), 1.0);
		texId = 2.0 + negy;
	} else {
		// z major
		float negz = step(r.z, 0.0);
		uvw = vec3(r.xy, absr.z) * vec3(mix(1.0, -1.0, negz), -1, 1);
		texId = 4.0 + negz;
	}
	st = vec2(uvw.xy / uvw.z + 1.) * .5;
}

...

cubemap(direction, texId, st);
vec4 color = vec4(0);
for (int i = 0; i < 6; ++i) {
	vec4 side = texture(u_sampler_sdf[i], st);
	float select = step(float(i) - 0.5, texId) * step(texId, float(i) + .5);
	color = mix(color, side, select);
}
return color;

vec4 texCubemap(vec3 uvw, vec3 pos) {
	float texId;
	vec2 st;
	vec3 ipos = floor(pos);
	float index_pos_y = u_node_size.x * u_node_size.y * u_node_size.z;
	float index = (u_node_size.z - ipos.z) * u_node_size.y * u_node_size.x
							+ (u_node_size.y - ipos.y) * u_node_size.x
							+ (u_node_size.x - ipos.x);
	index = max(min(index, index_pos_y), 0.);

	cubemap(uvw, texId, st);
	st = vec2(st.x / 6., st.y / index_pos_y);
	vec4 color = vec4(0);
	for (int i = 0; i < 6; ++i) {
		vec4 side = texture(u_sampler_sdf, st + vec2(float(i) * (1./6.), 
												index * (1./index_pos_y)));
		float select = step(float(i) - 0.5, texId) *
		step(texId, float(i) + .5);
		color = mix(color, side, select);
	}
	return color;
}

vec4 texCubemapSmooth(vec3 uvw, vec3 pos) {
	vec3 spos = fract(pos) * 0.5;
	vec3 spos_abs = abs(spos);
	vec3 direction = normalize(uvw);

	vec3 offset_x = vec3((spos.x < 0 ? -1. : 1.), 0., 0.);
	vec3 offset_y = vec3(0., (spos.y < 0 ? -1. : 1.), 0.);
	vec3 offset_z = vec3(0., 0., (spos.z < 0 ? -1. : 1.));

	vec4 c000 = texCubemap(direction, pos);
	vec4 c100 = texCubemap(direction, pos + offset_x);
	vec4 c010 = texCubemap(direction, pos + offset_y);
	vec4 c110 = texCubemap(direction, pos + offset_x + offset_y);
	vec4 c001 = texCubemap(direction, pos + offset_z);
	vec4 c101 = texCubemap(direction, pos + offset_x + offset_z);
	vec4 c011 = texCubemap(direction, pos + offset_y + offset_z);
	vec4 c111 = texCubemap(direction, pos + offset_x + offset_y + offset_z);

	vec4 color = mix(
		mix(
		mix(c000, c100, spos_abs.x * 2.),
		mix(c010, c110, spos_abs.x * 2.),
		spos_abs.y * 2.
		),
		mix(
		mix(c001, c101, spos_abs.x * 2.),
		mix(c011, c111, spos_abs.x * 2.),
		spos_abs.y * 2.
		),
		spos_abs.z * 2.
	);
	return color;
}

마무리