surkim 님의 블로그

pt - 15. rchit shader, rmiss shader

surkim — Thu, 14 Aug 2025 12:25:41 +0900

앞에서 메모리 구조와 rgen shader를 설명했었다.

rgen shader에서 레이를 쏘면

맞지 않으면 -> rmiss

맞으면 -> rchit shader로 가고

이 때 정보를 주고 받는 메모리는

raypayload 구조체로 정의된다.

struct RayPayload {
	vec3 L;
	vec3 beta;
	vec3 nextOrigin;
	vec3 nextDir;
	int bounce;
	uint seed;
	int terminated;
	float pdf;
};


layout(location = 0) rayPayloadInEXT RayPayload payload;

내가 정의한 RayPayload 구조체이다.

레이에 맞거나 맞지 않거나

rchit 나 rmiss 셰이더로 들어오고 이 구조체의 값을 변경할 수 있어

그 셰이더의 입출력이 되는것이다.

당연하게도 셰이더로 들어오는 구조체인 rayPayloadInEXT는 무조건 하나여야한다는게 중요하다

rchit 셰이더 내부에서도 raypayload구조체를 만들어 자체적으로 레이를 쏠 수 있다. (shadow 판별할 때 썼다.)

이건 중요한 부분이라 다시 정리하자면

.rgen shader

	payload.L = vec3(0.0);
	payload.beta = vec3(1.0);
	payload.nextOrigin = origin;
	payload.nextDir = dir;
	payload.bounce = 0;
	payload.seed = initRandom(size, pixel, options.frameCount);
	payload.terminated = 0;


	for (int i = 0; i < 16; ++i) {
		payload.bounce = i;// 이때 payload는 초기화 상태
		traceRayEXT(topLevelAS, gl_RayFlagsOpaqueEXT, 0xFF, 0, 0, 0,
					origin, 0.0001, dir, 1e30, 0);
		// 함수를 거친후 payload는 안의 값이 rchit or rmiss 셰이더로 인해 변경된 상태
		if (payload.terminated != 0) break;

		if (i > 2) {
			float p = clamp(max(payload.beta.r, max(payload.beta.g, payload.beta.b)), 0.05, 1.0);
			if (rand(payload.seed) > p) {
				break;
			}
			payload.beta /= p;
		}

		origin = payload.nextOrigin;
		dir = payload.nextDir;
	}

여기서 traceRayEXT 함수로 레이를 쏘면 raypayload구조체가 rchit나 rmiss로 가게 되고

그 구조체 내부의 변수를 셰이더 내부에서 변경하여

다시 rgen 셰이더로 왔을 때 그 값이 변경되는 구조이다.

구조 설명했으니 셰이더 코드를 봐보자

.rmiss

void main() {
    payload.terminated = 1;
}

miss는 쉬운게 그냥 terminated를 1로 조정하여 끝내버렸다.

광원까지 무조건 가야 계산되기 때문에 초기에 miss가 나든 몇번 튕겨 miss나든 똑같다.

.rchit

우선 메인 흐름부터

void main() {
    uint instanceID = gl_InstanceCustomIndexEXT;
    InstanceGPU instance = instances[instanceID];

    vec3 N, P;
    computeHitNormal(N, P);
    vec3 wo = -normalize(gl_WorldRayDirectionEXT);
    
    if (instance.lightIndex >= 0) {
        AreaLightGPU light = areaLights[instance.lightIndex];

        vec3 lightNormal = normalize(light.normal);

        if (dot(lightNormal, wo) < 0) {
            payload.terminated = 1;
            return ;
        }

        if (payload.bounce == 0) {
            payload.L = light.color;
            payload.terminated = 1;
            return ;
        }

        if (payload.bounce > 2) {
            payload.L += light.color * light.intensity * payload.beta;
            payload.terminated = 1;
            return ;
        }

        vec3 dir = P - gl_WorldRayOriginEXT;
        float dist = length(dir);
        float dist2 = dist * dist;
        vec3 L_wi = normalize(dir);

        float cosTheta = max(dot(lightNormal, -L_wi), 0.001);
        float areaPdf = 1.0 / light.area;
        float solidAnglePdf = dist2 / (cosTheta + 0.001) * areaPdf;
        float L_pdf = solidAnglePdf / float(options.lightCount);

        float w = L_pdf / (L_pdf + payload.pdf);

        payload.L += light.color * light.intensity * payload.beta * w;
        payload.terminated = 1;
        return;
    }

    // if (dot(N, wo) < 0) {
    //     payload.terminated = 1;
    //     return ;
    // }

    int matIdx = instance.materialIndex;
    MaterialGPU mat = materials[matIdx];


    vec2 uv = getUV();
    mat = copyMaterial(mat, uv);

    payload.beta *= mat.ao;

    if (payload.bounce == 0)
        sampleDirect(N, P, wo, mat);

    sampleIndirect(N, P, wo, mat);
}

한줄 한줄 설명 들어간다.

    uint instanceID = gl_InstanceCustomIndexEXT;
    InstanceGPU instance = instances[instanceID];

이건 TLAS 생성할 때 BLAS 인스턴스에 붙인 커스텀 정의값을 불러오는 함수이다.

다시 말해 rchit 셰이더에 들어왔으면 어디에든 레이가 오브젝트에 맞았다는 뜻이고

그 오브젝트는 blas로 정의되어있고

그 blas 정의할 때 커스텀 인덱스를 부여해놔서 이 인스턴스가 어떤 인스턴스인지 확인하는 단계

    vec3 N, P;
    computeHitNormal(N, P);
    vec3 wo = -normalize(gl_WorldRayDirectionEXT);

맞은 지점과 그 지점의 표면의 법선 벡터를 계산한다.

wo는 표면에 들어온 레이 벡터 계산이다. gl_ 붙여있는거는 내장 변수들이다.

    if (instance.lightIndex >= 0) {
        AreaLightGPU light = areaLights[instance.lightIndex];

        vec3 lightNormal = normalize(light.normal);

        if (dot(lightNormal, wo) < 0) {
            payload.terminated = 1;
            return ;
        }

        if (payload.bounce == 0) {
            payload.L = light.color;
            payload.terminated = 1;
            return ;
        }

        if (payload.bounce > 2) {
            payload.L += light.color * light.intensity * payload.beta;
            payload.terminated = 1;
            return ;
        }

        vec3 dir = P - gl_WorldRayOriginEXT;
        float dist = length(dir);
        float dist2 = dist * dist;
        vec3 L_wi = normalize(dir);

        float cosTheta = max(dot(lightNormal, -L_wi), 0.001);
        float areaPdf = 1.0 / light.area;
        float solidAnglePdf = dist2 / (cosTheta + 0.001) * areaPdf;
        float L_pdf = solidAnglePdf / float(options.lightCount);

        float w = L_pdf / (L_pdf + payload.pdf);

        payload.L += light.color * light.intensity * payload.beta * w;
        payload.terminated = 1;
        return;
    }

인스턴스로 확인해봤을 때 표면에 맞은 부분이 광원일 때 계산이다.

path tracing이 진행될 때마다 payload의 beta부분이 계속 갱신되는데

광원에 맞았을 때 그 광원의 정보를 가져와

지금까지 계산했던 throughput(beta)와 계산하여 최종 샘플 색인 L을 구하는 것이다.

딱 bounce가 1일때만 휴리스틱 벨런스(w)를 적용해줘야하는데

처음 바운스된곳에서 NEE를 딱 한번만 적용시켰기 때문이다.

raypayload에 많은 정보를 넣을 수가 없어서 광원에 맞았을 때 레이가 발사된 지점을 역산해서 pdf를 구해줘야했다.

    int matIdx = instance.materialIndex;
    MaterialGPU mat = materials[matIdx];


    vec2 uv = getUV();
    mat = copyMaterial(mat, uv);

    payload.beta *= mat.ao;

    if (payload.bounce == 0)
        sampleDirect(N, P, wo, mat);

    sampleIndirect(N, P, wo, mat);

맞은 표면의 material을 찾아서 처음 튕겼을 때는 직접광도 계산하고(NEE)

그 이후부터는 간접광만 계산한다.

간접광 계산부터 한번 봐보자

void sampleIndirect(in vec3 N, in vec3 P, in vec3 wo, in MaterialGPU mat)
{
    vec3 baseColor = mat.baseColor.rgb;
    vec3 Kd = baseColor * (1.0 - mat.metallic);
    vec3 F0 = mix(vec3(0.04), baseColor, mat.metallic);
    float probSpec = max(max(F0.r, F0.g), F0.b);

    vec3 H = vec3(0.0);
    vec3 wi = vec3(0.0);
    vec3 f = vec3(0.0);
    float pdf = 1.0;
    float tpdf = 1.0;
    
    int sampledSpecular = rand(payload.seed) < probSpec ? 1 : 0;

    if (sampledSpecular != 0) {
        vec2 Xi = sample2D(payload.seed);
        H = importanceSampleGGX(Xi, N, mat.roughness);
        wi = normalize(reflect(-wo, H));
    } else {
        vec3 localWi = cosineSampleHemisphere(payload.seed);
        wi = normalize(toWorld(localWi, N));
        H = normalize(wo + wi);
    }

    float NdotL = max(dot(N, wi), 0.001);
    float NdotV = max(dot(N, wo), 0.001);
    float NdotH = max(dot(N, H), 0.001);
    float VdotH = max(dot(wo, H), 0.001);

    if (sampledSpecular == 1 && dot(wo, N) * dot(wi, N) < 0.0) {
        payload.terminated = 1;
        return;
    }

    float D = distributionGGX(N, H, mat.roughness);
    float G = geometrySmith(N, wo, wi, mat.roughness);
    vec3 F_refl = fresnelSchlick(VdotH, F0);

    vec3 specularf = (D * G * F_refl) / max(4.0 * NdotV * NdotL, 1e-4);
    vec3 diffusef = Kd / PI;

    float pdf_diff = NdotL / PI * (1.0 - probSpec);
    float pdf_spec = D * NdotH / (4.0 * VdotH + 1e-4) * probSpec;

    float sumPdf = pdf_diff + pdf_spec;
    float misWeight = (sampledSpecular != 0) ? (pdf_spec / sumPdf) : (pdf_diff / sumPdf);

    f = (sampledSpecular != 0) ? specularf * misWeight : diffusef * misWeight;
    pdf = (sampledSpecular != 0) ? pdf_spec : pdf_diff;

    payload.beta *= f * NdotL / max(pdf, 1e-4);
    payload.nextOrigin = P + wi * 0.001;
    payload.nextDir = wi;
    payload.terminated = 0;
    payload.pdf = pdf;
}

    vec3 baseColor = mat.baseColor.rgb;
    vec3 Kd = baseColor * (1.0 - mat.metallic);
    vec3 F0 = mix(vec3(0.04), baseColor, mat.metallic);
    float probSpec = max(max(F0.r, F0.g), F0.b);

    vec3 H = vec3(0.0);
    vec3 wi = vec3(0.0);
    vec3 f = vec3(0.0);
    float pdf = 1.0;
    float tpdf = 1.0;

값들 초기화해주는 부분

    int sampledSpecular = rand(payload.seed) < probSpec ? 1 : 0;

    if (sampledSpecular != 0) {
        vec2 Xi = sample2D(payload.seed);
        H = importanceSampleGGX(Xi, N, mat.roughness);
        wi = normalize(reflect(-wo, H));
    } else {
        vec3 localWi = cosineSampleHemisphere(payload.seed);
        wi = normalize(toWorld(localWi, N));
        H = normalize(wo + wi);
    }

레이의 출력방향 샘플링해주는 부분이다.

여기서 중요한 점은 metallic성분으로 만든 probSpec 변수를 통해 출력 방향 로브를 랜덤으로 선택하는 부분이다.

이 확률은 나중에 pdf 계산할 때 꼭 들어가야하므로 기억해두고

확률에 따라서 디퓨즈 로브를 선택할지 스페큘러 로브를 선택할지 정한다.

예시로서 딱 좋은 이미지

    float NdotL = max(dot(N, wi), 0.001);
    float NdotV = max(dot(N, wo), 0.001);
    float NdotH = max(dot(N, H), 0.001);
    float VdotH = max(dot(wo, H), 0.001);

    if (sampledSpecular == 1 && dot(wo, N) * dot(wi, N) < 0.0) {
        payload.terminated = 1;
        return;
    }

계산을 위한 사전 작업과

출력방향이 혹여 표면 반구의 반대방향이 나올 수도 있는 것을 방지하는 코드

    float D = distributionGGX(N, H, mat.roughness);
    float G = geometrySmith(N, wo, wi, mat.roughness);
    vec3 F_refl = fresnelSchlick(VdotH, F0);

    vec3 specularf = (D * G * F_refl) / max(4.0 * NdotV * NdotL, 1e-4);
    vec3 diffusef = Kd / PI;

ggx 마이크로패싯 계산 + diffuse 램버트 계산

    float pdf_diff = NdotL / PI * (1.0 - probSpec);
    float pdf_spec = D * NdotH / (4.0 * VdotH + 1e-4) * probSpec;

레이를 결정했을 때 이걸 선택한 확률을 구해야한다.

여기서 중요한 점은 디퓨즈 스페큘러 로브를 probSpec 변수로 나눴으니 이것도 꼭 곱해서 적용해준다.

    float sumPdf = pdf_diff + pdf_spec;
    float misWeight = (sampledSpecular != 0) ? (pdf_spec / sumPdf) : (pdf_diff / sumPdf);

    f = (sampledSpecular != 0) ? specularf * misWeight : diffusef * misWeight;
    pdf = (sampledSpecular != 0) ? pdf_spec : pdf_diff;

구한 pdf로 밸런스 휴리스틱 계산

f와 pdf 결정

    payload.beta *= f * NdotL / max(pdf, 1e-4);
    payload.nextOrigin = P + wi * 0.001;
    payload.nextDir = wi;
    payload.terminated = 0;
    payload.pdf = pdf;

throughput 업데이트와 다음 바운스 세팅을 하면 끝

직접광계산은 비슷하지만 다른부분이 있다.

void sampleDirect(in vec3 N, in vec3 P, in vec3 wo, in MaterialGPU mat)
{
    vec3 Kd = mat.baseColor.rgb * (1.0 - mat.metallic);
    vec3 F0 = mix(vec3(0.04), mat.baseColor.rgb, mat.metallic);
    float probSpec = max(max(F0.r, F0.g), F0.b);

    // Light sampling
    int lightIdx = int(mod(rand(payload.seed) * float(options.lightCount), float(options.lightCount)));
    AreaLightGPU light = areaLights[lightIdx];

    // sample point on quad (light.p0~p3)
    float u = rand(payload.seed);
    float v = rand(payload.seed);
    vec3 sampledPos;
    if (u + v <= 1.0) {
        sampledPos = light.p0 * (1.0 - u - v) + light.p1 * u + light.p2 * v;
    } else {
        u = 1.0 - u;
        v = 1.0 - v;
        sampledPos = light.p2 * (1.0 - u - v) + light.p3 * u + light.p0 * v;
    }

    vec3 lightNormal = normalize(light.normal);
    vec3 dir = sampledPos - P;
    float dist = length(dir);
    float dist2 = dist * dist;
    vec3 L_wi = normalize(dir);

    float cosTheta = max(dot(lightNormal, -L_wi), 0.001);
    float areaPdf = 1.0 / light.area;
    float solidAnglePdf = dist2 / (cosTheta + 0.001) * areaPdf;
    float L_pdf = solidAnglePdf / float(options.lightCount);

    // Shadow test
    isShadowed = true;
    traceRayEXT(topLevelAS, 
        gl_RayFlagsTerminateOnFirstHitEXT | gl_RayFlagsOpaqueEXT | gl_RayFlagsSkipClosestHitShaderEXT,
        0xFF, 0, 0, 1, 
        P + N * 0.0001, 0.0001, L_wi, dist * 0.99, 1);

    if (isShadowed || dot(L_wi, N) < 0.0 || L_pdf <= 0.0)
        return;

    // BRDF evaluation
    vec3 H = normalize(wo + L_wi);

    float NdotL = max(dot(N, L_wi), 0.001);
    float NdotV = max(dot(N, wo), 0.001);
    float NdotH = max(dot(N, H), 0.001);
    float VdotH = max(dot(wo, H), 0.001);

    float D = distributionGGX(N, H, mat.roughness);
    float G = geometrySmith(N, wo, L_wi, mat.roughness);
    vec3 F  = fresnelSchlick(VdotH, F0);

    vec3 specularf = (D * G * F) / max(4.0 * NdotV * NdotL, 0.001);
    vec3 diffusef = Kd / PI;

    float pdf_diff = NdotL / PI * (1.0 - probSpec);
    float pdf_spec = D * NdotH / (4.0 * VdotH + 0.001) * probSpec;

    vec3 f = specularf + diffusef;
    float pdfBRDF = max(pdf_diff + pdf_spec, 0.001);

    // Final contribution with MIS weight
    vec3 direct = (f * light.color * light.intensity * NdotL) / L_pdf;
    float w = L_pdf / (L_pdf + pdfBRDF);
    payload.L += payload.beta * direct * w;
}

계산은 비슷하니 전체적으로 설명하자면

직접광은 광원을 직접 샘플링해야하기 때문에

광원 인덱스에서 랜덤으로 하나를 뽑았다.

원래 가까운 광원이나 더 영향을 많이 줄 것 같은 광원에 확률를 높게주는 기법이 있긴한데

나는 그냥 고른 분포로 뽑게 했다.

뽑은 광원의 한 지점을 결정하여 레이의 방향을 결정하고 레이를 한번 쏴서 그림자인지 아닌지 판단한다.

그림자가 아니라고 판단되면 (광원에 레이를 쏴서 그 중간에 아무것도 맞지 않으면)

그 광원에 대한 brdf를 평가한다.

이때는 보통의 광원 계산과 같이 diffuse와 specular를 같이 평가하여 더하고

MIS 보정을 위해 광원 선택확률과 brdf평가 확률로 보정계수 w를 계산하고 직접광 계산에 곱해주면 끝!

pt - 14. gltf를 지원하는 path tracing 렌더러

surkim — Tue, 12 Aug 2025 18:02:48 +0900

재질 통합을 완료하고 gltf를 지원하는 렌더러로 바꿨다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

ui 상 왼쪽 위는 오브젝트, 아래는 area light를 조정할 수 있는 ui이고

다중 광원 역시 지원 가능하다. (물론 area light 중 사각형만..!)

계산식 통합이야 계속 해왔던거라 쉬웠는데

오히려 오브젝트 추가 제거나

area light도 오브젝트 취급인데 light 속성을 지니고 있으니 이걸 구분지어주는 것에 애먹었었다

생각해보니 내 path tracing 계산식에 대한 코드와 메모리들 설명을 여기다가 안적어서 정리해서 적어 놔야겠다.

오브젝트, arealight, material, camera, options 전부 gpu에 올려 놓았고 메모리 구조는 이렇다.

1. 카메라

layout (set = 0, binding = 0) uniform CameraGPU {
    vec3 camPos;
    float pad0;
    vec3 camDir;
    float pad1;
    vec3 camUp;
    float pad2;
    vec3 camRight;
    float fovY;
} camera;

그냥 빡빡하게 메모리 정렬을 맞춰주었다.

내 역량 부족인지 뭔지 작업하는 컴퓨터가 각각 스펙이 다른 3대(rtx2060 super, rtx3060, rtx4070labtop)여서

돌려가며 작업했었는데 왜인지 정렬을 굉장히 빡빡하게 안맞춰주면

어디선가 항상 삑사리가 났고 화딱지 나서 정확하게 16바이트씩 맞춰줬었다.

특별할 거 없는 카메라 정보이고 위치, 방향, up, right, fov를 gpu에 올려둔다.

2. 옵션

layout (set = 0, binding = 1) uniform OptionsGPU {
    int frameCount;
    int maxSpp;
    int currentSpp;
    int lightCount;
} options;

옵션은 일단 만들어두고 그때그때 필요할 때마다 추가해주는 형식으로

개발 친화적으로 만든 구조체였고

현재는 frame count, 최대 spp, 현재 spp, light 개수가 들어간다.

3. 인스턴스 (오브젝트)

struct InstanceGPU {
    mat4 transform;

    uint64_t vertexAddress;
    uint64_t indexAddress;

    int lightIndex;
    int materialIndex;
    int meshIndex;
    float pad0;
};
layout(set = 3, binding = 0) buffer InstanceBuffer {
    InstanceGPU instances[];
};

모든 transform을 가지고 있는 오브젝트들 묶음이고

이건 오브젝트도 light도 될 수가 있다.

blas에 직접적으로 1대1 대응하는 인스턴스이다.

레이에 맞았을 때 이 인스턴스를 찾아서 무엇에 맞는지 알아내는 용도

각각 인덱스를 가지고 있고 자발광이 아닐때는 lightIndex 가 -1로 초기화 되어있다.

요 인덱스를 가지고 bindless형태로 각 세부정보를 확인하여 들어간다.

맞은 표면의 노말값과 uv값을 정확하게 알기위해 vetexAddress와 indexAddress를 cpu단에서 먼저 보내줘야 했다.

4. material

struct MaterialGPU {
    vec4 baseColor;
    vec3 emissiveFactor;
    float roughness;

    float metallic;
    float ao;
    int albedoTexIndex;
    int normalTexIndex;

    int metallicTexIndex;
    int roughnessTexIndex;
    int aoTexIndex;
    int emissiveTexIndex;

    int doubleSided;
    float transmissionFactor;
    float ior;
    float pad0;
};

layout (set = 1, binding = 0) buffer MaterialBuffer {
    MaterialGPU materials[];
};

path tracing 계산에 필요한 material 정보이다.

역시 bindless 형태로 gpu에 보내고 인덱스로 확인하는 구조로 짰고

통합재질이라 + gltf의 특성에 맞춰 메모리를 구성했다.

딱히 어려울 건 없고 여기서 중요한 포인트는 texture 인덱스를 또 bindless 형태로 찾아 들어간다는 점?

doubleSided는 이때 알게 되었는데 렌더링중에 특정 오브젝트가 특히 군데군데만 깜해서 찾아봤더니 doubleSided가 켜져있는 gltf파일은 뒷면에 맞아도 렌더링해야한다는 점을 알게되었었다.

제일 밑의 transmissionFactor와 ior은 투과의 잔재이다.

5. texture

layout(set = 2, binding = 0) uniform sampler2D textures[];

텍스쳐도 bindless형태로 올라간다.

이 프로젝트 부터 bindless를 알게되어서 아주 적극적으로 사용해준 기억이 난다.

이전 프로젝트에선 디스크립터 셋 구조가 난리가 났었다.

6. areaLight

struct AreaLightGPU {
    vec3 color;
    float intensity;

    vec3 p0;
    float area;
    vec3 p1;
    float pad0;
    vec3 p2;
    float pad1;
    vec3 p3;
    float pad2;

    vec3 normal;
    float pad3;
};
layout(set = 3, binding = 1) buffer AreaLightBuffer {
    AreaLightGPU areaLights[];
}

나는 사각형만 했고 직접광을 샘플링하기위해 점 4개가 다 필요했다.

좀 더 좋은 방법이 있긴 할텐데 그냥 모든 정보를 올리는 방법으로 쉽게 했다.

인스턴스에서 타고 들어가 인덱스로 light정보를 확인한다.

이정도가 얼추 path tracing에서 필요한 정보들이고 이 외에도 tlas, 그리고 출력용 이미지가 gpu에 올라간다.

처음에 렌더링이 시작되면

rgen shader에서 시작된다.

void main() {

	if (options.currentSpp >= options.maxSpp) {
		return;
	}


    uvec2 pixel = gl_LaunchIDEXT.xy;
    uvec2 size = gl_LaunchSizeEXT.xy;
    
	// vec2 uv = (vec2(pixel) + vec2(0.5)) / vec2(size);

    uint seed = initRandom(size, pixel, options.frameCount);
	vec2 jitter = vec2(rand(seed), rand(seed));
	vec2 uv = (vec2(pixel) + jitter) / vec2(size);

    vec2 screen = uv * 2.0 - 1.0;
    screen.y = -screen.y;
    float aspect = float(size.x) / float(size.y);
    float scale = tan(radians(camera.fovY) * 0.5);

    vec3 dir = normalize(
        screen.x * aspect * scale * camera.camRight +
        screen.y * scale * camera.camUp +
        camera.camDir
    );
	vec3 origin = camera.camPos;


	payload.L = vec3(0.0);
	payload.beta = vec3(1.0);
	payload.nextOrigin = origin;
	payload.nextDir = dir;
	payload.bounce = 0;
	payload.seed = initRandom(size, pixel, options.frameCount);
	payload.terminated = 0;


	for (int i = 0; i < 16; ++i) {
		payload.bounce = i;
		traceRayEXT(topLevelAS, gl_RayFlagsOpaqueEXT, 0xFF, 0, 0, 0,
					origin, 0.0001, dir, 1e30, 0);
		
		if (payload.terminated != 0) break;

		if (i > 2) {
			float p = clamp(max(payload.beta.r, max(payload.beta.g, payload.beta.b)), 0.05, 1.0);
			if (rand(payload.seed) > p) {
				break;
			}
			payload.beta /= p;
		}

		origin = payload.nextOrigin;
		dir = payload.nextDir;
	}

	ivec2 ipixel = ivec2(pixel);

	// 누적 버퍼
	vec4 prevAccum = vec4(0.0);
	if (options.currentSpp > 0) {
		prevAccum = imageLoad(accumPrevImage, ipixel);
	}
	vec4 newAccum = prevAccum + vec4(payload.L, 1.0);
	imageStore(accumCurImage, ipixel, newAccum);

	// 현재 샘플 수로 정규화된 출력
	vec3 finalColor = newAccum.rgb / (float(options.currentSpp) + 1.0f);
	imageStore(outputImage, ipixel, vec4(finalColor, 1.0));

}

ray가 생성되는 곳이고 딱히 어렵다할 부분은 없는데 하나씩 설명하자면

if (options.currentSpp >= options.maxSpp) {
		return;
	}

들어오자마자 현재와 맥스 spp를 확인하여 이미 max에 도달했다면 별다른 일 없이 리턴이다.

    uvec2 pixel = gl_LaunchIDEXT.xy;
    uvec2 size = gl_LaunchSizeEXT.xy;
    
	// vec2 uv = (vec2(pixel) + vec2(0.5)) / vec2(size);

    uint seed = initRandom(size, pixel, options.frameCount);
	vec2 jitter = vec2(rand(seed), rand(seed));
	vec2 uv = (vec2(pixel) + jitter) / vec2(size);

    vec2 screen = uv * 2.0 - 1.0;
    screen.y = -screen.y;
    float aspect = float(size.x) / float(size.y);
    float scale = tan(radians(camera.fovY) * 0.5);

    vec3 dir = normalize(
        screen.x * aspect * scale * camera.camRight +
        screen.y * scale * camera.camUp +
        camera.camDir
    );
	vec3 origin = camera.camPos;

현재 들어온 곳이 화면의 어느 픽셀인지 계산을 하여 카메라의 위치와 화면을 고려하여 레이의 위치와 방향을 결정하는 단계이다.

여기서 jitter부분은 서브픽셀의 렌덤위치에서 레이를 생성하여 엘리어싱을 방지해주는 기법을 사용했다.

	payload.L = vec3(0.0);
	payload.beta = vec3(1.0);
	payload.nextOrigin = origin;
	payload.nextDir = dir;
	payload.bounce = 0;
	payload.seed = initRandom(size, pixel, options.frameCount);
	payload.terminated = 0;


	for (int i = 0; i < 16; ++i) {
		payload.bounce = i;
		traceRayEXT(topLevelAS, gl_RayFlagsOpaqueEXT, 0xFF, 0, 0, 0,
					origin, 0.0001, dir, 1e30, 0);
		
		if (payload.terminated != 0) break;

		if (i > 2) {
			float p = clamp(max(payload.beta.r, max(payload.beta.g, payload.beta.b)), 0.05, 1.0);
			if (rand(payload.seed) > p) {
				break;
			}
			payload.beta /= p;
		}

		origin = payload.nextOrigin;
		dir = payload.nextDir;
	}

payload는 rgen 셰이더와 rchit, rmiss 셰이더간 정보 교환이 일어나는 구조체다.

rgen에서 payload를 생성하여 초기화해준뒤 레이를 쏘면

blas로 생성된 오브젝트가 맞았을때 rchit 셰이더로 들어가는 구조이다.

쏠 때 거리를 지정해줄 수 있는데 그 거리만큼 레이가 갔는데도 blas구조에 맞지 않으면 rmiss 셰이더로 들어간다.

위 코드는 payload 초기화와 직접적으로 path tracing이 일어나는 코드이다.

최대 16번을 튕기면서 레이를 쏘는데 쏘면 rchit나 rmiss 셰이더에 들어가고 payload구조체가 갱신되고 다시 레이를 쏘는 구조이다.

안에 if문은 러시안 룰렛 기법으로 기여도가 너무 없는 레이를 확률적으로 삭제하는 로직이다. 이게 없으면 끝까지 16번 돌것이고 이러면 1spp를 생성하는데 너무 많은 계산이 들어가게 된다. (1번의 샘플을 만들기 위해 해상도 x 16번의 path tracing 계산)

	ivec2 ipixel = ivec2(pixel);

	// 누적 버퍼
	vec4 prevAccum = vec4(0.0);
	if (options.currentSpp > 0) {
		prevAccum = imageLoad(accumPrevImage, ipixel);
	}
	vec4 newAccum = prevAccum + vec4(payload.L, 1.0);
	imageStore(accumCurImage, ipixel, newAccum);

	// 현재 샘플 수로 정규화된 출력
	vec3 finalColor = newAccum.rgb / (float(options.currentSpp) + 1.0f);
	imageStore(outputImage, ipixel, vec4(finalColor, 1.0));

다 계산이 되면 payload의 L부분이 그 픽셀의 샘플 색이 되는 거고 이를 누적하여 출력용 이미지에 적재하면 path tracing 종료이다.

일단 여기까지 하고

그 다음은 레이를 발사해서 오브젝트 어딘가에 맞았을 때

위의 코드의

traceRayEXT(topLevelAS, gl_RayFlagsOpaqueEXT, 0xFF, 0, 0, 0,
					origin, 0.0001, dir, 1e30, 0);

이부분 이후의 rchit 또는 rmiss 셰이더에서 일어나는 일을 써야겠다.

pt - 13. svgf 폐기

surkim — Tue, 12 Aug 2025 16:35:01 +0900

호기롭게 SVGF(Screen Space Variance Guided Filtering) 적용을 시도했지만,
원하는 퍼포먼스가 나오지 않아 폐기하기로 했다.
필터 자체의 한계도 명확히 보였다.

그래도 얻은 건 있었다.
논문을 찾아 읽고 직접 구현해본 경험,
그리고 구현 과정에서 여러 문제를 맞닥뜨리고 해결해본 경험이다.

가장 기억남는것중 하나가 알베도 디모듈레이션(demodulation) 과정에서 생긴 문제다.

필터 적용 전에 알베도 성분이 날아가는 것을 방지하여

빛 성분을 알베도로 나누는 방식인데, 처음에는 모든 픽셀에 그대로 적용했다.

그 결과, 알베도가 0에 가깝거나 아예 없는 픽셀에서도 나눗셈이 일어나 값이 튀었고,
히스토리 버퍼가 오염되면서 노이즈가 크게 발생했다.

특히 Path Tracing에서는 완전 스펙큘러 반사나 광원 직접 샘플링, 그리고 디퓨즈 스페큘러 섞여 있는 재질에서도 확률상 스페큘러만 계산되는 것도 있어서 결국 알베도 개념이 없는 픽셀이 많다.

이런 경우까지 나눗셈을 하니 깨끗해야 할 값이 망가졌다.

마지막에는 조건을 걸어, 알베도가 존재하고 일정 값 이상일 때만 나누도록 수정했다.

그렇게 해서 문제는 해결했지만, 전체적인 구조와 성능 문제로 SVGF 자체는 사용하지 않기로 했다.

성능 면에서는 Path Tracing 원본 출력은 노이즈가 있어도 현실감이 강하게 느껴졌는데,
SVGF를 적용하면 노이즈는 줄지만 화면이 부드럽게 뭉개져서 오히려 밋밋해 보였다.

특히 디모듈 모듈 문제에서 스페큘러 부분이 많이 없어져버리는 문제가 심했다.

게다가 필터 과정이 생각보다 느려, 기대했던 프레임 향상 효과도 없었다.
결국 효과와 성능 모두 만족스럽지 않다는 결론을 내리고 폐기했다.

총 정리 ppt 중 일부

깃에는 PBRT-bathroom-renderer 로 옮겨서 path tracing 만 적용된 버전으로 따로 옮기고

소개문을 작성해주었다.

https://github.com/ksro0128/PBRT_bathroom_renderer

GitHub - ksro0128/PBRT_bathroom_renderer

Contribute to ksro0128/PBRT_bathroom_renderer development by creating an account on GitHub.

github.com

지금까지는 .pbrt 파일만 지원하는 렌더러 였는데

이제는 .gltf를 지원하는 패스트레이싱 렌더러를 만들었다.

재질별 계산식을 통합식으로 수정했고

투과는 하고있는데..

gltf 특성상 투과를 얇은 재질, 두꺼운 재질 2가지를 지원하는데

이걸 통합적으로 생각하다가 지금은 흐지부지 되었었다.

일단은 빼고 ui만 수정해서 마무리짓고 정리해서 글 올려야겠다.

pt - 12. taa 적용

surkim — Mon, 19 May 2025 10:15:44 +0900

Path Tracing 파이프라인에서 서브픽셀 단위로 지터링된 primary ray를 생성하여 샘플을 수집하고

이를 프레임마다 누적하는 방식으로 TAA를 적용하였다.

레스터라이제이션을 활용한 gbuffer 생성 방식을 고려해보았지만

primary ray 생성 로직 자체를 변경하지 않는 이상 구조적으로

오히려 성능 저하 요인이 된다고 판단하여 해당 방식은 일단 폐기

pt - 11. svgf 로직 수정 (샘플 수 적을 때)

surkim — Fri, 16 May 2025 10:13:13 +0900

spp가 적을때 로직을 수정했다.

필터 적용시 픽셀의 분산 샘플이 적으면 루미넌스를 제외한 depth, normal 인자로 7x7 bilateral 필터를 적용해야한다.

atorus 1step만 적용했었는데 1step이 아니라 5step 전부 7x7 bilateral 필터로 적용해야 했었다.

고치기 전

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

pt - 10. NEE 계산 수정, svgf 디모듈레이션 수정, 필터에서 거울만 수정

surkim — Thu, 15 May 2025 10:38:13 +0900

Path Tracing에서 Next Event Estimation (NEE) 을 도입하면

직접광 샘플링과 BRDF 샘플링이 동시에 조명을 설명하게 되므로

Multiple Importance Sampling (MIS) 을 통해 두 샘플링 방식의 중복 기여를 보정해야 한다.

NEE를 적용한 이후 직접광 샘플에 대해서는 MIS weight를 올바르게 적용했지만

간접광 (BRDF를 따라간 bounce) 에 대해서는 MIS weight 계산이 누락된 것을 확인했다.

때문에 NEE를 추가했을때 MIS 보정이 들어가지 않아서 과하게 밝아지는 문제가 발생했던 것이다.

결과적으로 간접광만 누적한것과

NEE를 추가해서 누적한 이미지는 같아야하는데 (수렴속도만 차이나야하는데)

NEE를 추가하면서 과하게 밝아진 부분을 해결했다.

처음에는 밝아지는 게 맞다고 생각했어서 이 문제를 자각하지 못했다.

NEE 적용 전

NEE를 적용했지만 간접광에는 mis적용이 안된 이전 이미지

전부 적용

1: nee 적용전, 2: 잘못된 적용, 3: 제대로 적용 (1spp)

왼쪽: 샘플 수 많이 늘렸을 때, 오른쪽: 레퍼런스

svgf 디모듈레이션 수정

직접광, 간접광을 따로 샘플링하고 정확하게 알베도의 영향을 디모듈레이션 해줘야하는데

간접광 (brdf 따라간 bounce)샘플링은 재질 특성에 따라 확률적으로 디퓨즈, 스펙큘러중 하나를 선택해 적용하기 때문에 알베도를 제거하기가 쉬웠지만

직접광은 샘플링할 때

디퓨즈, 스펙큘러 혼합재질일 경우 한 샘플링 광원에 대해 각각 계산한 후 합해서 사용했었기 때문에

알베도를 정확하게 제거하기가 어려웠다.

따라서 간접광 계산할 때 처럼 재질 특성에 따라 확률적으로 디퓨즈, 스펙큘러를 하나 선택해 적용하는 것으로 바꿨고

디퓨즈일 때만 알베도를 디모듈 해주는 방식으로 바꿨다.

사실 이렇게 해도 NEE 샘플링자체가 간접광의 패스를 따라서 샘플링이 진행되기 때문에

2번째 바운스 이후부터는 직접광 누적에 간접광의 throughput이 들어가는 구조라

알베도의 영향을 전부 제거하지는 못했다.

그래도 영향도가 매우 낮아 이상한 색이 나오진 않는 거 같다.

또한 모듈레이션도 지금 그냥 알베도를 곱하는 형식으로 하고있는데 이러면

필터링된 디퓨즈 + 스펙큘러 영향에 그냥 albedo를 곱하는 형식이라

정확한 계산이 아닌거 같다.

정확하게 하려면 직접광의 디퓨즈 스펙큘러, 간접광의 디퓨즈 스펙큘러

싹 다 나눠서 디모듈 -> 필터링 -> 모듈레이션 해야 정확할 거 같은데

이러면 논문에 제시한 방법도 아니거니와

필터링 자체가 무거운데 그걸 두번 더 해야하는 거라

고민이 필요한거 같다..

고치기 전

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

일단은 푸른빛 돌던게 사라졌다.

혼합재질에서 스펙큘러 부분이 거의 사라져버렸는데 이게 지금 잘 적용이 되서 이런건지

아니면 계산부분에서 누락된 부분이 있는건지 확인해봐야 할것 같다.

거울 재질 조정

씬의 4분의 1이 거울인데 흐릿하게 나와 안이쁜 것 같아서 이 부분만 조금 조정했다.

우선 흐릿하게 나오는 이유가 필터링 거칠 때 사용하는 인자들이

1. 표면의 법선벡터, 2. 뎁스, 3. 루미넌스 값인데

거울 재질에서 보이는 부분은 법선벡터와 뎁스차이가 거의 없으니깐

강한 필터링을 거치게 되어 생긴 문제

거울일 때만 gbuffer를 튕겨 보이는 부분의 정보로 바꿔서

선명하게 보이도록 바꿨다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

가까이 가면 전프레임에 있는 부분이었지만 갱신되는 부분은

일치도 검사할 때 depth차이에 대한 부분을 너무 강하게 잡아서 생긴 문제였고

약간 느슨하게 바꿔줘서 해결했다.

pt - 9. 푸른 빛 원인 찾음

surkim — Wed, 14 May 2025 10:41:14 +0900

직접광 / 간접광을 분리하여 샘플링하고 디모듈레이션 하는 과정에서

잘못된 방법을 사용하여 푸른빛이 도는 결과가 나온 것이었다.

간접광 계산할 때 디퓨즈와 스페큘러 샘플링을 확률적으로 선택하여 진행되는데

이 중 디퓨즈 샘플링일때만 albedo 영향을 받기 때문에 일괄적으로 albedo를 나누면 안되고

실제 albedo영향을 받는 픽셀만 선택하여 디모듈레이션 해줘야했다.

위 이미지는 정확한 결과 이미지는 아니고

간접광에서는 정확하게 albedo영향을 계산해서 빼줬는데

직접광 영향은 아직 정확하게 계산을 못해서 직접광은 잠시 albedo 성분을 vec3(1.0)으로 없애고 실험해보았다.

pt - 8. 전반적인 정리 (NEE 개념, svgf 개념), 현재 문제점들

surkim — Mon, 12 May 2025 19:01:03 +0900

레퍼런스

복습

렌더링 방정식

모든 렌더링은 이 렌더링 방정식을 푸는 것으로 시작

렌더링 방정식은 순환 적분식 구조이므로 직접푸는 것은 불가능

렌더링 방정식 몬테카를로 근사

따라서 몬테카를로와 같은 근사식으로 렌더링 방정식을 근사

path tracing 진행

path tracing은 경로 하나만 샘플링하여 그 경로하나가 전체 적분 값을 대표하도록 처리

기존 구현 방식

초기에는 BRDF 중요도 기반 샘플링을 통해 path tracing을 구성
BRDF로 샘플링한 방향이 우연히 광원에 도달하면
그때만 throughput × radiance를 계산하는 방식

BRDF 샘플링 → 경로 따라 ray를 쏨
광원에 닿을 때까지 bounce
맞으면 그때만 기여 누적

문제점

1 SPP에서 광원에 도달하지 못하면 그 샘플이 버려짐
노이즈가 심하고 수렴이 느림

NEE (Next Event Estimation) 추가

NEE는 ray가 광원에 맞을 때를 기다리지 않고
맞은 지점에서 직접광을 샘플링하여 즉시 조명 기여를 평가하는 방식

기대 효과

1 SPP에서도 광원이 보이는 위치라면 직접광 기여를 누적 가능
따라서 노이즈가 줄고 수렴이 훨씬 빨라짐

NEE는 다음과 같은 순서로 수행

현재 위치에서 scene 내 광원 중 하나를 무작위로 선택 (광원에 모양이 있어 삼각형으로 전부 쪼개서 저장) 즉 광원 삼각형을 선택
선택한 광원의 면적 중 한 점을 sampling
해당 위치를 향해 shadow ray를 하나 발사
그 경로가 가려지지 않았다면 → BRDF를 통해 기여량 계산
계산된 조명 기여를 현재 throughput에 곱해 누적

직접광 계산

pdf 계산

광원중 하나 x 면적

후에 나올 brdf의 계산은 입체각 기준이기 때문에 입체각 기준으로 계산

따라서

cos x 레이를 쏘려는 지점에서 법선 방향과 레이의 내적
cos y 광원 지점에서의 법선 방향과 레이의 내적
pdf: light sampling 시 해당 방향으로 샘플될 확률

주의점

같은 조명 기여가 두 경로에서 중복 계산 될 수 있음

결과가 편향될 수 있음 -> 노이즈 증가

따라서 MIS(Multiple Importance Sampling) 사용

MIS란? 여러 샘플링 전략이 동일한 기여를 만들 수 있을 때

중복 없이, 편향 없이 합산하기위한 방법

Balance Heuristic

샘플링한 레이를 brdf 기준으로 계산한 pdf와 balance heuristic

따라서 최종 NEE기여는

NEE추가해서 나온 이미지

왼쪽: 추가 전, 오른쪽: 추가 후 spp 4096

왼쪽: 추가 전, 오른쪽: 추가 후 spp 1

svgf 도입 중

이제 path tracing 결과를 기반으로 실시간 렌더링을 노려보고자 SVGF를 도입

논문을 열심히 읽고 구현하긴 했는데 자의적으로 해석한 부분이 있을 수도 있음,,,

구현 목표

1. 낮은 샘플 수에서 빠르게 수렴

2. 카메라 이동이나 씬 변화에도 노이즈가 안정적으로 억제

우선 전체적인 개요

전체 개요

path tracing 결과는 직접광과 간접광으로 나눠서 처리

직접광은 NEE를 통해 직접 샘플되기 때문에 신뢰도가 높고, variance가 낮음
간접광은 bounce를 여러 번 거쳐 얻어진 결과이므로 variance가 높고, 노이즈도 많음

따라서 두 성분을 같은 필터 강도로 처리하면 비효율적이기 때문에 나눠서 처리

필터링을 하기 전, 먼저 radiance를 albedo로 나눈다.

radiance에는 texture 색 정보가 곱해져 있는데 이 상태로 필터링하면 텍스처 디테일까지 뭉개짐
따라서 필터링 전에는 albedo를 제거해서 색 정보를 분리 -> 필터링 후에는 다시 albedo를 곱해서 원래 색을 복원

이 과정을 통해 노이즈는 줄이되 텍스처 디테일은 유지할 수 있음

그 다음에 직접광 간접광 각각 필터링

그 다음 필터링한 두 이미지를 합치고 다시 albedo를 곱해서 원래 색을 복원

그 뒤 톤 매핑과 안티엘리어싱

필터링

1. Temporal Accumulation

우선 1 spp path tracing 결과를 프레임 간 누적

이때 단순히 과거 프레임 색을 복사하지 않고,
Motion Vector, Normal, Depth, Mesh ID를 이용해 이전 프레임 값이 현재 픽셀과 같은 지점에서 온 값인지 판단

일치도 판단 방식

재투영된 위치를 기준으로 2×2 주변 픽셀을 bilinear 보간
각 픽셀의 Normal, Depth, Mesh ID를 비교
4개 중 하나라도 일치하면 → 가중 평균으로 누적
4개 모두 일치 안 하면 → 3×3으로 범위 확장
그래도 없으면 → 재시작 (이전 값 무시)

누적 방식: EMA (Exponential Moving Average)

α: blending weight

ci-1: history color 이미지 (필터의 1step 결과물)

이 방식은 오래된 샘플은 점점 희석되지만 빠르게 수렴하기 때문에 실시간 렌더링에 적합

-> 이제 많이 누적된다고 화면 개선이 되진 않는다.

2. 분산 추정

이 단계에서는 누적된 샘플들의 시간 변화량을 분석하여, 해당 픽셀에 노이즈가 얼마나 있는지를 판단

분산이 크다 → 샘플들이 시간에 따라 많이 흔들렸다 → 노이즈가 많을 가능성 높음
분산이 작다 → 결과가 시간에 따라 안정적이다 → 노이즈가 적음

분산을 추정하기 위해, 다음 두 값을 시간 축 누적 방식으로 저장

휘도의 평균 (mean of luminance)
휘도의 제곱 평균 (mean of luminance²)

이 두 값을 가지고 고전적인 분산 계산 방식

을 통해 분산을 구함

구현 방식

이전 프레임에서 누적해둔 휘도의 평균 , 휘도의 제곱 평균을 현재 프레임에서 motion vector로 재투영하여 불러온 뒤

재투영 유효성 판별(=일치도 검사)은 Temporal Accumulation과 동일하게 수행하고

이 결과를 바탕으로 현재 픽셀의 분산을 계산

여기서 계산된 분산은 뒤에 필터에서 weight 계산하기위해 들어 간다.

샘플수가 적을 때 (spp < 4)

누적된 샘플 수가 너무 적다면 분산 값은 신뢰할 수 없다.

이 경우엔 분산 기반 필터를 사용하지 않고

7x7 bilateral 필터를 fallback으로 적용 (depth, normal만 사용)

3. a-torus wavelet 필터

노이즈를 제거하면서도 경계를 보존하는 필터링 기법

특징은 픽셀 사이를 건너뛰며 필터링 커널을 적용하는 방식을 사용

1스텝: 이웃한 픽셀 (stride = 1)
2스텝: 1칸 건너뛰며 필터 적용 (stride = 2)
3스텝: 2칸 건너뛰며 적용 (stride = 4)

스텝이 진행될수록 더 넓은 범위를 필터링 가능

A-Trous 필터는 픽셀 주변 이웃들과의 유사도를 판단해
가중 평균(weighted average)을 통해 radiance 값을 보간

Normal weight: 물체 표면의 방향이 비슷할수록 높은 가중치
Depth weight: 깊이 차이가 작을수록 높은 가중치
Variance weight: 노이즈가 적을수록 더 신뢰할 수 있는 샘플

h(q)는 커널 내 위치 q에 대한 spatial weight, h = {1/16, 1/4, 3/8, 1/4, 1/16}
w(p,q)는 normal / depth / variance 기반 유사도 가중치,

ci(q)는 이전 스텝의 radiance 값

이 수식은 주변 픽셀들과의 유사도(weight)를 기반으로 한 가중 평균 필터

A-Trous 필터는 radiance 값뿐 아니라, 해당 radiance의 신뢰도인 분산(variance)도 함께 필터링

필터링이 반복될수록 각 픽셀의 값은 주변과 섞여서 바뀌기 때문에,
그에 맞게 분산도 새로 계산되어야 정확한 weight 추정이 가능하기 때문

총 5스텝까지 적용
각 스텝마다 stride를 키우면서 더 넓은 영역까지 노이즈를 억제

1스텝: 가까운 노이즈 제거 (디테일 유지) -> history color 이미지로 저장
5스텝: 넓은 영역의 저주파 노이즈까지 제거 -> 출력 이미지

4. Edge-stopping functions

여기서 시그마는 보정 계수인데

σz = 1, σn = 128, σl = 4,

1. depth

σz = 1
깊이 차이가 클수록 weight를 낮게 설정
분모에 있는 ∇z⋅(p−q)는 로컬 depth gradient에 따른 보정
- depth 차이만 보면 무조건 경계인데
- 원래 그방향이 깊이 변화가 좀 있는 방향이면 그만큼 더 허용해줌

2. normal

σn = 128

법선 방향이 다르면 같은 표면이 아닐 가능성이 높으므로 weight를 급격히 줄여 강하게 억제.

3. luminance

분산 자체가 노이즈가 커서 가우시안 블러로 먼저 부드럽게 적용 후 사용
- a torus 들어가기 직전에만 사용 -> 갱신될 때마다 사용하지 않음
분산이 크면 → 이 픽셀 자체가 noisy → 밝기 차이에 덜 민감하게 필터링
분산이 작으면 → 이 픽셀은 안정됨 → 밝기 차이에 더 민감하게 대응

아까 정리했듯 분산은 필터내에서 스텝마다 갱신된다.

현재 구현된 내 파이프라인

1. Path Tracing

G-buffer 생성 - primary ray로 gbuffer생성
- Normal
- Depth
- Albedo
- Mesh ID
이전 카메라 정보를 받아 이전 프레임의 normal depth meshID과 일치도 판별을 하여 누적or갱신 판단
- 현재 픽셀 월드 위치 -> 이전 카메라로 스크린 변환을 거쳐 -> 이전 픽셀 좌표 예측
- 픽셀 기준으로 먼저 2x2개의 픽셀 가져옴 -> 조건 만족하는 픽셀만 누적 평균
- 없으면 3x3 -> 이래도 없으면 초기화
누적/분산 계산을 위한 이미지 생성
- Sample Count: 픽셀당 분산이 얼마나 누적되었는지 저장
- Moment1: 직접광 / 간접광 각각 휘도의 평균
- Moment2: 직접광 / 간접광 각각 휘도의 제곱 평균
출력 결과
- Direct history + 1spp direct 샘플 ema누적 결과, a = 0.05
- Indirect history + 1spp indirect 샘플 ema누적 결과, a = 0.05
- Direct/Indirect 각각의 분산 맵 + 샘플에 누적된 픽셀 수 -> (spp < 4) 판단

2. 3×3 Gaussian 필터

직접광, 간접광 각각의 분산 이미지에 한 번만 적용

3. A-Trous Wavelet 필터

Direct / Indirect 각각 독립적으로 필터링 수행
총 5 스텝 반복, stride는 1 → 2 → 4 → 8 → 16
1스텝 결과는 history buffer로 저장 (다음 프레임 누적용)
5스텝 결과가 최종 필터링된 radiance 출력
spp < 4 일 경우 normal, depth 로만 7x7필터 ~~1step 만 진행~~ 로 5step 진행

4. Composite

필터링된 Direct + Indirect 결과를 합산하고,
최종적으로 Albedo를 곱해서 최종 색을 복원

현재는 Tonemapping과 TAA(Temporal Anti-Aliasing)는 아직 미구현 상태

결과

왼쪽: svgf 적용 전, 오른쪽: 적용 후

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

전반적으로 문제인데 가장 도드라지는 문제점 몇가지를 뽑아보면

1. 색 번짐 (Albedo 복원 후 문제)

바닥이나 세면대처럼 색이 있는 오브젝트에서
알베도를 나눴다 다시 곱하면 푸른빛이 번진다.

특히 normal이 비슷한 엣지 주변에서 색상이 번짐
→ 필터 가중치 계산식 확인 필요

2. 수렴 불안정 / 잔상 울렁거림

한 샘플의 영향이 크다 보니 전체 화면이 울렁거린다.

EMA 계수를 0.05까지 낮춰도 완전한 안정성은 부족하다.
→ 샘플링 전략과 누적 방식 재검토 필요

3. 거울 반사 영역 블러 현상

거울이나 반사 재질의 결과가 흐려지고 퍼져 보인다.

날카로운 반사 디테일이 유지되지 않음

→ 재질별 필터 강도 조정 또는 제외 처리 고려

pt - 7. svgf 필터 추가

surkim — Mon, 12 May 2025 10:39:24 +0900

SVGF 기법을 Path Tracing 렌더러에 단계적으로 도입 중이다.

현재는 초기 구현 단계로, 카메라 정지 상태에서의 샘플 누적 및 A-Trous 필터 기반의 분산 가이드 블러링이 구현된 상태다.

현재 구현된 구조

1. 기본 구조

G-buffer 구성
- Normal, Depth, Albedo를 G-buffer에 출력
조명 분리
- 직접광(Direct)과 간접광(Indirect)을 분리하여 샘플링
- 각 결과에 대해 Albedo 디모듈레이션 수행 (Radiance / Albedo)

2. Temporal Accumulation (단순 방식)

이전 프레임의 누적 버퍼가 존재할 경우, 현재 프레임과 8:2 비율로 선형 보간하여 누적
현재는 카메라 이동 시 모든 히스토리 삭제 (정확한 모션 벡터 기반 일치는 미도입 상태)

3. Variance Computation

각 픽셀에 대해 누적 평균과 제곱 평균을 저장하여 분산(variance) 계산
계산된 분산은 3x3 Gaussian 필터를 통해 보간

4. A-Trous 기반 가이드 필터링

직접광, 간접광 각각에 대해 5단계 필터링 수행
각 단계에서:
- 샘플 간격(step size)은 점진적으로 증가
- 현재 프레임의 Normal, Depth, Variance 정보를 사용하여 주변 픽셀과의 유사도를 계산
- 유사도에 따라 필터의 가중치를 조절 (edge-aware)
Step 1 결과는 History 버퍼로 저장되어 다음 프레임에서 temporal 합성에 사용

5. 최종 출력

Step5의 직접광, 간접광 결과를 합산 후,
다시 Albedo를 곱해 최종 색상 복원
결과 이미지를 화면에 출력

까지 했는데 결과가 생각대로 안나온 상태

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

결과 이미지까지 출력하는 단계까지 구현을 마쳤으나, 현재 결과가 예상한 품질과 일치하지 않는 상태다.

pt - 6. 푸른빛 해결, 안티 엘리어싱, 러시안룰렛 추가

surkim — Thu, 8 May 2025 10:57:34 +0900

1. NEE 이상 고침

샘플중 r 값만, (실질적으로 앞의 4bytes만) 0이 되어버려 전반적인 색이 푸르게 변하는 문제가 있었는데,

해결했다.

정확히 말하자면 .rgen 파일과 .rchit파일간 데이터를 raypayload 구조체로 주고 받는데

이 구조체가 참까다롭다.

명확한 레퍼런스는 결국 못찾아 확실하지 않은데

경험상 128bytes를 넘으면 예상하지 못한 에러가 난다.

이 에러가 정말 예상을 못하는게 명확한 에러가 나는게 아니라

부분적으로 특정 메모리 지역에 null이 채워진다 던가 하는 에러가 나서

원인 찾기가 쉽지가 않았다.

이제 BRDF 기반 경로 추적 과정에 Next Event Estimation(NEE)을 도입하여,
레이가 표면에 도달했을 때 광원을 샘플링해 직접광을 계산하고,
그 기여를 휴리스틱 밸런스를 통해 보정한 뒤 최종 radiance에 반영하도록 구현했다.

왼쪽: NEE 추가 전, 오른쪽: NEE 추가 후 (SPP 4096)

brdf기반으로 path tracing 과정에서

레이가 닿는 모든 표면에 대해 라이트를 샘플링 하는데

모든 라이트에 대해 기여를 전부 계산하지는 않고

현재 있는 모든 라이트를 삼각형 단위로 분해한 뒤

그 삼각형들 중 하나를 유니폼하게 선택하고
선택된 삼각형 내부에서 면적 기반 샘플링을 통해 한 점을 고르는 방식으로 구현했다.

샘플링된 위치가 현재 지점에서 가시적인 경우에만
BSDF와 geometric term을 고려하여 직접광 기여를 계산하고
light pdf에 기반한 MIS 보정 후 radiance에 반영했다.

샘플 하나일 때 차이가 명확하다.

왼쪽: NEE 추가 전, 오른쪽: NEE 추가 후 (SPP 1)

2. 안티 엘리어싱

안티 앨리어싱은 복잡하게 처리하지 않고,
픽셀 중심 대신 랜덤한 서브픽셀 위치에서 ray를 쏘는 방식으로 간단히 해결

프레임마다 다른 위치에서 샘플링되기 때문에
프레임 누적으로 자연스럽게 aliasing이 줄어드는 효과를 얻을 수 있었다.

왼쪽: 안티 엘리어싱 적용 전, 오른쪽: 적용 후 (SPP 4096)

왼쪽: 안티 엘리어싱 적용 전, 오른쪽: 적용 후

3. 러시안 룰렛

3번 bounce 이후부터 경로를 무조건 이어가는 대신

throughput에 비례한 확률로 생존 여부를 결정하는 러시안 룰렛을 적용했다.

에너지 보존을 위해 살아남을 경우에는 기여를 1/p로 보정한다.

왼쪽: 러시안 룰렛 적용 전, 오른쪽: 적용 후