definición de la clase y la ejecución Fishhole

Cuando el ojo está en el agua, tener una perspectiva de ojo de pez similares, FOV es siempre psi_max 2 veces. Los libros de referencia algoritmo.

 

declaración de la clase:

#pragma vez 
#ifndef __FISHHOLE_HEADER__ 
#define __FISHHOLE_HEADER__ 

# include "camera.h" 

clase Fishhole: Cámara pública { 
público: 
	Fishhole (); 
	~ Fishhole (); 
	Fishhole (const Fishhole y fh); 
	set_fov void (const LHaga fov); 
	set_angle void (const LHaga deg); 
	Vector3 ray_direction (const Point3 y PP, HRES enteros const, vres enteros const, const LHaga s, LHaga y r_squared) const; 
	clon virtual de la cámara * () const; 
	Virtual render_scene vacío (World & w); 
	Fishhole operador & = (const Fishhole y fh); 
: privada 
	psi_max LHaga; // FOV / 2 
}; 
#terminara si

　　

implementación de la clase:

# include "pch.h" 
# include "fishhole.h" 
# include "../utilities/world.h" 
# include "../utilities/viewplane.h" 
"../samplers/sampler.h" # include 
# include "../tracers/tracer.h" 

Fishhole :: Fishhole (): la cámara (), psi_max (180) {} 

Fishhole :: ~ Fishhole () {} 

Fishhole :: Fishhole (const Fishhole y FH): la cámara ( fh), psi_max (fh.psi_max) {} 

void Fishhole :: set_fov (const LHaga FOV) { 
	psi_max = FOV / 2; 
} 

Void Fishhole :: set_angle (const LHaga deg) { 
	LHaga rad = radianes (grados); 
	arriba = Point3 (std :: cos (rad) * up.x - std :: sin (rad) * up.y, 
		std :: sin (rad) * up.x + std :: cos (rad) * arriba. y, up.z); 
}

Vector3 Fishhole :: ray_direction (const Point3 y PP, HRES enteros const, vres enteros const, const LHaga s, LHaga y r_squared) const { 
	Point3 pn (2,0 / (s HRES *) * pp.x, 2.0 / (s VRES *) * pp.y, 0); 
	r_squared = pn.x * pn.x + pn.y * pn.y; 
	Dir Vector3; 
	si (r_squared <= 1,0) { 
		LHaga r = std :: sqrt (r_squared); 
		LHaga = psi r radián * (psi_max); 
		LHaga sin_psi = std :: sin (psi), cos_psi = std :: cos (psi), sin_alpha = pn.y / r, cos_alpha = pn.x / r; 
		dir = sin_psi * cos_alpha * u + sin_psi * sin_alpha * v - cos_psi * w; 
	} 
	Devolver dir; 
} 

De la cámara * Fishhole :: clone () const { 
	return new Fishhole (* this); 
} 
 
Void Fishhole :: render_scene (World & w) {
	Ray Ray;
	Vp ViewPlane (w.vp); 
	profundidad Integer = 0; 
	Sp Point3, pp; 
	LHaga r_squared; 
	w.open_window (vp.hres, vp.vres); 
	ray.o = ojo; 
	vp.s = 1 / vp.s; 
	para (entero r = vp.vres - 1; r> = 0; r -) // genera de-esquina izquierda a derecha-esquina 
		para (número entero c = 0; c <vp.hres; c ++) { 
			el color RGBColor; 
			para (número entero p = 0; p <vp.nsamples; p ++) { 
				sp = vp.sampler-> sample_unit_square (); 
				pp.x = (c - 0,5 * vp.hres + sp.x) * vp.s; 
				pp.y = (r - 0,5 * vp.vres + sp.y) * vp.s; 
				ray.d = ray_direction (pp, vp.hres, vp.vres, vp.s, r_squared); 
				si (r_squared <= 1,0) 
					color + = w.tracer_ptr-> trace_ray (ray); 
			} 
			de color / = vp.nsamples; 
			De color * = exposure_time; 
			w.display_pixel (r, c, color); 
		} 
} 

Fishhole y Fishhole operador :: = (const Fishhole y FH) { 
	si (este y FH ==) 
		de retorno * esto; 
	= Cámara :: operador (FH); 
	psi_max = fh.psi_max; 
	* volver esto; 
}

resultados de la prueba FIG (FOV es de 180 grados):