我们来整理一下项目的代码
目录
----include
--hit
--texture
--material
----RTdef.hpp
----ray.hpp
----camera.hpp
----main.cpp
3D泛型数学库中的randomfunc.hpp增加了新内容
#pragma once
#include <lvgm\type_vec\type_vec.h>
#include <random>
namespace lvgm
{
//@brief: create a random number that from 0 to 1 completely
template<typename T = lvgm::precision>
const T rand01()
{
if (typeid(T) == typeid(int))
{
std::cerr << "integer doesn't have a random number from 0 to 1\n";
throw "integer doesn't have a random number from 0 to 1\n";
}
static std::mt19937 mt;
static std::uniform_real_distribution<T> r;
return r(mt);
}
//@brief: find a random point in unit_sphere
template<typename T = lvgm::precision>
const lvgm::vec3<T> random_unit_sphere()
{
if (typeid(T) == typeid(int))
{
std::cerr << "integer doesn't have a random number from 0 to 1\n";
throw "integer doesn't have a random number from 0 to 1\n";
}
lvgm::vec3<T> p;
do
{
p = 2.0*lvgm::vec3<T>(rand01(), rand01(), rand01()) - lvgm::vec3<T>(1, 1, 1);
} while (dot(p, p) >= 1.0);
return p;
}
//@brief: find a random point in unit_plane
template<typename T = lvgm::precision>
const lvgm::vec2<T> random_unit_plane()
{
if (typeid(T) == typeid(int))
{
std::cerr << "integer doesn't have a random number from 0 to 1\n";
throw "integer doesn't have a random number from 0 to 1\n";
}
lvgm::vec2<T> p;
do
{
p = 2.0*lvgm::vec2<T>(rand01(), rand01()) - lvgm::vec2<T>(1, 1);
} while (dot(p, p) >= 1.0);
return p;
}
//@brief: generate a list of normalized vector(-1~1)
template<typename T = precision>
vec2<T> * random_normalized2D(const size_t size)
{
vec2<T> * p = new vec2<T>[size];
for (int i = 0; i < size; ++i)
p[i] = vec2<T>( -1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01()).ret_unitization();
return p;
}
//@brief: generate a list of normalized vector(-1~1)
template<typename T = precision>
vec3<T> * random_normalized3D(const size_t size)
{
vec3<T> * p = new vec3<T>[size];
for (int i = 0; i < size; ++i)
p[i] = vec3<T>(-1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01()).ret_unitization();
return p;
}
//@brief: generate a list of normalized vector(-1~1)
template<typename T = precision>
T * random_normalized1D(const size_t size)
{
T * p = new T[size];
for (int i = 0; i < size; ++i)
p[i] = -1 + 2 * lvgm::rand01();
return p;
}
//@brief: make list permute randomly
template<typename T>
void permute_method(T * p, size_t n)
{
for (int i = n - 1; i; i--)
{
size_t tar = int(lvgm::rand01() * (i + 1));
T t = p[i];
p[i] = p[tar];
p[tar] = t;
}
}
//@brief: generate a list of random value(0~n)
template<typename T = int>
T * generate_random0n(size_t size)
{
int * p = new int[size];
for (int i = 0; i < 256; ++i) p[i] = i;
permute_method(p, 256);
return p;
}
}
先说最外面的
基本和上次的没什么区别https://www.cnblogs.com/lv-anchoret/p/10243553.html
/// RTdef.hpp
// https://www.cnblogs.com/lv-anchoret/p/10243553.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1.1
// [brief ] the basic concept of rt
// -----------------------------------------------------
#pragma once
#include <lvgm\type_vec\type_vec.h> //https://www.cnblogs.com/lv-anchoret/p/10163085.html
#include <lvgm\opticsfunc.hpp> //https://www.cnblogs.com/lv-anchoret/p/10241904.html
#include <lvgm\randfunc.hpp> //https://www.cnblogs.com/lv-anchoret/p/10241904.html
#include <algorithm>
#define stds std::
namespace rt
{
using rtvar = lvgm::precision;
using rtvec = lvgm::vec3<rtvar>;
constexpr static rtvar rtInf() { return static_cast<rtvar>(0x3f3f3f3f); } //最大值
constexpr rtvar π = 3.1415926;
template<typename T>
const T& rtmin(const T& a, const T& b)
{
return a < b ? a : b;
}
template<typename T>
const T& rtmax(const T& a, const T& b)
{
return a > b ? a : b;
}
}
/// ray.hpp
// https://www.cnblogs.com/lv-anchoret/p/10182002.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] the ray-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
#include "RTdef.hpp"
namespace rt
{
class ray
{
public:
ray()
:_a{ rtvec() }
, _b{ rtvec() }
{ }
ray(const rtvec& a, const rtvec& b, const rtvar time = 0.)
:_a(a)
, _b(b)
,_time(time)
{ }
ray(const ray& r)
:_a(r._a)
,_b(r._b)
,_time(r._time)
{ }
inline rtvec origin()const { return _a; }
inline rtvec direction()const { return _b; }
inline rtvar time()const { return _time; }
inline rtvec go(const rtvar t)const { return _a + t * _b; }
private:
rtvec _a;
rtvec _b;
rtvar _time;
};
} // rt namespace
/// camera.hpp
// https://www.cnblogs.com/lv-anchoret/p/10221058.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] the camera-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of camera class
class camera
{
public:
/*
@brief: the camera constructor
@param: lookfrom -> the position of eye
lookat -> the vector of sight's direction
vup -> the vertical up direction
vfov -> 相机在垂直方向上关于屏幕岔开的角度
aspect -> Screen aspect ratio
focus -> the focal length
t1 -> Shutter start time
t2 -> Shutter end time
*/
camera(rtvec lookfrom, rtvec lookat, rtvec vup, rtvar vfov, rtvar aspect, rtvar aperture, rtvar focus, rtvar t1, rtvar t2);
inline const ray get_ray(const rtvar u, const rtvar v)const;
inline const ray get_ray(const lvgm::vec2<rtvar>& para)const;
public:
inline const rtvec& eye()const { return _eye; }
inline const rtvec& start()const { return _start; }
inline const rtvec& horizontal()const { return _horizontal; }
inline const rtvec& vertical()const { return _vertical; }
inline const rtvec& u()const { return _u; }
inline const rtvec& v()const { return _v; }
inline const rtvec& w()const { return _w; }
inline const rtvar lens_r()const { return _lens_radius; }
private:
rtvec _u;
rtvec _v;
rtvec _w;
rtvec _eye;
rtvec _start; //left-bottom
rtvec _horizontal;
rtvec _vertical;
rtvar _lens_radius; //the radius of lens
rtvar _time1;
rtvar _time2;
};
//the implementation of camera class
inline camera::camera(rtvec lookfrom, rtvec lookat, rtvec vup, rtvar vfov, rtvar aspect, rtvar aperture, rtvar focus, rtvar t1, rtvar t2)
:_eye(lookfrom)
, _lens_radius(aperture / 2)
, _time1(t1)
, _time2(t2)
{
rtvar theta = vfov * π / 180;
rtvar half_height = tan(theta / 2) * focus;
rtvar half_width = aspect * half_height;
_w = (lookfrom - lookat).ret_unitization();
_u = cross(vup, _w).ret_unitization();
_v = cross(_w, _u);
_start = _eye - half_width * _u - half_height * _v - focus * _w;//高和宽都乘了焦距，w也要乘，不然公式是错的
_horizontal = 2 * half_width * _u;
_vertical = 2 * half_height * _v;
}
inline const ray camera::get_ray(const rtvar u, const rtvar v)const
{
rtvec rd = rtvec(_lens_radius * lvgm::random_unit_plane());
rtvec offset = _u * rd.x() + _v * rd.y();
rtvar time = _time1 + lvgm::rand01() * (_time2 - _time1);
return ray{ _eye + offset, _start + u*_horizontal + v*_vertical - (_eye + offset), time };
}
inline const ray camera::get_ray(const lvgm::vec2<rtvar>& para)const
{
return get_ray(para.u(), para.v());
}
} // rt namespace
hit
里面包含的很多物体以及一些变换
/// RThit.hpp
// https://www.cnblogs.com/lv-anchoret/p/10190092.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] some intersects
// intersections
// aabb
// bvh
// sphere
// moving_sphere
// rectangle
// rectangles
// box
// translate
// rotate
// -----------------------------------------------------
#pragma once
#include "ray.hpp"
#include "aabb_box.hpp"
#include "intersect.hpp"
#include "bvh.hpp"
#include "intersections.hpp"
#include "sphere.hpp"
#include "moving_sphere.hpp"
#include "rectangleBasic.hpp"
#include "rectangles.hpp"
#include "rectangle.hpp"
#include "flip_normal.hpp"
#include "box.hpp"
#include "constant_medium.hpp"
#include "translate.hpp"
#include "rotate.hpp"
/// intersect.hpp
//https://www.cnblogs.com/lv-anchoret/p/10190092.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] the intersect-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class material;
class aabb;
// the infomation of intersection point
struct hitInfo
{
lvgm::precision _t; //ray 中的系数t
rtvec _p; //相交点、撞击点
rtvec _n; //_p点的表面法线
material* _materialp; //材质
rtvar _u; //texture-u
rtvar _v; //texture-v
};
// the statement of intersect class
class intersect
{
public:
intersect() { }
/*
@brief: 撞击函数，求取撞击点相关记录信息
@param: sight->视线
系数t的上下界->筛选撞击点
info->返回撞击点信息
@retur: 是否存在合法撞击点
*/
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const = 0;
/*
@brief: get the box of Geometry
*/
virtual aabb getbox()const = 0;
};
}
/// aabb.hpp
// https://www.cnblogs.com/lv-anchoret/p/10284085.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the aabb-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
//the statement of aabb class
class aabb
{
public:
aabb() { }
/*
@brief: the box of Geometry
@param: min -> 盒子坐标最小端
max -> 盒子坐标最大端
*/
aabb(const rtvec& min, const rtvec& max);
/*
@brief: 相交碰撞检测
@param: sight -> 视线
解的上下界
@retur: 是否碰撞相交
*/
inline bool hit(const ray& sight, rtvar tmin, rtvar tmax)const;
/*
@brief: 两个包围盒的包围盒
*/
static aabb _surrounding_box(aabb box1, aabb box2);
public:
inline const rtvec& min()const { return _min; }
inline const rtvec& max()const { return _max; }
private:
rtvec _min;
rtvec _max;
};
//the implementation of aabb class
inline aabb::aabb(const rtvec& min, const rtvec& max)
:_min(min)
,_max(max)
{
}
inline bool aabb::hit(const ray& sight, rtvar tmin, rtvar tmax)const
{
for (int i = 0; i < 3; ++i)
{
rtvar div = 1.0 / sight.direction()[i];
rtvar t1 = (_min[i] - sight.origin()[i]) / sight.direction()[i];
rtvar t2 = (_max[i] - sight.origin()[i]) / sight.direction()[i];
if (div < 0.)stds swap(t1, t2);
if (stds min(t2, tmax) <= stds max(t1, tmin))
return false;
}
return true;
}
aabb aabb::_surrounding_box(aabb box1, aabb box2)
{
auto fmin = [](const rtvar a, const rtvar b) {return a < b ? a : b; };
auto fmax = [](const rtvar a, const rtvar b) {return a > b ? a : b; };
rtvec min{ fmin(box1.min().x(),box2.min().x()),
fmin(box1.min().y(),box2.min().y()),
fmin(box1.min().z(),box2.min().z()) };
rtvec max{ fmax(box1.max().x(),box2.max().x()),
fmax(box1.max().y(),box2.max().y()),
fmax(box1.max().z(),box2.max().z()) };
return aabb(min, max);
}
} //rt namespace
/// bvh.hpp
// https://www.cnblogs.com/lv-anchoret/p/10284085.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the bvh-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of bvh_node class
class bvh_node :public intersect
{
public:
bvh_node() { }
/*
@brief: bvh树
@param: world -> all Geometry of the scene
n -> the number of the Geometry
time1 -> start time
time2 -> end time
*/
bvh_node(intersect** world, const int n, const rtvar time1, const rtvar time2);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
private:
intersect* _left;
intersect* _right;
aabb _box;
};
// the implementation of bvh_node class
inline int _x_cmp(const void * lhs, const void * rhs)
{
intersect * lc = *(intersect**)lhs;
intersect * rc = *(intersect**)rhs;
aabb lbox = lc->getbox();
aabb rbox = rc->getbox();
if (lbox.min().x() - rbox.min().x() < 0.)
return -1;
else
return 1;
}
inline int _y_cmp(const void * lhs, const void * rhs)
{
intersect * lc = *(intersect**)lhs;
intersect * rc = *(intersect**)rhs;
aabb lbox = lc->getbox();
aabb rbox = rc->getbox();
if (lbox.min().y() - rbox.min().y() < 0.)
return -1;
else
return 1;
}
inline int _z_cmp(const void * lhs, const void * rhs)
{
intersect * lc = *(intersect**)lhs;
intersect * rc = *(intersect**)rhs;
aabb lbox = lc->getbox();
aabb rbox = rc->getbox();
if (lbox.min().z() - rbox.min().z() < 0.)
return -1;
else
return 1;
}
inline bvh_node::bvh_node(intersect** world, const int n, const rtvar time1, const rtvar time2)
{
int axis = static_cast<int>(3 * lvgm::rand01());
if (axis == 0)
qsort(world, n, sizeof(intersect*), _x_cmp);
else if (axis == 1)
qsort(world, n, sizeof(intersect*), _y_cmp);
else
qsort(world, n, sizeof(intersect*), _z_cmp);
if (n == 1)
_left = _right = world[0];
else if (n == 2)
_left = world[0],
_right = world[1];
else
_left = new bvh_node(world, n / 2, time1, time2),
_right = new bvh_node(world + n / 2, n - n / 2, time1, time2);
aabb lbox = _left->getbox();
aabb rbox = _right->getbox();
_box = aabb::_surrounding_box(lbox, rbox);
}
aabb bvh_node::getbox()const
{
return _box;
}
bool bvh_node::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
if (_box.hit(sight, t_min, t_max))
{
hitInfo linfo, rinfo;
bool lhit = _left->hit(sight, t_min, t_max, linfo);
bool rhit = _right->hit(sight, t_min, t_max, rinfo);
if (lhit && rhit)
{
if (linfo._t < rinfo._t)
info = linfo;
else
info = rinfo;
return true;
}
else if (lhit)
{
info = linfo;
return true;
}
else if (rhit)
{
info = rinfo;
return true;
}
else
return false;
}
else
return false;
}
} //rt namespace
/// intersections.hpp
// https://www.cnblogs.com/lv-anchoret/p/10190092.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] the intersections-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of intersections class
class intersections :public intersect
{
public:
intersections() { }
/*
@brief: the list of scene's Geometry
@param: list -> all Geometry of the scene
n -> the number of the scene's Geometry
*/
intersections(intersect** list, size_t n) :_list(list), _size(n) { }
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override { return aabb(); }
public:
const size_t get_size()const { return _size; }
private:
intersect** _list;
size_t _size;
};
// the implementation of intersections class
bool intersections::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
hitInfo t_rec;
bool hitSomething = false;
rtvar far = t_max; //刚开始可以看到无限远
for (int i = 0; i < _size; ++i)
{
if (_list[i]->hit(sight, t_min, far, t_rec))
{
hitSomething = true;
far = t_rec._t; //将上一次的最近撞击点作为视线可达最远处
info = t_rec;
}
}
return hitSomething;
}
} // rt namespace
/// sphere.hpp
// https://www.cnblogs.com/lv-anchoret/p/10190092.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the sphere-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class sphere :public intersect
{
public:
sphere() { }
/*
@para1: 球心坐标
@para2: 球半径
@para3: 材质
*/
sphere(const rtvec& h, rtvar r, material* ma);
~sphere();
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
/*
获取几何球体中p点对应的2D纹理坐标（u,v)
*/
static void get_sphere_uv(const rtvec& p, rtvar& u, rtvar& v);
public:
inline const rtvar r()const { return _radius; }
inline const rtvec& heart()const { return _heart; }
inline const material* get_material()const { return _materialp; }
inline rtvar& r() { return _radius; }
inline rtvec& heart() { return _heart; }
inline void set_material(material* m) { _materialp = m; }
private:
rtvec _heart;
rtvar _radius;
material* _materialp;
};
inline sphere::sphere(const rtvec& h, rtvar r, material* ma)
:_heart(h)
, _radius(r)
, _materialp(ma)
{
}
inline sphere::~sphere()
{
if (_materialp)
delete _materialp;
}
bool sphere::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvec trace = sight.origin() - _heart;
rtvar a = dot(sight.direction(), sight.direction());
rtvar b = 2.0 * dot(trace, sight.direction());
rtvar c = dot(trace, trace) - _radius * _radius;
rtvar delt = b*b - 4.0*a*c;
if (delt > 0)
{
info._materialp = _materialp;
rtvar x = (-b - sqrt(delt)) / (2.0*a);
if (x < t_max && x > t_min)
{
info._t = x;
info._p = sight.go(x);
info._n = (info._p - _heart) / _radius;
get_sphere_uv((info._p - _heart) / _radius, info._u, info._v); //将撞击点向量规格化
return true;
}
x = (-b + sqrt(delt)) / (2.0*a);
if (x < t_max && x > t_min)
{
info._t = x;
info._p = sight.go(x);
info._n = (info._p - _heart) / _radius;
get_sphere_uv((info._p - _heart) / _radius, info._u, info._v); //!!!
return true;
}
}
return false;
}
aabb sphere::getbox()const
{
return aabb(_heart - rtvec(_radius, _radius, _radius), _heart + rtvec(_radius, _radius, _radius));
}
void sphere::get_sphere_uv(const rtvec& p, rtvar& u, rtvar& v)
{
rtvar φ = atan2(p.z(), p.x());
rtvar θ = asin(p.y());
u = 1 - (φ + π) / (2 * π);
v = (θ + π / 2) / π;
}
} // rt namespace
/// moving_sphere.hpp
// https://www.cnblogs.com/lv-anchoret/p/10269488.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the moving_sphere-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
//the statement of moving_shpere class
class moving_sphere :public intersect
{
public:
moving_sphere() { }
/*
@brief: 模拟运动模糊的几何体
@param: 起始位置的球心
结束位置的球心
开始时间
结束时间
球体半径
纹理
*/
moving_sphere(rtvec heart1, rtvec heart2, rtvar t1, rtvar t2, rtvar r, material* mp);
virtual bool hit(const ray& r, rtvar tmin, rtvar tmax, hitInfo& info)const override;
virtual aabb getbox()const override;
inline rtvec heart(rtvar t)const;
private:
rtvec _heart1;
rtvec _heart2;
rtvar _time1;
rtvar _time2;
rtvar _radius;
material* _materialp;
};
//the implementation of moving_sphere class
inline moving_sphere::moving_sphere(rtvec heart1, rtvec heart2, rtvar t1, rtvar t2, rtvar r, material* mp)
:_heart1(heart1)
, _heart2(heart2)
, _time1(t1)
, _time2(t2)
, _radius(r)
, _materialp(mp)
{
}
inline rtvec moving_sphere::heart(rtvar t)const
{
return _heart1 + ((t - _time1) / (_time2 - _time1)) * (_heart2 - _heart1);
}
bool moving_sphere::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvec trace = sight.origin() - heart(sight.time());
rtvar a = dot(sight.direction(), sight.direction());
rtvar b = 2.0 * dot(trace, sight.direction());
rtvar c = dot(trace, trace) - _radius * _radius;
rtvar delt = b*b - 4.0*a*c;
if (delt > 0)
{
info._materialp = _materialp;
rtvar x = (-b - sqrt(delt)) / (2.0*a);
if (x < t_max && x > t_min)
{
info._t = x;
info._p = sight.go(x);
info._n = (info._p - heart(sight.time())) / _radius;
return true;
}
x = (-b + sqrt(delt)) / (2.0*a);
if (x < t_max && x > t_min)
{
info._t = x;
info._p = sight.go(x);
info._n = (info._p - heart(sight.time())) / _radius;
return true;
}
}
return false;
}
aabb moving_sphere::getbox()const
{
rtvec delt{ _radius, _radius, _radius };
return aabb::_surrounding_box(aabb(_heart1 - delt, _heart1 + delt), aabb(_heart2 - delt, _heart2 + delt));
}
} // rt namespace
/// constant_medium.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the constant_dedium-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class constant_medium :public intersect
{
public:
/*
形体
颗粒浓度
纹理
*/
constant_medium(intersect* p, rtvar d, texture* tex);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
public:
inline const rtvar get_density()const { return _density; }
inline const material* get_material()const { return _materialp; }
inline void set_density(const rtvar density) { _density = density; }
inline void set_material(material* m) { _materialp = m; }
private:
intersect* _item;
rtvar _density;
material* _materialp;
};
inline constant_medium::constant_medium(intersect* p, rtvar d, texture* tex)
:_item(p)
,_density(d)
,_materialp(new isotropic(tex))
{
}
aabb constant_medium::getbox()const
{
return _item->getbox();
}
bool constant_medium::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
hitInfo info1, info2;
if (_item->hit(sight, -rtInf(), rtInf(), info1)) {
if (_item->hit(sight, info1._t + 0.0001, rtInf(), info2)) {
if (info1._t < t_min)
info1._t = t_min;
if (info2._t > t_max)
info2._t = t_max;
if (info1._t >= info2._t)
return false;
if (info1._t < 0)
info1._t = 0;
float distance_inside_boundary = (info2._t - info1._t)*sight.direction().normal();
float hit_distance = -(1 / _density)*log(lvgm::rand01());
if (hit_distance < distance_inside_boundary) {
info._t = info1._t + hit_distance / sight.direction().normal();
info._p = sight.go(info._t);
info._n = rtvec(lvgm::rand01(), lvgm::rand01(), lvgm::rand01()); // arbitrary
info._materialp = _materialp;
return true;
}
}
}
return false;
}
} // rt namespace
/// flip_normal.hpp
// https://www.cnblogs.com/lv-anchoret/p/10307569.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the flip_normal-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class flip_normal: public intersect
{
public:
flip_normal(intersect * p) :_p(p) { }
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override
{
if (_p->hit(sight, t_min, t_max, info))
{
info._n = -info._n;
return true;
}
return false;
}
virtual aabb getbox()const override
{
return _p->getbox();
}
private:
intersect* _p;
};
} // rt namespace
/// translate.hpp
// https://www.cnblogs.com/lv-anchoret/p/10307569.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the translate-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class translate :public intersect
{
public:
translate(intersect* p, const rtvec& offset);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
inline const rtvec get_offset()const { return _offset; }
inline void set_offset(const rtvec& f) { _offset = f; }
private:
intersect* _item;
rtvec _offset;
};
translate::translate(intersect* p, const rtvec& offset)
:_item(p)
, _offset(offset)
{
}
bool translate::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
ray movedRay(sight.origin() - _offset, sight.direction(), sight.time());
if (_item->hit(movedRay, t_min, t_max, info))
{
info._p += _offset;
return true;
}
return false;
}
aabb translate::getbox()const
{
aabb box = _item->getbox();
return aabb(box.min() + _offset, box.max() + _offset);
}
}// rt namespace
/// rotate.hpp
// https://www.cnblogs.com/lv-anchoret/p/10307569.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the translate-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of rotate_y class
class rotate_y :public intersect
{
public:
rotate_y(intersect* p, rtvar angle);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
private:
intersect* _item;
rtvar _sinθ;
rtvar _cosθ;
aabb _box;
};
// the statement of rotate_x class
class rotate_x :public intersect
{
public:
rotate_x(intersect* p, rtvar angle);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
private:
intersect* _item;
rtvar _sinθ;
rtvar _cosθ;
aabb _box;
};
// the statement of rotate_z class
class rotate_z :public intersect
{
public:
rotate_z(intersect* p, rtvar angle);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
private:
intersect* _item;
rtvar _sinθ;
rtvar _cosθ;
aabb _box;
};
// the implementation of rotate_y class
rotate_y::rotate_y(intersect* p, rtvar angle)
:_item(p)
{
rtvar radians = (π / 180.) * angle;
_sinθ = sin(radians);
_cosθ = cos(radians);
rtvec min(rtInf(), rtInf(), rtInf());
rtvec max = -min;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
{
rtvar x = i * _box.max().x() + (1 - i)*_box.min().x();
rtvar y = j * _box.max().y() + (1 - j)*_box.min().y();
rtvar z = k * _box.max().z() + (1 - k)*_box.min().z();
rtvar newx = _cosθ * x + _sinθ * z;
rtvar newz = -_sinθ * x + _cosθ * z;
rtvec tester(newx, y, newz);
for (int c = 0; c < 3; ++c)
{
if (tester[c] > max[c])
max[c] = tester[c];
if (tester[c] < min[c])
min[c] = tester[c];
}
}
_box = aabb(min, max);
}
bool rotate_y::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvec eye = sight.origin();
rtvec direction = sight.direction();
eye[0] = _cosθ * sight.origin()[0] - _sinθ * sight.origin()[2];
eye[2] = _sinθ * sight.origin()[0] + _cosθ * sight.origin()[2];
direction[0] = _cosθ * sight.direction()[0] - _sinθ * sight.direction()[2];
direction[2] = _sinθ * sight.direction()[0] + _cosθ * sight.direction()[2];
ray rotatedRay(eye, direction, sight.time());
if (_item->hit(rotatedRay, t_min, t_max, info))
{
rtvec p = info._p;
rtvec n = info._n;
p[0] = _cosθ * info._p[0] + _sinθ * info._p[2];
p[2] = -_sinθ * info._p[0] + _cosθ * info._p[2];
n[0] = _cosθ * info._n[0] + _sinθ * info._n[2];
n[2] = -_sinθ * info._n[0] + _cosθ * info._n[2];
info._p = p;
info._n = n;
return true;
}
return false;
}
aabb rotate_y::getbox()const
{
return _box;
}
// the implementation of rotate_x class
rotate_x::rotate_x(intersect* p, rtvar angle)
:_item(p)
{
rtvar radians = (π / 180.) * angle;
_sinθ = sin(radians);
_cosθ = cos(radians);
rtvec min(rtInf(), rtInf(), rtInf());
rtvec max = -min;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
{
rtvar x = i * _box.max().x() + (1 - i)*_box.min().x();
rtvar y = j * _box.max().y() + (1 - j)*_box.min().y();
rtvar z = k * _box.max().z() + (1 - k)*_box.min().z();
rtvar newy = _cosθ * x - _sinθ * z;
rtvar newz = _sinθ * x + _cosθ * z;
rtvec tester(x, newy, newz);
for (int c = 0; c < 3; ++c)
{
if (tester[c] > max[c])
max[c] = tester[c];
if (tester[c] < min[c])
min[c] = tester[c];
}
}
_box = aabb(min, max);
}
bool rotate_x::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvec eye = sight.origin();
rtvec direction = sight.direction();
eye[1] = _cosθ * sight.origin()[1] + _sinθ * sight.origin()[2];
eye[2] = -_sinθ * sight.origin()[1] + _cosθ * sight.origin()[2];
direction[1] = _cosθ * sight.direction()[1] + _sinθ * sight.direction()[2];
direction[2] = -_sinθ * sight.direction()[1] + _cosθ * sight.direction()[2];
ray rotatedRay(eye, direction, sight.time());
if (_item->hit(rotatedRay, t_min, t_max, info))
{
rtvec p = info._p;
rtvec n = info._n;
p[1] = _cosθ * info._p[1] - _sinθ * info._p[2];
p[2] = _sinθ * info._p[1] + _cosθ * info._p[2];
n[1] = _cosθ * info._n[1] - _sinθ * info._n[2];
n[2] = _sinθ * info._n[1] + _cosθ * info._n[2];
info._p = p;
info._n = n;
return true;
}
return false;
}
aabb rotate_x::getbox()const
{
return _box;
}
// the implementation of rotate_z class
rotate_z::rotate_z(intersect* p, rtvar angle)
:_item(p)
{
rtvar radians = (π / 180.) * angle;
_sinθ = sin(radians);
_cosθ = cos(radians);
rtvec min(rtInf(), rtInf(), rtInf());
rtvec max = -min;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
{
rtvar x = i * _box.max().x() + (1 - i)*_box.min().x();
rtvar y = j * _box.max().y() + (1 - j)*_box.min().y();
rtvar z = k * _box.max().z() + (1 - k)*_box.min().z();
rtvar newx = _cosθ * x - _sinθ * y;
rtvar newy = _sinθ * x + _cosθ * y;
rtvec tester(newx, newy, z);
for (int c = 0; c < 3; ++c)
{
if (tester[c] > max[c])
max[c] = tester[c];
if (tester[c] < min[c])
min[c] = tester[c];
}
}
_box = aabb(min, max);
}
bool rotate_z::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvec eye = sight.origin();
rtvec direction = sight.direction();
eye[0] = _cosθ * sight.origin()[0] + _sinθ * sight.origin()[1];
eye[1] = -_sinθ * sight.origin()[0] + _cosθ * sight.origin()[1];
direction[0] = _cosθ * sight.direction()[0] + _sinθ * sight.direction()[1];
direction[1] = -_sinθ * sight.direction()[0] + _cosθ * sight.direction()[1];
ray rotatedRay(eye, direction, sight.time());
if (_item->hit(rotatedRay, t_min, t_max, info))
{
rtvec p = info._p;
rtvec n = info._n;
p[0] = _cosθ * info._p[0] - _sinθ * info._p[1];
p[1] = _sinθ * info._p[0] + _cosθ * info._p[1];
n[0] = _cosθ * info._n[0] - _sinθ * info._n[1];
n[1] = _sinθ * info._n[0] + _cosθ * info._n[1];
info._p = p;
info._n = n;
return true;
}
return false;
}
aabb rotate_z::getbox()const
{
return _box;
}
} // rt namespace
鉴于这个系统的变换均针对运算期的每个点做变换，具体的几何体不变，所以，造成一个问题就是不方便获取变换后的法线等信息，也不利于重置纹理材质等，就长方体而言，比如我想改变某个面的纹理或者材质，就很困难，所以新加了很多接口，但是，这些接口都是统一的，所以又重新整了一个基类，提高代码重用性和可维护性
但我只改了反转向量，没有对旋转做适应的变动
/// rectangleBasic.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the rectangle-class for the ray-tracing project
// -----------------------------------------------------
#pragma once
namespace rt
{
class rectangle :public intersect
{
public:
rectangle() { }
rectangle(rtvar u1, rtvar u2, rtvar v1, rtvar v2, rtvar other, material* mat, rtvec nor)
:_u1(u1)
, _u2(u2)
, _v1(v1)
, _v2(v2)
, _materialp(mat)
, _normal(nor)
{
}
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override = 0;
virtual aabb getbox()const = 0;
public:
inline const rtvec Getnormal()const { return _normal; }
inline const lvgm::vec2<lvgm::precision> Urange()const { return lvgm::vec2<lvgm::precision>(rtmin(_u1, _u2), rtmax(_u1, _u2)); }
inline const lvgm::vec2<lvgm::precision> Vrange()const { return lvgm::vec2<lvgm::precision>(rtmin(_v1, _v2), rtmax(_v1, _v2)); }
inline const material* Getmaterial()const { return _materialp; }
inline void flipNormal() { _normal = -_normal; }
inline void setmaterial(material* m) { _materialp = m; }
inline void setnormal(const rtvec& n) { _normal = n; }
protected:
material* _materialp;
rtvar _u1, _u2;
rtvar _v1, _v2;
rtvar _other;
rtvec _normal;
};
} // rt namespace
/// rectangles.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the rectangles-class for the ray-tracing project
// -----------------------------------------------------
#pragma once
namespace rt
{
class rectangles:public rectangle
{
public:
rectangles(rectangle** list, size_t n) :_list(list), _size(n) { }
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override { return aabb(); }
private:
rectangle** _list;
size_t _size;
};
// the implementation of intersections class
bool rectangles::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
hitInfo t_rec;
bool hitSomething = false;
rtvar far = t_max; //刚开始可以看到无限远
for (int i = 0; i < _size; ++i)
{
if (_list[i]->hit(sight, t_min, far, t_rec))
{
hitSomething = true;
far = t_rec._t; //将上一次的最近撞击点作为视线可达最远处
info = t_rec;
}
}
return hitSomething;
}
}
/// rectangle.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the rect-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
//the statement of xy_rect class
class xy_rect : public rectangle
{
public:
xy_rect() { }
/*
@brief: the rectangle in the x-y plane
@param: the boundary of x axis
the boundary of y axis
the value of z axis
the material of rectangle
flip normal or not
*/
xy_rect(rtvar x1, rtvar x2, rtvar y1, rtvar y2, rtvar z0, material* mat, bool _flipNormal = false);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
};
//the statement of xz_rect class
class xz_rect : public rectangle
{
public:
xz_rect() { }
/*
@brief: the rectangle in the x-z plane
@param: the boundary of x axis
the boundary of z axis
the value of y axis
the material of rectangle
*/
xz_rect(rtvar x1, rtvar x2, rtvar z1, rtvar z2, rtvar y0, material* mat, bool _flipNormal = false);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
};
//the statement of yz_rect class
class yz_rect : public rectangle
{
public:
yz_rect() { }
/*
@brief: the rectangle in the y-z plane
@param: the boundary of y axis
the boundary of z axis
the value of x axis
the material of rectangle
*/
yz_rect(rtvar y1, rtvar y2, rtvar z1, rtvar z2, rtvar x0, material* mat, bool _flipNormal = false);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
};
// the implementation of xy_rect class
inline xy_rect::xy_rect(rtvar x1, rtvar x2, rtvar y1, rtvar y2, rtvar z0, material* mat, bool _flipNormal)
: rectangle(x1, x2, y1, y2, z0, mat, rtvec(0., 0., 1.))
{
if (_flipNormal)flipNormal();
}
bool xy_rect::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvar t = (_other - sight.origin().z()) / sight.direction().z();
if (t < t_min || t > t_max)return false;
rtvar x = sight.origin().x() + t*sight.direction().x();
rtvar y = sight.origin().y() + t*sight.direction().y();
if (x < _u1 || x > _u2 || y < _v1 || y > _v2)
return false;
info._u = (x - _u1) / (_u2 - _u1);
info._v = (y - _v1) / (_v2 - _v1);
info._t = t;
info._materialp = _materialp;
info._p = sight.go(t);
info._n = rtvec(0, 0, 1);
return true;
}
aabb xy_rect::getbox()const
{
return aabb(rtvec(_u1, _v1, _other - 0.0001), rtvec(_u2, _v2, _other + 0.0001));
}
// the implementation of xz_rect class
inline xz_rect::xz_rect(rtvar x1, rtvar x2, rtvar z1, rtvar z2, rtvar y0, material* mat, bool _flipNormal)
: rectangle(x1, x2, z1, z2, y0, mat, rtvec(0., 1., 0.))
{
if (_flipNormal)flipNormal();
}
bool xz_rect::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvar t = (_other - sight.origin().y()) / sight.direction().y();
if (t < t_min || t > t_max)return false;
rtvar x = sight.origin().x() + t*sight.direction().x();
rtvar z = sight.origin().z() + t*sight.direction().z();
if (x < _u1 || x > _u2 || z < _v1 || z > _v2)
return false;
info._u = (x - _u1) / (_u2 - _u1);
info._v = (z - _v1) / (_v2 - _v1);
info._t = t;
info._materialp = _materialp;
info._p = sight.go(t);
info._n = rtvec(0, 1, 0);
return true;
}
aabb xz_rect::getbox()const
{
return aabb(rtvec(_u1, _other - 0.0001, _v1), rtvec(_u2, _other + 0.0001, _v2));
}
// the implementation of yz_rect class
inline yz_rect::yz_rect(rtvar y1, rtvar y2, rtvar z1, rtvar z2, rtvar x0, material* mat, bool _flipNormal)
: rectangle(y1, y2, z1, z2, x0, mat, rtvec(1., 0., 0.))
{
if (_flipNormal)flipNormal();
}
bool yz_rect::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
rtvar t = (_other - sight.origin().x()) / sight.direction().x();
if (t < t_min || t > t_max)return false;
rtvar y = sight.origin().y() + t*sight.direction().y();
rtvar z = sight.origin().z() + t*sight.direction().z();
if (y < _u1 || y > _u2 || z < _v1 || z > _v2)
return false;
info._u = (y - _u1) / (_u2 - _u1);
info._v = (z - _v1) / (_v2 - _v1);
info._t = t;
info._materialp = _materialp;
info._p = sight.go(t);
info._n = rtvec(1, 0, 0);
return true;
}
aabb yz_rect::getbox()const
{
return aabb(rtvec(_other - 0.0001, _u1, _v1), rtvec(_other + 0.0001, _u2, _v2));
}
}// rt namespace
/// box.hpp
// https://www.cnblogs.com/lv-anchoret/p/10307569.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the box-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of box class
class box: public intersect
{
public:
box() { }
box(const rtvec& pointmin, const rtvec& pointmax, material * mat);
virtual bool hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const override;
virtual aabb getbox()const override;
public:
// the normal of xy_rect, the normal's direction is +
inline const rtvec& xy_n() const { return _list[0].Getnormal(); }
// the normal of xy_rect, the normal's direction is -
inline const rtvec& xy_nflip() const { return _list[1].Getnormal(); }
inline const rtvec& xz_n() const { return _list[2].Getnormal(); }
inline const rtvec& xz_nflip() const { return _list[3].Getnormal(); }
inline const rtvec& yz_n() const { return _list[4].Getnormal(); }
inline const rtvec& yz_nflip() const { return _list[5].Getnormal(); }
inline void set_xy_material(material* m) { _list[0].setmaterial(m); }
inline void set_xy_flipmaterial(material* m) { _list[1].setmaterial(m); }
inline void set_xz_material(material* m) { _list[2].setmaterial(m); }
inline void set_xz_flipmaterial(material* m) { _list[3].setmaterial(m); }
inline void set_yz_material(material* m) { _list[4].setmaterial(m); }
inline void set_yz_flipmaterial(material* m) { _list[5].setmaterial(m); }
private:
rtvec _min;
rtvec _max;
rectangles* _list;
};
// the implementation of box class
inline box::box(const rtvec& pointmin, const rtvec& pointmax, material * mat)
:_min(pointmin)
,_max(pointmax)
{
rectangle ** list = new rectangle*[6];
list[0] = new xy_rect(_min.x(), _max.x(), _min.y(), _max.y(), _max.z(), mat);
list[1] = new xy_rect(_min.x(), _max.x(), _min.y(), _max.y(), _min.z(), mat, true);
list[2] = new xz_rect(_min.x(), _max.x(), _min.z(), _max.z(), _max.y(), mat);
list[3] = new xz_rect(_min.x(), _max.x(), _min.z(), _max.z(), _min.y(), mat, true);
list[4] = new yz_rect(_min.y(), _max.y(), _min.z(), _max.z(), _max.x(), mat);
list[5] = new yz_rect(_min.y(), _max.y(), _min.z(), _max.z(), _min.x(), mat, true);
_list = new rectangles(list, 6);
}
bool box::hit(const ray& sight, rtvar t_min, rtvar t_max, hitInfo& info)const
{
return _list->hit(sight, t_min, t_max, info);
}
aabb box::getbox()const
{
return aabb(_min, _max);
}
} // rt namespace
material
/// RTmaterial.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] some materials
// diffuse
// metal
// dielectric
// areaLight
// isotropic
// -----------------------------------------------------
#pragma once
#include "E:\OpenGL\光线追踪\code\ray tracing 1-2\ray tracing 1-2\ray.hpp"
#include "E:\OpenGL\光线追踪\code\ray tracing 1-2\ray tracing 1-2\include\hit\intersect.hpp"
#include "material.hpp"
#include "diffuse.hpp"
#include "metal.hpp"
#include "dielectric.hpp"
#include "light.hpp"
#include "isotropic.hpp"
/// material.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] the material-class for the ray-tracing project
// from the 《ray tracing in one week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of material class
class material
{
public:
/*
@brief: produce a scattered ray
@param: InRay -> Incident light
info -> the information of intersect-point(hit-point)
attenuation -> when scattered, how much the ray should be attenuated by tis reflectance R
scattered -> as we talk, it is a new sight; or
it is the scattered ray with the intersect-point
@retur: the function calculate a scattered ray or not
*/
virtual bool scatter(const ray& InRay, const hitInfo& info, rtvec& attenuation, ray& scattered)const = 0;
/*
@brief: 自发光
@param: 纹理所需信息
@retur: 纹理像素值
*/
virtual rtvec emitted(rtvar u, rtvar v, const rtvec& p)const { return rtvec(); }
};
}
/// diffuse.hpp
// https://www.cnblogs.com/lv-anchoret/p/10198423.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] one of the materials
// -----------------------------------------------------
#pragma once
namespace rt
{
class texture;
// the statement of lambertian class
class lambertian : public material
{
public:
lambertian(texture* _tex);
virtual bool scatter(const ray& rIn, const hitInfo& info, rtvec& attenuation, ray& scattered)const override;
public:
const texture* get_texture()const { return _albedo; }
void set_texture(texture* tex) { _albedo = tex; }
protected:
texture* _albedo;
};
// the implementation of lambertian class
inline lambertian::lambertian(texture* _tex)
:_albedo(_tex)
{
}
bool lambertian::scatter(const ray& rIn, const hitInfo& info, rtvec& attenuation, ray& scattered)const
{
rtvec target = info._p + info._n + lvgm::random_unit_sphere();
scattered = ray{ info._p, target - info._p };
attenuation = _albedo->value(info._u, info._v, info._p);
return true;
}
} // rt namespace
/// metal.hpp
// https://www.cnblogs.com/lv-anchoret/p/10206773.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2018.12
// [brief ] one of the materials
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of metal class
class metal :public material
{
public:
/*
@param: f -> Fuzzy index
*/
metal(texture* a, const rtvar f = 0.);
virtual bool scatter(const ray& rIn, const hitInfo& info, rtvec& attenuation, ray& scattered)const override;
public:
const texture* get_texture()const { return _albedo; }
const rtvar get_fuzz()const { return _fuzz; }
void set_texture(texture* tex) { _albedo = tex; }
void set_fuzz(const rtvar f) { _fuzz = f; }
protected:
texture* _albedo;
rtvar _fuzz;
};
inline metal::metal(texture* a, const rtvar f )
:_albedo(a)
{
if (f < 1 && f >= 0)_fuzz = f;
else _fuzz = 1;
}
bool metal::scatter(const ray& rIn, const hitInfo& info, rtvec& attenuation, ray& scattered)const
{
rtvec target = reflect(rIn.direction().ret_unitization(), info._n);
scattered = ray{ info._p, target + _fuzz * lvgm::random_unit_sphere() };
attenuation = _albedo->value(info._u, info._v, info._p);
return dot(scattered.direction(), info._n) != 0;
}
} // rt namespace
/// dielectric.hpp
// https://www.cnblogs.com/lv-anchoret/p/10217719.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] one of the materials
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of dielectric class
class dielectric :public material
{
public:
/*
@param: refractive indices
*/
dielectric(const rtvar RI) :_RI(RI) { }
virtual bool scatter(const ray& InRay, const hitInfo& info, rtvec& attenuation, ray& scattered)const override;
public:
const rtvar get_refIndex()const { return _RI; }
void set_refIndex(rtvar ri) { _RI = ri; }
protected:
rtvar _RI;
inline rtvar schlick(const rtvar cosine)const;
};
// the implementation of dielectric class
bool dielectric::scatter(const ray& InRay, const hitInfo& info, rtvec& attenuation, ray& scattered)const
{
rtvec outward_normal;
rtvec refracted;
rtvec reflected = reflect(InRay.direction(), info._n);
rtvar eta;
rtvar reflect_prob;
rtvar cos;
attenuation = rtvec(1., 1., 1.);
if (dot(InRay.direction(), info._n) > 0)
{
outward_normal = -info._n;
eta = _RI;
cos = _RI * dot(InRay.direction(), info._n) / InRay.direction().normal();
}
else
{
outward_normal = info._n;
eta = 1.0 / _RI;
cos = -dot(InRay.direction(), info._n) / InRay.direction().normal();
}
if (refract(InRay.direction(), outward_normal, eta, refracted))
reflect_prob = schlick(cos); //如果有折射，计算反射系数
else
reflect_prob = 1.0; //如果没有折射，那么为全反射
if (lvgm::rand01() < reflect_prob)
scattered = ray(info._p, reflected);
else
scattered = ray(info._p, refracted);
return true;
}
inline rtvar dielectric::schlick(const rtvar cosine)const
{
rtvar r0 = (1. - _RI) / (1. + _RI);
r0 *= r0;
return r0 + (1 - r0)*pow((1 - cosine), 5);
}
} // rt namespace
/// light.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the areaLight-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
//the statement of areaLight class
class areaLight :public material
{
public:
areaLight() { }
areaLight(texture* mat) :_emit(mat) { }
virtual bool scatter(const ray& InRay, const hitInfo& info, rtvec& attenuation, ray& scattered)const { return false; }
virtual rtvec emitted(rtvar u, rtvar v, const rtvec& p)const { return _emit->value(u, v, p); }
public:
const texture* get_texture()const { return _emit; }
void set_texture(texture* tex) { _emit = tex; }
private:
texture* _emit;
};
} // rt namespace
/// isotropic.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the isotropic-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class isotropic :public material
{
public:
isotropic(texture* tex) :_albedo(tex) { }
virtual bool scatter(const ray& InRay, const hitInfo& info, rtvec& attenuation, ray& scattered)const override
{
scattered = ray(info._p, lvgm::random_unit_sphere());
attenuation = _albedo->value(info._u, info._v, info._p);
return true;
}
public:
const texture* get_texture()const { return _albedo; }
void set_texture(texture* tex) { _albedo = tex; }
private:
texture * _albedo;
};
} // rt namespace
texture
/// RTtexture.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] some textures
// checker
// constant
// Perlin noise
// image
// -----------------------------------------------------
#pragma once
#include "RTdef.hpp"
#include "texture.hpp"
#include "checker_tex.hpp"
#include "constant_tex.hpp"
#include "Perlin.hpp"
#include "noise_tex.hpp"
#include "image_tex.hpp"
/// texture.hpp
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the texture-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
class texture
{
public:
virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const = 0;
};
} // rt namespace
/// constant_tex.hpp
// https://www.cnblogs.com/lv-anchoret/p/10285473.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the constant_texture-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of constant_texture class
class constant_texture :public texture
{
public:
constant_texture() { }
constant_texture(const rtvec& color);
virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
public:
inline const rtvec& color()const { return _color; }
inline void set_color(const rtvec& color) { _color = color; }
private:
rtvec _color;
};
// the implementation of constant_texture class
inline constant_texture::constant_texture(const rtvec& color)
:_color(color)
{
}
rtvec constant_texture::value(rtvar u, rtvar v, const rtvec& p)const
{
return _color;
}
} // rt namesapce
/// checker_tex.hpp
// https://www.cnblogs.com/lv-anchoret/p/10285473.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the checker_texture-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of checker_texture class
class checker_texture :public texture
{
public:
checker_texture() { }
/*
传入两个用于交错的纹理信息
*/
checker_texture(texture* t1, texture* t2);
virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
private:
texture* _even;
texture* _odd;
};
// the implementation of checker_texture class
inline checker_texture::checker_texture(texture * t1, texture * t2)
:_even(t1)
, _odd(t2)
{
}
rtvec checker_texture::value(rtvar u, rtvar v, const rtvec& p)const
{
rtvar sines = sin(10 * p.x() + 2) * sin(10 * p.y() + 2) * sin(10 * p.z() + 2);
if (sines < 0)
return _odd->value(u, v, p);
else
return _even->value(u, v, p);
}
} // rt namespace
/// image_tex.hpp
// https://www.cnblogs.com/lv-anchoret/p/10295137.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the image_texture-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of image_texture class
class image_texture: public texture
{
public:
image_texture() { }
/*
@param: image -> the rgb list of image texture
a b -> the size of image texture
*/
image_texture(unsigned char* image, size_t a, size_t b);
virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
public:
inline unsigned char* image()const { return _image; }
inline size_t sizeX()const { return _sizeX; }
inline size_t sizeY()const { return _sizeY; }
private:
unsigned char* _image;
size_t _sizeX;
size_t _sizeY;
};
//the implementation of image_texture class
image_texture::image_texture(unsigned char* image, size_t a, size_t b)
:_image(image)
,_sizeX(a)
,_sizeY(b)
{
}
rtvec image_texture::value(rtvar u, rtvar v, const rtvec& p)const
{
int i = u*_sizeX;
int j = (1 - v)*_sizeY - 0.001;
if (i < 0)i = 0;
if (j < 0)j = 0;
if (i > _sizeX - 1)i = _sizeX - 1;
if (j > _sizeY - 1)j = _sizeY - 1;
rtvar r = int(_image[3 * i + 3 * _sizeX*j]) / 255.0;
rtvar g = int(_image[3 * i + 3 * _sizeX*j + 1]) / 255.0;
rtvar b = int(_image[3 * i + 3 * _sizeX*j + 2]) / 255.0;
return rtvec(r, g, b);
}
} // rt namespace
/// Perlin.hpp
// https://www.cnblogs.com/lv-anchoret/p/10291292.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the Perlin-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of Perlin class
class Perlin
{
public:
/*
产生噪声值
*/
inline rtvar noise(const rtvec& p)const;
/*
@brief: 三线性插值
@param: list -> 辅助数组
u v w -> 0~1 的辅助系数
@retur: 插值结果值
*/
static rtvar perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w);
/*
对噪声值进行采样
*/
inline rtvar turb(const rtvec& p, int depth) const;
inline rtvec* randomvalue()const { return _randomvalue; }
inline int* perm_x()const { return _perm_x; }
inline int* perm_y()const { return _perm_y; }
inline int* perm_z()const { return _perm_z; }
private:
static rtvec * _randomvalue;
static int * _perm_x;
static int * _perm_y;
static int * _perm_z;
};
// the implement of Perlin class
rtvec * Perlin::_randomvalue = lvgm::random_normalized3D(256);
int * Perlin::_perm_x = lvgm::generate_random0n(256);
int * Perlin::_perm_y = lvgm::generate_random0n(256);
int * Perlin::_perm_z = lvgm::generate_random0n(256);
rtvar Perlin::turb(const rtvec& p, int depth = 7) const
{
rtvar accumulate = 0;
rtvec t = p;
rtvar weight = 1.0;
for (int i = 0; i < depth; i++)
{
accumulate += weight*noise(t);
weight *= 0.5;
t *= 2;
}
return abs(accumulate);
}
inline rtvar Perlin::noise(const rtvec& p)const
{
int i = floor(p.x());
int j = floor(p.y());
int k = floor(p.z());
rtvar u = p.x() - i;
rtvar v = p.y() - j;
rtvar w = p.z() - k;
rtvec list[2][2][2];
for (int a = 0; a < 2; ++a)
for (int b = 0; b < 2; ++b)
for (int c = 0; c < 2; ++c)
{
list[a][b][c] = _randomvalue[_perm_x[(i + a) & 255] ^ _perm_y[(j + b) & 255] ^ _perm_z[(k + c) & 255]];
#ifdef listtest
if (list[a][b][c].x() < 0)stds cout << "list.x < 0 " << stds endl;
if (list[a][b][c].y() < 0)stds cout << "list.y < 0 " << stds endl;
if (list[a][b][c].z() < 0)stds cout << "list.z < 0 " << stds endl;
#endif
}
return perlin_interp(list, u, v, w);
}
rtvar Perlin::perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w)
{
#ifdef uvwtest
if (u < 0)stds cout << "u < 0 " << stds endl;
if (v < 0)stds cout << "v < 0 " << stds endl;
if (w < 0)stds cout << "w < 0 " << stds endl;
if (u > 1)stds cout << "u > 1 " << stds endl;
if (v > 1)stds cout << "v > 1 " << stds endl;
if (w > 1)stds cout << "w > 1 " << stds endl;
#endif
rtvar uu = u*u*(3 - 2 * u);
rtvar vv = u*v*(3 - 2 * v);
rtvar ww = u*w*(3 - 2 * w);
rtvar accumulate = 0;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
{
rtvec weight(u - i, v - j, w - k);
accumulate +=
(i*uu + (1 - i) * (1 - uu))*
(j*vv + (1 - j) * (1 - vv))*
(k*ww + (1 - k) * (1 - ww))*
lvgm::dot(list[i][j][k], weight);
#ifdef accumulatetest
if (accumulate < 0)stds cout << "accumulate < 0 " << stds endl;
#endif
}
return accumulate;
}
} // rt namespace
/// noise_tex.hpp
// https://www.cnblogs.com/lv-anchoret/p/10291292.html
// -----------------------------------------------------
// [author] lv
// [begin ] 2019.1
// [brief ] the noise_texture-class for the ray-tracing project
// from the 《ray tracing the next week》
// -----------------------------------------------------
#pragma once
namespace rt
{
// the statement of noise_texture class
class noise_texture :public texture
{
public:
noise_texture() { }
noise_texture(const rtvar scale);
virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
inline const rtvar get_scale()const { return _scale; }
inline void set_scale(const rtvar s) { _scale = s; }
private:
Perlin _noise;
rtvar _scale;
};
// the implementation of noise_texture class
noise_texture::noise_texture(const rtvar scale)
:_scale(scale)
{
}
rtvec noise_texture::value(rtvar u, rtvar v, const rtvec& p)const
{
return rtvec(1., 1., 1.) * 0.5 * (1 + sin(_scale * p.z() + 10 * _noise.noise(p)));
}
} // rt namespace
如果有什么问题可以留言
来源：oschina
链接：https://my.oschina.net/u/4413093/blog/3662222