3차원 구와 Ray Tracing

목적

Ray Tracing 역방향 광추적

렌더 부분의 변경

void Render(std::vector<glm::vec4> &pixels)
		{
			std::fill(pixels.begin(), pixels.end(), vec4{0.0f, 0.0f, 0.0f, 1.0f});

#pragma omp parallel for
			for (int j = 0; j < height; j++)
				for (int i = 0; i < width; i++)
				{
					const vec3 pixelPosWorld = TransformScreenToWorld(vec2(i, j));

					// 광선의 방향 벡터
					// 스크린에 수직인 z방향, 절대값 1.0인 유닉 벡터
					// Orthographic projection (정투영) vs perspective projection (원근투영)
					const auto rayDir = vec3(0.0f, 0.0f, 1.0f);

					Ray pixelRay{pixelPosWorld, rayDir};

					// index에는 size_t형 사용 (index가 음수일 수는 없으니까)
					// traceRay()의 반환형은 vec3 (RGB), A는 불필요
					pixels[size_t(i + width * j)] = vec4(traceRay(pixelRay), 1.0f);
				}
		}

Ray Class

#pragma once

#include <iostream>
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>

namespace hlab
{
    class Ray
    {
    public:
        glm::vec3 start; // start position of the ray
        glm::vec3 dir;   // direction of the ray
    };
}

Hit

#pragma once

#include <iostream>
#include <glm/glm.hpp>
#include <glm/gtx/string_cast.hpp>

namespace hlab
{
    class Hit
    {
    public:
        float d;// 광선의 시작부터 충돌 지점까지의 거리
        glm::vec3 point;// 충돌한 위치
        glm::vec3 normal;// 충돌한 위치에서 표면의 수직 벡터
        
        //std::shared_ptr<Object> obj; // 나중에 물체의 재질 등을 가져오기 위한 포인터
    };
}

TraceRay

// 광선이 물체에 닿으면 그 물체의 색 반환
		vec3 traceRay(Ray &ray)
		{
			const Hit hit = sphere->IntersectRayCollision(ray);

			if (hit.d < 0.0f)
			{
				return vec3(0.0f);
			}
			else
			{
				return sphere->color * hit.d; // 깊이를 곱해서 입체감 만들기
			}
		}

Sphere

#pragma once

#include "Hit.h"
#include "Ray.h"

namespace hlab
{
    using namespace glm;

    class Sphere
    {
    public:
        glm::vec3 center;
        float radius;
        glm::vec3 color; // 뒤에서 '재질(material)'로 확장

        Sphere(const glm::vec3 &center, const float radius, const glm::vec3 &color)
            : center(center), color(color), radius(radius)
        {
        }

        // Wikipedia Line–sphere intersection
        // https://en.wikipedia.org/wiki/Line-sphere_intersection
        Hit IntersectRayCollision(Ray &ray)
        {
            Hit hit = Hit{-1.0f, vec3(0.0f), vec3(0.0f)}; // d가 음수이면 충돌을 안한 것으로 가정

            /*
             * hit.d = ... // 광선의 시작점으로부터 충돌지점까지의 거리 (float)
             * hit.point = ... // 광선과 구가 충돌한 지점의 위치 (vec3)
             * hit.normal = .. // 충돌 지점에서 구의 단위 법선 벡터(unit normal vector)
             */

            // const float a = glm::dot(ray.dir, ray.dir); // dir이 unit vector라면 a는 1.0f라서 생략 가능


            return hit;
        }
    };
}

스피어를 레이트레이싱 해보자

충돌의 경우의 수

벡터를 이용한 계산

구의 방정식

직선의 방정식

방정식 결합

구현

Hit IntersectRayCollision(Ray &ray)
        {
            Hit hit = Hit{-1.0f, vec3(0.0f), vec3(0.0f)}; // d가 음수이면 충돌을 안한 것으로 가정

            /*
             * hit.d = ... // 광선의 시작점으로부터 충돌지점까지의 거리 (float)
             * hit.point = ... // 광선과 구가 충돌한 지점의 위치 (vec3)
             * hit.normal = .. // 충돌 지점에서 구의 단위 법선 벡터(unit normal vector)
             */
             // const float a = glm::dot(ray.dir, ray.dir); // dir이 unit vector라면 a는 1.0f라서 생략 가능
            const auto oc = ray.start - center;
            const float ocsqrt = glm::dot(oc, oc);
            const float nabla = ocsqrt - glm::abs(ocsqrt) - (radius * radius);

            if (nabla >= 0.0f)
            {
                const float d1 = -glm::dot(ray.dir,oc) + sqrt( nabla);
                const float d2 = -glm::dot(ray.dir,oc) - sqrt( nabla);
                hit.d = glm::min(d1, d2);
                hit.point = ray.start + hit.d;
                hit.normal = glm::normalize(hit.point);
            }

            return hit;
        }

Hit IntersectRayCollision(Ray &ray)
        {
            Hit hit = Hit{-1.0f, vec3(0.0f), vec3(0.0f)}; // d가 음수이면 충돌을 안한 것으로 가정

            /*
             * hit.d = ... // 광선의 시작점으로부터 충돌지점까지의 거리 (float)
             * hit.point = ... // 광선과 구가 충돌한 지점의 위치 (vec3)
             * hit.normal = .. // 충돌 지점에서 구의 단위 법선 벡터(unit normal vector)
             */
             // const float a = glm::dot(ray.dir, ray.dir); // dir이 unit vector라면 a는 1.0f라서 생략 가능
            const float b = 2.0f * glm::dot(ray.dir, ray.start - center);
            const float c = glm::dot(ray.start - center, ray.start - center) - (radius * radius);
            const float nabla = b * b / 4.0f - c; // 4.0f는 2.0f를 2번 곱해주기 때문에
            
            if (nabla >= 0.0f)
            {
                const float d1 = -b /2.0f + sqrt(nabla);
                const float d2 = -b /2.0f - sqrt(nabla);
                hit.d = glm::min(d1, d2);
                hit.point = ray.start + ray.dir * hit.d;
                hit.normal = glm::normalize(hit.point - center);
            }

            return hit;
        }

const float b

const float c

const float nabla

const float nabla = b * b / 4 - c

1. 나블라가 0보다 낮으면 충돌 안함 즉 색상 검정색 즉 그냥 리턴 해주면 됨 ( 위에서 hit을 검정색으로 초기화 했기 때문에 )

2. 나블라가 0과 같거나 크면 충돌에 대한 값을 넣어주면 됨

d1 과 d2

const d1 = -b / 2.0f + sqrt(nabla)
const d2 = -b / 2.0f - sqrt(nabla)

hit.d

hit.point

hit.normalize

결과