光线追踪(RayTracing)算法理论与实践(二)平面、材质、联合光线与物体求交

提要

经过上次的学习，我们已经可以建立一个简单的光线追踪的场景，接下来，我们继续我们的征程。

今天要得到的最终效果如下：

光线与物体求交

在光线追踪算法中，最重要的就是求光线与物体的相交，也就是实现IntersectResult Object::isIntersected(CRay _ray)方法。因为我求得交点之后就可以对该点的像素进行计算，然后显示，后续的很多效果（透明，反射....）还有算法的优化加速，都是在对相交算法的改进。

之前已经讨论了光线与球体的相交，今天讨论平面，三角形和多个物体，且不考虑折射和反射。

平面

平面在空间几何中可以用一个向量（法向量）和平面中的一点P0来表示。

平面就是满足下式的点集：n.（P-P0）=0

得到：n.P=d;d=n.P0;

给定射线p(t)=p0+tu,平面方程为n.p+d=0,将p(t)带入到平面方程，最后求得t：

t=(-d-(n.p0))/(n.u)

三角形

渲染中的基本图元包括点，线，还有三角形，建模中多面体大部分都是用三角形的拼接来表示。

首先来看一下空间三角形的表示。

假设用空间上a，b，c三点来表示一个三角形。

则三角平面内的任意一点可以表示为

即

法线向量表示为

将光线向量P = e + td带入，得到：

当B>0,r>0且B+r<1的时候，P在三角形内。

对方程进行变换并改写成矩阵的形式：

由克莱莫法则求得B，r，t

其中

则三角形和光线求交的伪代码可以表示为：

[cpp]view plaincopy

boolean raytri (ray r, vector3 a, vector3 b, vector3 c, interval [t0 , t1 ])
compute t
if (t < t0 ) or (t > t1 ) then
return false
compute γ
if (γ < 0) or (γ > 1) then
return false
compute β
if (β < 0) or (β > 1 − γ) then
return false
return true

平面多边形

已知条件是平面的m个顶点（p1...pm）还有平面的法向量n。

平面内的向量和法向量时垂直的，即点乘结果为0，可以且接方程：

(p − p1 ) · n = 0

其中p = e + td，解得：

这样我们就可以求得p点，如果p在平面内，则光线与平面相交，否则不相交。

但是如何知道p是否在平面内呢？

siggragh course上的解决方法是：从相交点往平面内的任意方向做一条射线，如果射线与多边形的边的交点数量为奇数则p在平面内，否则在平面外。

这个很好理解，用笔画一下就知道了。

一个场景

一个场景包含很多个图元，球体，正方体。。。

回到光线追踪的原理，从摄像机发射一条射线之后，当场景中只有单个物体，只需计算一个，就可以得到一个result，当场景中又多个物体的时候，我们需要做的就是计算多次，取距离最近的那个result。

伪代码

[cpp]view plaincopy

hit = false
for each object o in the group do
if (o is hit at ray parameter t and t ∈ [t0 , t1 ]) then
hit = true
hitobject = o
t1 = t
return hit

平面类的实现

平面类我们就可以用代码这样来描述：

[cpp]view plaincopy

<span style="font-size:14px;">#ifndef Plane_H
#define Plane_H
#include "gvector3.h"
#include "intersectresult.h"
#include "cray.h"
#include "checkermaterial.h"
#include "cobject.h"
class Plane:public CObject
{
public:
Plane();
Plane(const GVector3& _normal,float _d);
virtual ~Plane();
virtual IntersectResult isIntersected(CRay& RAY);
protected:
private:
//法向量
GVector3 normal;
//到原点的距离
float d;
};
#endif // Plane_H
</span>

接下来是求光线到平面的距离。

代码实现如下：

[cpp]view plaincopy

<span style="font-size:14px;">#include "plane.h"
Plane::Plane()
{
//ctor
}
Plane::~Plane()
{
//dtor
}
Plane::Plane(const GVector3& _normal,float _d)
{
normal=_normal;
d=_d;
}
IntersectResult Plane::isIntersected(CRay& ray)
{
IntersectResult result = IntersectResult::noHit();
float a = ray.getDirection().dotMul(this->normal);
if (a <0)
{
result.isHit=1;
result.object = this;
float b = this->normal.dotMul(ray.getOrigin()-normal*d);
result.distance = -b / a;
result.position = ray.getPoint(result.distance);
result.normal = this->normal;
return result;
}
}
</span>

接下来我们在场景中创建一个平面，然后渲染深度，得到下面的效果：

材质

在真实世界中，白色物体在绿光照射下看起来是绿色而不是白色，红色物体在绿光照射下看起来是黑色，而有的同样颜色的物体在同样的光照下亮度却不同，这都是由物体的材质不同造成的。
首先在项目中添加一个颜色类，然后定义一些方法。

color.h

[cpp]view plaincopy

#ifndef COLOR_H
#define COLOR_H
#include <stdlib.h>
#include <stdio.h>
#include <cmath>
#include <iostream>
using namespace std;
class Color
{
public:
float r;
float g;
float b;
Color();
Color(float _r,float _g,float _b);
Color add(const Color& c);
Color multiply(float s) const;
Color modulate(const Color& c) const;
void saturate();
void show();
virtual ~Color();
static inline Color black(){ return Color(0,0,0); }
static inline Color white(){ return Color(1,1,1); }
static inline Color red() { return Color(1,0,0); }
static inline Color green(){ return Color(0,1,0); }
static inline Color blue() { return Color(0,0,1); }
protected:
private:
};
#endif // COLOR_H

color.cpp

[cpp]view plaincopy

#include "color.h"
Color::Color()
{
//ctor
}
Color::~Color()
{
//dtor
}
Color::Color(float _r,float _g,float _b)
{
r=_r;g=_g;b=_b;
}
Color Color::add(const Color& c)
{
return Color(r + c.r, g + c.g, b + c.b);
}
Color Color::multiply(float s) const
{
return Color(r * s, g * s, b * s);
}
Color Color::modulate(const Color&c) const
{
return Color(r * c.r, g * c.g, b * c.b);
}
void Color::saturate()
{
r = r>1.0?1.0:r;
g = g>1.0?1.0:g;
b = b>1.0?1.0:b;
}
void Color::show()
{
cout<<"r:"<<r<<"g:"<<g<<"b:"<<b<<endl;
}

然后是定义一个材质的基类，后面要实现的各种材质都继承它：

material.h

[cpp]view plaincopy

#ifndef Material_H
#define Material_H
#include "gvector3.h"
#include "intersectresult.h"
#include "cray.h"
#include "color.h"
class Material
{
public:
Material();
Material(float _reflectiveness);
float getRef();
void setRef(float _reflectiveness);
virtual ~Material();
virtual Color sample(const CRay& ray,const GVector3& position,const GVector3& normal);
protected:
float reflectiveness;
private:
};
#endif // Material_H

material.cpp

[cpp]view plaincopy

#include "material.h"
Material::Material()
{
//ctor
}
Material::Material(float _reflectiveness)
{
reflectiveness=_reflectiveness;
}
Material::~Material()
{
//dtor
}
float Material::getRef()
{
return reflectiveness;
}
void Material::setRef(float _reflectiveness)
{
reflectiveness=_reflectiveness;
}
Color Material::sample(const CRay& ray,const GVector3& position,const GVector3& normal)
{
cout<<"Base sample!"<<endl;
}

实现两种材质，一种是棋盘材质，一种phong材质。

checkermaterial.h

[cpp]view plaincopy

#ifndef CHECKERMATERIAL_H
#define CHECKERMATERIAL_H
#include "material.h"
#include "color.h"
#include <stdlib.h>
class CheckerMaterial:public Material
{
public:
CheckerMaterial();
CheckerMaterial(float _scale,float _reflectiveness=0);
virtual ~CheckerMaterial();
virtual Color sample(const CRay& ray,const GVector3& position,const GVector3& normal);
protected:
private:
float scale;
};
#endif // CHECKERMATERIAL_H

checkermaterial.cpp

[cpp]view plaincopy

#include "checkermaterial.h"
CheckerMaterial::CheckerMaterial()
{
//ctor
}
CheckerMaterial::CheckerMaterial(float _scale,float _reflectiveness)
{
scale=_scale;
reflectiveness=_reflectiveness;
}
CheckerMaterial::~CheckerMaterial()
{
//dtor
}
Color CheckerMaterial::sample(const CRay& ray,const GVector3& position,const GVector3& normal)
{
float d=abs((floor(position.x * this->scale) + floor(position.z * this->scale)));
d=fmod(d,2);
return d < 1 ? Color::black() : Color::white();
}

phongmaterial.h

[cpp]view plaincopy

#ifndef PHONGMATERIAL_H
#define PHONGMATERIAL_H
#include"gvector3.h"
#include "color.h"
#include "cray.h"
#include "material.h"
// global temp
static GVector3 lightDir = GVector3(1, 1, 1).normalize();
static Color lightColor = Color::white();
class PhongMaterial:public Material
{
public:
PhongMaterial();
PhongMaterial(const Color& _diffuse,const Color& _specular,const float& _shininess,float _reflectiveness=0);
virtual Color sample(const CRay& ray,const GVector3& position,const GVector3& normal);
virtual ~PhongMaterial();
protected:
private:
Color diffuse;
Color specular;
float shininess;
};
#endif // PHONGMATERIAL_H

phongmaterial.cpp

[cpp]view plaincopy

#include "phongmaterial.h"
PhongMaterial::PhongMaterial()
{
//ctor
}
PhongMaterial::PhongMaterial(const Color& _diffuse,const Color& _specular,const float& _shininess,float _reflectiveness)
{
diffuse=_diffuse;
specular=_specular;
shininess=_shininess;
reflectiveness=_reflectiveness;
}
PhongMaterial::~PhongMaterial()
{
//dtor
}
Color PhongMaterial::sample(const CRay& ray,const GVector3& position,const GVector3& normal)
{
float NdotL = normal.dotMul(lightDir);
GVector3 H = (lightDir-ray.getDirection()).normalize();
float NdotH = normal.dotMul(H);
Color diffuseTerm = this->diffuse.multiply(std::max(NdotL, (float)0));
Color specularTerm = this->specular.multiply(pow(std::max(NdotH, (float)0), this->shininess));
return lightColor.modulate(diffuseTerm.add(specularTerm));
}

试着来渲染一下。

[cpp]view plaincopy

void renderDepth()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); // Reset The View
glTranslatef(-0.5f,-0.5f,-1.0f);
glPointSize(2.0);
PerspectiveCamera camera( GVector3(0, 10, 10),GVector3(0, -0.5, -1),GVector3(0, 1, 0), 90);
Plane plane1(GVector3(0, 1, 0),1.0);
CSphere sphere1(GVector3(0, 5, -10), 5.0);
plane1.material=new CheckerMaterial(0.1f);
sphere1.material=new PhongMaterial(Color::red(), Color::white(), 16);
long maxDepth=20;
float dx=1.0f/WINDOW_WIDTH;
float dy=1.0f/WINDOW_HEIGHT;
float dD=255.0f/maxDepth;
glBegin(GL_POINTS);
for (long y = 0; y < WINDOW_HEIGHT; ++y)
{
float sy = 1 - dy*y;
for (long x = 0; x < WINDOW_WIDTH; ++x)
{
float sx =dx*x;
CRay ray(camera.generateRay(sx, sy));
IntersectResult result = sphere1.isIntersected(ray);
//IntersectResult result = plane1.isIntersected(ray);
if (result.isHit)
{
Color color = sphere1.material->sample(ray, result.position, result.normal);
//Color color =plane1.material->sample(ray, result.position, result.normal);
color.saturate();
//color.show();
glColor3ub(color.r*255,color.g*255,color.b*255);
glVertex2f(sx,sy);
}
}
}
glEnd();
// 交换缓冲区
glfwSwapBuffers();
}

结果如下：

材质这一块有很多东西可以来探讨，而且它和光照联系的很紧密，这里先不探讨。

联合

之前的渲染测试我们都只渲染了单个的物体，现在我们需要在场景中显示多个物体，就上开篇的那副图一样。

创建一个union类，在渲染的时候将要渲染的东西都丟进去。

union.h

[cpp]view plaincopy

#ifndef UNION_H
#define UNION_H
#include "cobject.h"
#include <vector>
using namespace std;
class Union:public CObject
{
public:
Union();
virtual ~Union();
void push(CObject* object);
virtual IntersectResult isIntersected(CRay& _ray);
protected:
private:
vector<CObject*> cobjects;
};
#endif // UNION_H

union.cpp

[cpp]view plaincopy

#include "union.h"
Union::Union()
{
//ctor
}
Union::~Union()
{
//dtor
}
void Union::push(CObject* object)
{
cobjects.push_back(object);
}
IntersectResult Union::isIntersected(CRay& _ray)
{
const float Infinity=1e30;
float minDistance = Infinity;
IntersectResult minResult = IntersectResult::noHit();
long size=this->cobjects.size();
for (long i=0;i<size;++i){
IntersectResult result = this->cobjects[i]->isIntersected(_ray);
if (result.object && (result.distance < minDistance)) {
minDistance = result.distance;
minResult = result;
}
}
return minResult;
}

最后的渲染代码

[cpp]view plaincopy

void renderUnion()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); // Reset The View
glTranslatef(-0.5f,-0.5f,-1.0f);
glPointSize(2.0);
PerspectiveCamera camera( GVector3(0, 10, 10),GVector3(0, -0.5, -1),GVector3(0, 1, 0), 90);
Plane* plane1=new Plane(GVector3(0, 1, 0),1.0);
CSphere* sphere1=new CSphere(GVector3(-2, 5, -10), 5.0);
CSphere* sphere2=new CSphere(GVector3(5, 5, -10), 3.0);
plane1->material=new CheckerMaterial(0.1f);
sphere1->material=new PhongMaterial(Color::red(), Color::white(), 16);
sphere2->material=new PhongMaterial(Color::blue(), Color::white(), 16);
Union scence;
scence.push(plane1);
scence.push(sphere1);
scence.push(sphere2);
long maxDepth=20;
float dx=1.0f/WINDOW_WIDTH;
float dy=1.0f/WINDOW_HEIGHT;
float dD=255.0f/maxDepth;
glBegin(GL_POINTS);
for (long y = 0; y < WINDOW_HEIGHT; ++y)
{
float sy = 1 - dy*y;
for (long x = 0; x < WINDOW_WIDTH; ++x)
{
float sx =dx*x;
CRay ray(camera.generateRay(sx, sy));
IntersectResult result = scence.isIntersected(ray);
//IntersectResult result = plane1.isIntersected(ray);
if (result.isHit)
{
Color color = result.object->material->sample(ray, result.position, result.normal);
//Color color =plane1.material->sample(ray, result.position, result.normal);
color.saturate();
//color.show();
glColor3ub(color.r*255,color.g*255,color.b*255);
glVertex2f(sx,sy);
}
}
}
glEnd();
// 交换缓冲区
glfwSwapBuffers();
}

运行结果

最后我们来加一点反射的效果，在main.cpp中添加一个函数。

[cpp]view plaincopy

Color rayTraceRecursive(CObject* scene,CRay& ray,long maxReflect)
{
IntersectResult result = scene->isIntersected(ray);
if (result.object)
{
float reflectiveness = result.object->material->getRef();
Color color = result.object->material->sample(ray, result.position, result.normal);
color = color.multiply(1 - reflectiveness);
if ((reflectiveness > 0) && (maxReflect > 0))
{
GVector3 r = result.normal*(-2 * result.normal.dotMul(ray.getDirection()))+ray.getDirection();
CRay ray = CRay(result.position, r);
Color reflectedColor = rayTraceRecursive(scene, ray, maxReflect - 1);
color = color.add(reflectedColor.multiply(reflectiveness));
}
return color;
}else return Color::black();
}

渲染一下

[cpp]view plaincopy

void renderRecursive()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); // Reset The View
glTranslatef(-0.5f,-0.5f,-1.0f);
glPointSize(2.0);
PerspectiveCamera camera( GVector3(0, 10, 10),GVector3(0, -0.5, -1),GVector3(0, 1, 0), 90);
Plane* plane1=new Plane(GVector3(0, 1, 0),1.0);
CSphere* sphere1=new CSphere(GVector3(-2, 5, -2), 4.0);
CSphere* sphere2=new CSphere(GVector3(5, 5, -7), 3.0);
plane1->material=new CheckerMaterial(0.1f,0.5f);
sphere1->material=new PhongMaterial(Color::red(), Color::white(), 16,0.25);
sphere2->material=new PhongMaterial(Color::green(), Color::white(), 16,0.25);
Union scene;
scene.push(plane1);
scene.push(sphere1);
scene.push(sphere2);
long maxDepth=20;
long maxReflect=5;
float dx=1.0f/WINDOW_WIDTH;
float dy=1.0f/WINDOW_HEIGHT;
float dD=255.0f/maxDepth;
glBegin(GL_POINTS);
for (long y = 0; y < WINDOW_HEIGHT; ++y)
{
float sy = 1 - dy*y;
for (long x = 0; x < WINDOW_WIDTH; ++x)
{
float sx =dx*x;
CRay ray(camera.generateRay(sx, sy));
IntersectResult result = scene.isIntersected(ray);
//IntersectResult result = plane1.isIntersected(ray);
if (result.isHit)
{
Color color = rayTraceRecursive(&scene, ray, maxReflect);
//Color color = result.object->material->sample(ray, result.position, result.normal);
//Color color =plane1.material->sample(ray, result.position, result.normal);
color.saturate();
//color.show();
glColor3ub(color.r*255,color.g*255,color.b*255);
glVertex2f(sx,sy);
}
}
}
glEnd();
// 交换缓冲区
glfwSwapBuffers();
}

结果就是最上面的那幅图了。

结语

以前自己只玩过一些opengl的东西，不过那些都有现成的接口让你掉，原理上也不用理解得很深，往往一两句语句就可以实现一个简单的效果。

而现在，从原理到实现，每一句代码都需要先在真实世界中想清楚，然后抽象成代码，不管对编程技巧还是数学功底都会有很高的要求，所以在编写这些代码的时候我又回头去看C++ primer，学线性代数。。当然收获也很大。

源码可以点这里下载。

参考

用JavaScript玩转计算机图形学(一)光线追踪入门-http://www.cnblogs.com/miloyip/archive/2010/03/29/1698953.html
光线追踪技术的理论和实践(面向对象)-http://blog.csdn.net/zhangci226/article/details/5664313

Wikipedia, Ray Tracing
计算机图形学（第三版）（美）赫恩著，（美）巴克著。

Ray Object Intersections - http://siggraph.org/education/materials/HyperGraph/raytrace/rtinter0.htm