蒙特卡洛光线追踪技术系列 见 蒙特卡洛光线追踪技术

首先，让我们自己得到一个正常的表面，这样我们就可以遮荫。这是一个垂直于表面的向量，按照惯例，它指出。一个设计决策是这些法线（同样按惯例）是否为单位长度。这样会方便产生阴影，所以我会说可以这样，但我不会强制别人在代码中这样实现。这可能会导致细微的错误，所以请注意这是个人偏好，就像大多数这样的设计决策一样。对于球体，法向是指连接点减去中心的方向：

在地球上，这意味着从地球中心到你的矢量指向正上方。我们现在就把它放入代码中，并对其进行着色。我们还没有任何灯光或任何东西，所以让我们用颜色贴图来可视化法线。可视化法线的一个常用技巧（因为假设N是单位长度向量（因此每个分量介于-1和1之间）很容易而且有点直观）是将每个分量映射到0到1之间的间隔，然后将x/y/z映射到r/g/b。对于法线，我们需要命中点，而不仅仅是命中与否。让我们假设最近的命中点（最小t）。代码中的这些更改使我们能够计算并可视化N：

float hit_sphere(const Vector3& center, float radius, const Ray&r) {Vector3 oc = r.origin() - center;float a = dot(r.direction(), r.direction());float b = 2.0*dot(oc, r.direction());float c = dot(oc, oc) - radius*radius;float discriminant = b*b - 4 * a*c;if (discriminant < 0) {return -1.0;}else {return (-b - sqrt(discriminant)) / (2.0*a);}
}
Vector3 color(const Ray&r) {float t = (hit_sphere(Vector3(0, 0, -1), 0.5, r));if (t > 0.0) {Vector3 N = unitVector(r.pointAtParameter(t)-Vector3(0,0,-1));return 0.5*Vector3(N.x() + 1, N.y() + 1,N.z() + 1);}Vector3 unit_direction = unitVector(r.direction());t = 0.5*(unit_direction.y() + 1.0);return (1.0 - t)*Vector3(1.0, 1.0, 1.0) + t*Vector3(0.5, 0.7, 1.0);
}

然后得到效果：

现在，往场景里添加几个球怎么样？虽然有一个球体数组很诱人，但一个非常干净的解决方案是为光线可能击中的任何对象创建一个“抽象类”，并使球体和球体列表都成为您可以击中的对象。这个类应该被调用，这是一个窘境——如果不是“面向对象”编程的话，将它称为“object”会很好。“surface”是经常使用的，缺点是我们可能需要量。“Hitable”强调将它们结合在一起的成员函数。我不喜欢这些，但我会选择“hitable”。

这个可命中的抽象类将有一个接收光线的命中函数。大多数光线跟踪器都发现在tmax中添加一个有效的命中时间间隔是很方便的，所以只有当tmin<t<tmax时，命中才会“计数”。对于初始光线，这是正t，但正如我们将看到的，它可以帮助代码中的一些细节，使tmin到tmax有一个间隔。一个设计问题是，如果我们碰到了什么东西，是否要做一些计算正常值的事情；我们可能会在搜索的过程中碰到更接近的东西，我们只需要最接近的东西的正常值。我将使用简单的解决方案，并计算出将存储在某个结构中的一组数据。我知道我们需要在某个点的运动模糊，所以我将添加一个时间输入变量。下面是抽象类：

（在程序中为了和书上一致，把Vector3全部改为vec3）

#pragma once
#ifndef __HITABLE__H__
#define __HITABLE__H__#include "ray.h"struct hit_record {float t;vec3 p;vec3 normal;
};
class hitable {	public:virtual bool hit(const ray&r,float t_min,float t_max,hit_record&rec)const = 0;
};#endif

球体继承的类：

#pragma once
#ifndef __SPHEREH__
#define __SPHEREH__#include "Hitable.h"
class sphere :public hitable {
public:sphere() {}sphere(vec3 cen, float r) :center(cen), radius(r) {};virtual bool hit(const ray&r, float t_min, float t_max, hit_record&rec)const;vec3 center;float radius;
};
bool sphere::hit(const ray&r, float t_min, float t_max, hit_record&rec)const {vec3 oc = r.origin() - center;float a = dot(r.direction(), r.direction());float b = 2.0*dot(oc, r.direction());float c = dot(oc, oc) - radius*radius;float discriminant = b*b - 4 * a*c;if (discriminant > 0) {float temp = (-b - sqrt(discriminant)) / (2.0*a);if (temp < t_max && temp > t_min) {rec.t = temp;rec.p = r.pointAtParameter(rec.t);rec.normal = (rec.p - center) / radius;return true;}temp = (-b + sqrt(discriminant)) / (2.0*a);if (temp < t_max && temp > t_min) {rec.t = temp;rec.p = r.pointAtParameter(rec.t);rec.normal = (rec.p - center) / radius;return true;}}return false;
}#endif

以及对象列表：

#pragma once
#ifndef __HITABLELIST_H__
#define __HITABLELIST_H__#include "hitable.h"class hitable_list :public hitable {
public:hitable_list() {};hitable_list(hitable **l, int n) { list = l;list_size = n; }virtual bool hit(const ray&r,float tmin,float tmax,hit_record& rec)const;hitable **list;int list_size;
};bool hitable_list::hit(const ray&r, float tmin, float tmax, hit_record& rec)const {hit_record temp_rec;bool hit_anything = false;double closest_so_far = tmax;for (int i = 0;i < list_size;i++) {if (list[i]->hit(r, tmin, closest_so_far, temp_rec)) {hit_anything = true;closest_so_far = temp_rec.t;rec = temp_rec;}}return hit_anything;
}#endif

新的main函数：

#include <stdlib.h>
#ifdef _WIN64
#define GLUT_NO_LIB_PRAGMA
#pragma comment (lib, "opengl32.lib")  // link with Microsoft OpenGL lib 
#pragma comment (lib, "glut64.lib")    // link with Win64 GLUT lib 
#endif //_WIN64
#ifdef _WIN32
//On Windows, include the local copy of glut.h and glext.h
#include "glut.h"
#include "glext.h"
#define GET_PROC_ADDRESS( str ) wglGetProcAddress( str )
#endif
#include "vec3.h"
#include "ray.h"
#define WIDTH 400
#define HEIGHT 200
unsigned char *Pixels;
#include "hitable.h"
#include "Sphere.h"
#include "hitablelist.h"
#define MAXFLOAT 20.0vec3 color(const ray&r,hitable *world) {hit_record rec;if (world->hit(r, 0.0, MAXFLOAT, rec))return 0.5*vec3(rec.normal.x()+1, rec.normal.y() + 1, rec.normal.z() + 1);else {vec3 unit_direction = unitVector(r.direction());float t = 0.5*(unit_direction.y() + 1.0);return (1.0 - t)*vec3(1.0, 1.0, 1.0) + t*vec3(0.5, 0.7, 1.0);}
}
void Draw(void) {glClearColor(0.0, 0.0, 0.0, 1.0);glClear(GL_COLOR_BUFFER_BIT);glDrawPixels(WIDTH, HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, Pixels);glFlush();
}int main() {Pixels = (unsigned char*)malloc(WIDTH*HEIGHT*sizeof(unsigned char)*4);vec3 lower_left_corner(-2.0, -1.0, -1.0);vec3 horizontal(4.0,0.0,0.0);vec3 vertical(0.0,2.0,0.0);vec3 origin(0.0, 0.0, 0.0);hitable *list[2];list[0] = new sphere(vec3(0, 0, -1), 0.5);list[1] = new sphere(vec3(0, -100.5, -1), 100);hitable *world = new hitable_list(list, 2);for (int j = HEIGHT-1;j >= 0;j--) {for (int i = 0;i < WIDTH;i++) {int offset = (WIDTH*j + i) * 4;float u = float(i) / float(WIDTH);float v = float(j) / float(HEIGHT);ray r(origin, lower_left_corner+u*horizontal+v*vertical);vec3 p = r.pointAtParameter(2.0);vec3 col = color(r, world);Pixels[offset + 0] = (unsigned char)255.99*col[0];Pixels[offset + 1] = (unsigned char)255.99*col[1];Pixels[offset + 2] = (unsigned char)255.99*col[2];Pixels[offset + 3] = 255;}}int argc = 0;char *argv = {""};glutInit(&argc, &argv);glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);glutInitWindowSize(WIDTH, HEIGHT);glutCreateWindow("bitmap");glutDisplayFunc(Draw);glutMainLoop();
}

这就产生了一个图像，实际上只是一个可视化的地方，球体和他们的表面法向。这通常是一个很好的方式来看待你的模型的缺点和特点：