Ray tracing in a weekend (九)

New material:Dielectrics(介质)

概念:具有一定透明度,如玻璃、水、空气等。

原理:当光线从光密介质进入光疏介质(光疏和光密是相对而言的。空气的折射率约为1,水的折射率约为1.33,玻璃的折射率约为1.5。则水对空气而言为光密介质,水对玻璃而言又是光疏介质。),并且入射角超过临界角,那么发生全反射,类似mirror reflection;否则光线分成两束,一束进入新介质发生折射,另一束返回原介质发生反射。介质的折射率(ref_idx)是其自身的属性,而反射率/强度(reflect_prob)则与角度有关。当没有发生全反射时,依据反射率的大小来决定scattered是折射ray还是反射ray。

Ray tracing in a weekend (九)_第1张图片

material.h

#ifndef MATERIALH
#define MATERIALH

struct hit_record;

#include"ray.h"
#include"hitable.h"
#include"random.h"
#include

vec3 reflect(const vec3& v, const vec3& n)
{
	return v - 2 * dot(v, n)*n;
}


class material
{
public:
	//r_in是射向hitable的线,scattered是射出的线
	virtual bool scatter(const ray& r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const = 0;
};

class lambertian :public material//ideal diffuse
{
public:
	lambertian(const vec3& a):albedo(a){}
	virtual bool scatter(const ray& r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
	{
		vec3 target = rec.p + rec.normal + random_in_unit_sphere();
		scattered = ray(rec.p, target - rec.p);
		attenuation = albedo;//光线削弱
		return true;
	}

	vec3 albedo;//光线传播中的削弱值
};

class metal :public material//reflection
{
public:
	metal(const vec3& a, float f) :albedo(a) { if (f < 1) fuzz = f; else fuzz = 1; }
	virtual bool scatter(const ray& r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
	{
		vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
		scattered = ray(rec.p,reflected+fuzz*random_in_unit_sphere());
		attenuation = albedo;//光线削弱
		return (dot(scattered.direction(), rec.normal) > 0);
	}
	vec3 albedo;
	float fuzz;
};

bool refract(const vec3& v, const vec3& n, float ni_over_nt, vec3& refracted)
{
	vec3 uv = unit_vector(v);//入射ray的方向向量
	//在介质中ray可以进入object也可以从中出去
	float dt = dot(uv, n);
	float discriminant = 1.0 - ni_over_nt*(1 - dt*dt);
	//从光密介质进入光疏介质时,如果入射角大于临界角就会发生全反射,不会有折射
	//没有发生全反射的情况
	if (discriminant > 0)
	{
		refracted = ni_over_nt*(uv - dt*n) - sqrt(discriminant)*n;
		return true;
	}
	else
		return false;
}

//计算介质的反射率,除非发生全反射,不然入射光线会分为折射和反射两束光线
//有时折射强有时反射强,都要考虑
float schlick(float cosine, float ref_idx)
{
	float r0 = (1 - ref_idx) / (1 + ref_idx);
	r0 = r0*r0;
	return r0 + (1 - r0)*pow((1 - cosine), 5);
}

class dielectric :public material//介质,有一定透明度,如水、玻璃等
{
public:
	dielectric(float ri) : ref_idx(ri) {}//构造函数设置介质的折射率
	virtual bool scatter(const ray& r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
	{
		vec3 outward_normal;
		//先求出反射ray的方向,这个是一定会用到的
		vec3 reflected = reflect(r_in.direction(), rec.normal);
		float ni_over_nt;
		attenuation = vec3(1.0, 1.0, 1.0);//光通过介质不会衰减
		vec3 refracted;
		float reflect_prob;//介质的反射率,与折射率不同,反射率与角度相关
		float cosine;//上面提到的角度
		//当这个数量积大于0时说明ray是从介质中出去(normal由球心指向外)
		//不同的情况下用于求折射ray方向的outward_normal、ni_over_nt
		//还有用于求反射ray强度的cosine都不同
		if (dot(r_in.direction(), rec.normal)>0)
		{
			outward_normal = -rec.normal;
			ni_over_nt = ref_idx;
			cosine = ref_idx*dot(r_in.direction(), rec.normal) / r_in.direction().length();
		}
		else//ray从空气进入介质
		{
			outward_normal = rec.normal;
			ni_over_nt = 1.0/ref_idx;
			cosine = -dot(r_in.direction(), rec.normal) / r_in.direction().length();
		}
		//确定好所需的outward_normal、ni_over_nt和cosine便可以讨论何时返回refracted何时返回reflected
		//没有全反射,可以求出折射ray的情况,就需要判断上面的问题,所以才求reflect_prob
		if (refract(r_in.direction(), outward_normal, ni_over_nt, refracted))
		{
			reflect_prob = schlick(cosine, ref_idx);
		}
		else//发生全反射,scattered ray的方向肯定就是reflected了,反射率就是1
		{
			reflect_prob = 1.0;
		}
		//随机生成一个0至1的数,小于反射率就将scattered的方向置为reflected
		if (drand48() < reflect_prob)
		{
			scattered = ray(rec.p, reflected);
		}
		else
		{
			scattered = ray(rec.p, refracted);
		}
		return true;
	}
	float ref_idx;
};
#endif MATERIALH

RayTracer.cpp

#include"vector.h"
#include"ray.h"
#include"sphere.h"
#include"hitable_list.h"
#include"camera.h"
#include"material.h"
#include"random.h"
#include
#include
#include
#include
#include

using namespace std;

//此处的world就是把整个场景里的所有object视为一体(即hitable_list)
//depth是ray的传播深度,scatter一次加一
vec3 color(const ray& r,hitable *world,int depth)
{
	hit_record rec;
	//如果viewing ray(反向光线)与hitable object相交
	//tmin采用0.001是基于对showdow的考量,见fundamentals p86
	//然而当前还没有引入light,阴影部分是因为当光线到达此处时经历了太多次反射
	if (world->hit(r, 0.001, FLT_MAX, rec))
	{
		//当前还不能确定是difusse还是reflection,取决于hitable的material
		ray scattered;
		vec3 attenuation;//削弱
		//如果scatter次数小于50
		//并且ray接触的hitable object的material能成功调用scattered函数
		if (depth < 50 && rec.mat_ptr->scatter(r, rec, attenuation, scattered))
		{
			return attenuation*color(scattered, world, depth + 1);
		}
		else//scatter超过50次,能量全被吸完了;scattered函数调用失败
		{
			return vec3(0, 0, 0);//黑
		}
	}
	else//注意当前还是没有引入light,依然是由最后一条ray的direction的y值决定color
		//实际上可以认为是background在发光
	{
		vec3 unit_direction = unit_vector(r.direction());//得到单位方向向量,将y限定在-1至1之间
		float t = 0.5*(unit_direction.y() + 1.0);//间接用t代表y,将其限制在0至1之间
		return (1.0 - t)*vec3(1.0, 1.0, 1.0) + t*vec3(0.5, 0.7, 1.0);
		//所谓插值法,不同的ray对应的t不同,这些t决定了其对应的color为(1.0,1.0,1.0)和(0.5,0.7,1.0)之间某一RGB颜色
		//RGB各分量实际就是一个介于0.0至1.0的小数
	}
}

int main()
{
	int nx = 200;//200列
	int ny = 100;//100行
	int ns = 100;
	ofstream out("d:\\theFirstPpm.txt");
	out << "P3\n" << nx << " " << ny << "\n255" << endl;
	hitable *list[5];//我们自己定义world是什么,此处定义为两个sphere
	list[0] = new sphere(vec3(0, 0, -1), 0.5,new lambertian(vec3(0.1,0.2,0.5)));
	list[1] = new sphere(vec3(0, -100.5, -1), 100, new lambertian(vec3(0.8, 0.8, 0.0)));
	list[2] = new sphere(vec3(1, 0, -1), 0.5, new metal(vec3(0.8, 0.6, 0.2),0.3));
	list[3] = new sphere(vec3(-1, 0, -1), 0.5, new dielectric(1.5));
	list[4] = new sphere(vec3(-1, 0, -1), -0.45, new dielectric(1.5));
	hitable *world = new hitable_list(list, 5);//初始化world
	camera cam;
	for (int j = ny - 1;j >= 0;j--)//行从上到下
	{
		for (int i = 0;i < nx;i++)//列从左到右
		{
			vec3 col(0, 0, 0);
			for (int s = 0;s < ns;s++)
			{
				float u = float(i + drand48()) / float(nx);
				float v = float(j + drand48()) / float(ny);
				ray r = cam.get_ray(u, v);
				vec3 p = r.point_at_parameter(2.0);
				col += color(r,world,0);
			}
			col /= float(ns);
			//进行gamma校正,一般来说取gamma=2,原理及公式见fundamentals p63
			col = vec3(sqrt(col[0]), sqrt(col[1]), sqrt(col[2]));
			int ir = int(255.99*col[0]);
			int ig = int(255.99*col[1]);
			int ib = int(255.99*col[2]);
			out << ir << " " << ig << " " << ib << endl;
		}
	}
	return 0;
}

输出图像

 

 

你可能感兴趣的:(计算机图形学)