C++ ray::direction方法代码示例

    std::pair< T, T > intersection( const ray<T,2u>& ray, const circle<T>& circle )
    { 
      // check for no intersection
    
      const T a = dot( ray.direction(), ray.direction() );
      const T b = T(2.) * sum( ray.direction() * ( ray.source() - circle.center() ) );
      const T c =   dot( circle.center(), circle.center() ) 
                  + dot( ray.source(), ray.source() ) 
                  - T(2.) * dot( ray.source(), circle.center() )
                  - sqr( circle.radius() );

      return solve_quadratic_equation(a,b,c);
    }

bool sphere::hit(const ray& r, float t_min, float t_max, hit_record& rec) const
{
    vec3 oc = r.origin() - center;
    
    float v2 = dot(r.direction(), r.direction());
    float voc = dot(oc, r.direction());

    // 判別式.
    float discriminant = voc * voc - v2 * (dot(oc, oc) - radius*radius);

    if (discriminant > 0) {
        // 手前.
        float temp = (-voc - sqrt(discriminant)) / v2;

        if (temp < t_max && temp > t_min) {
            rec.t = temp;
            rec.p = r.org + rec.t * r.dir;
            
            rec.normal = (rec.p - center);
            rec.normal.noramlize();

            getUV(rec.u, rec.v, rec.normal);

            rec.mat_ptr = mat_ptr;
            return true;
        }

        // 奥.
        temp = (-voc + sqrt(discriminant)) / v2;

        if (temp < t_max && temp > t_min) {
            rec.t = temp;
            rec.p = r.org + rec.t * r.dir;
            
            rec.normal = (rec.p - center) / radius;
            rec.normal.noramlize();

            getUV(rec.u, rec.v, rec.normal);

            rec.mat_ptr = mat_ptr;
            return true;
        }
    }

    return false;
}

bool yz_rect::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
	double t = (k - r.origin().x()) / r.direction().x();

	if (t<t_min || t>t_max) return false;

	double y = r.origin().y() + t*r.direction().y();
	double z = r.origin().z() + t*r.direction().z();

	if (y<y0 || y>y1 || z<z0 || z>z1) return false;

	rec.u = (y - y0) / (y1 - y0);
	rec.v = (z - z0) / (z1 - z0);
	rec.t = t;
	rec.mat_ptr = mat_ptr;
	rec.point = r.point_at_parameter(t);
	rec.normal = vec3(1.0, 0.0, 0.0);
	return true;
}

vec3 color(const ray& r, surface* world, int depth) {
    hit_record rec;
    
    if (world->hit(r, 0.001, DBL_MAX, rec)) {
        ray scattered;
        vec3 attenuation;
        
        if (depth < MAXDEPTH &&
            rec.mat_ptr->scatter(r, rec, attenuation, scattered)) {
            return attenuation*color(scattered, world, depth+1);
        } else {
            return vec3(0, 0, 0);
        }
    } else {
        vec3 unit_direction = unit_vector(r.direction());
        double 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);
    }
}

static hdr_color
do_shade(scene const& scene, ray const& ray, shading_policy const& policy,
         unsigned depth, double importance, sampler_prng_engine& prng)
{
  if (!should_continue(depth, importance, policy))
    return policy.background;

  boost::optional<scene::intersection> i = scene.intersect_solid(ray);
  if (!i)
    return policy.background;

  hdr_color result = i->texture();
  for (light const& l : scene.lights()) {
    vector3 const light_dir{l.get_source() - i->position()};

    if (auto obstacle = scene.intersect_solid({i->position(), light_dir}))
      if ((obstacle->position() - i->position()).squaredNorm() <
          (l.get_source() - i->position()).squaredNorm())
        continue;  // Obstacle blocks direct path from light to solid

    result = blend_light(
      i->solid().material(), result, i->normal(), l.color(), light_dir
    );
  }

  unit3 const perfect_reflection_dir = reflect(ray.direction(), i->normal());
  unit3 const reflection_dir = cos_lobe_perturb(
    perfect_reflection_dir,
    i->solid().material().specular_exponent(),
    prng
  );
  oxatrace::ray const reflected{i->position(), reflection_dir};
  double const reflection_importance = i->solid().material().reflectance();
  hdr_color const reflection = do_shade(
    scene, reflected, policy, depth + 1, reflection_importance * importance,
    prng
  );
  result = blend_reflection(i->solid().material(), result, reflection);

  return result;
}

vec3 color(const ray& r, hitable *world, int depth)
{
    hit_record rec;

    if (world->hit(r,0.001f, 10000, rec)) { 
        ray scattered;
        vec3 attenuation;

        if (depth < 10 && rec.mat_ptr->scatter(r, rec, attenuation, scattered)) {
             return attenuation * color(scattered, world, depth + 1);
        }
        else {
            // ‰e.
            return vec3(0,0,0);
        }
    }
    else {
        // ‹ó.
        vec3 unit_direction = unit_vector(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);
    }
}

			            ray(const ray<T,Dim>& r)
			            : m_src( r.source() ), m_dir( r.direction() )  {	}