【Ray Tracing The Next Week 超详解】 光线追踪2-9

 

我们来整理一下项目的代码

目录

----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;
        }

}

randomfunc.hpp