1. extern crate time;
  2. extern crate green;
  4. use green::{SchedPool, PoolConfig, GreenTaskBuilder};
  5. use std::cmp;
  6. use std::f64;
  7. use std::fmt;
  8. use std::io::File;
  9. use std::iter;
  10. use std::mem;
  11. use std::rand::Rng;
  12. use std::rand;
  13. use std::raw;
  14. use std::sync::Arc;
  15. use std::task::TaskBuilder;
  16. use time::precise_time_s;
  18. type Rfloat = f64;
  20. const RESOLUTION : uint = 128;
  21. const RAY_BIAS : Rfloat = 0.0005;
  22. const SPP : uint = 16*16; // samples per pixel
  23. const MAX_BOUNCES : uint = 8;
  24. const MIN_BOUNCES : uint = 4;
  25. const NUM_AA : uint = 4;
  26. const INV_AA : Rfloat = 1.0 / (NUM_AA as Rfloat);
  28. struct Vector
  29. {
  30. x : Rfloat,
  31. y : Rfloat,
  32. z : Rfloat,
  33. }
  35. enum MaterialType
  36. {
  37. DIFFUSE,
  38. GLOSSY,
  39. MIRROR
  40. }
  42. struct Material
  43. {
  44. material_type : MaterialType,
  45. diffuse : Vector,
  46. emissive : Vector,
  47. specular : Vector,
  48. exp : Rfloat,
  49. }
  51. impl Material
  52. {
  53. fn default() -> Material
  54. {
  55. Material { material_type : DIFFUSE, diffuse : Vector::zero(), emissive : Vector::zero(), specular : Vector::zero(), exp : 0.0 }
  56. }
  57. }
  59. struct Sphere
  60. {
  61. radius : Rfloat,
  62. center : Vector,
  63. material : Box<Material>,
  65. radius_sqr : Rfloat,
  66. }
  68. impl Sphere
  69. {
  70. fn new(radius : Rfloat, center : Vector, material : Box<Material>) -> Sphere
  71. {
  72. Sphere { radius : radius, center : center, material : material, radius_sqr : radius*radius }
  73. }
  75. fn intersects(&self, ray : &Ray) -> Rfloat
  76. {
  77. let op = self.center - ray.origin;
  78. let b = dot(&op, &ray.dir);
  79. let mut d = b * b - dot(&op, &op) + self.radius_sqr;
  81. if d < 0.0
  82. {
  83. return 0.0
  84. }
  86. d = d.sqrt();
  87. let mut t = b - d;
  89. if t > RAY_BIAS
  90. {
  91. return t
  92. }
  94. t = b + d;
  95. if t > RAY_BIAS
  96. {
  97. return t
  98. }
  100. return 0.0
  101. }
  102. fn is_light(&self) -> bool
  103. {
  104. (dot(&self.material.emissive, &self.material.emissive) > 0.0)
  105. }
  106. }
  108. struct Ray
  109. {
  110. origin : Vector,
  111. dir : Vector,
  112. }
  114. impl Ray
  115. {
  116. fn calc_intersection_point(&self, t : Rfloat) -> Vector
  117. {
  118. return self.origin + self.dir * t;
  119. }
  120. }
  122. fn dot(a : &Vector, b : &Vector) -> Rfloat
  123. {
  124. a.x * b.x + a.y * b.y + a.z * b.z
  125. }
  127. fn cross(a : &Vector, b : &Vector) -> Vector
  128. {
  129. Vector { x : a.y*b.z - a.z*b.y, y : a.z*b.x - a.x*b.z, z : a.x*b.y - a.y*b.x }
  130. }
  132. fn clamp(x : Rfloat, min : Rfloat, max : Rfloat) -> Rfloat
  133. {
  134. if x < min
  135. {
  136. return min;
  137. }
  138. if x > max
  139. {
  140. return max;
  141. }
  142. return x;
  143. }
  145. fn max(x : Rfloat, y : Rfloat) -> Rfloat
  146. {
  147. if x > y
  148. {
  149. return x;
  150. }
  151. else
  152. {
  153. return y;
  154. }
  155. }
  157. impl Vector
  158. {
  159. fn new(vx : Rfloat, vy : Rfloat, vz : Rfloat) -> Vector
  160. {
  161. Vector { x : vx, y : vy, z : vz }
  162. }
  163. fn new_normal(mut vx : Rfloat, mut vy : Rfloat, mut vz : Rfloat) -> Vector
  164. {
  165. let len_sqr = vx*vx + vy*vy + vz * vz;
  166. if len_sqr > f64::EPSILON
  167. {
  168. let len = len_sqr.sqrt();
  169. vx /= len;
  170. vy /= len;
  171. vz /= len;
  172. }
  173. Vector { x : vx, y : vy, z : vz }
  174. }
  175. fn zero() -> Vector
  176. {
  177. Vector { x : 0.0, y : 0.0, z : 0.0 }
  178. }
  180. fn normalize(&mut self)
  181. {
  182. let len_sqr = dot(self, self);
  183. if len_sqr > f64::EPSILON
  184. {
  185. let oo_len = 1.0 / len_sqr.sqrt();
  186. self.x *= oo_len;
  187. self.y *= oo_len;
  188. self.z *= oo_len;
  189. }
  190. }
  192. fn clamp01(&mut self)
  193. {
  194. self.x = clamp(self.x, 0.0, 1.0);
  195. self.y = clamp(self.y, 0.0, 1.0);
  196. self.z = clamp(self.z, 0.0, 1.0);
  197. }
  199. fn get_color(&self) -> (u32, u32, u32)
  200. {
  201. let mut color = *self;
  202. color.clamp01();
  204. let r = (color.x.powf(0.45) * 255.0 + 0.5) as u32;
  205. let g = (color.y.powf(0.45) * 255.0 + 0.5) as u32;
  206. let b = (color.z.powf(0.45) * 255.0 + 0.5) as u32;
  208. (r, g, b)
  209. }
  211. fn vecmul(&self, other : &Vector) -> Vector
  212. {
  213. Vector { x : self.x * other.x, y : self.y * other.y, z : self.z * other.z }
  214. }
  216. fn set(&mut self, x : Rfloat, y : Rfloat, z : Rfloat)
  217. {
  218. self.x = x;
  219. self.y = y;
  220. self.z = z;
  221. }
  223. fn max_component(&self) -> Rfloat
  224. {
  225. max(max(self.x, self.y), self.z)
  226. }
  228. fn negate(&mut self)
  229. {
  230. self.x = -self.x;
  231. self.y = -self.y;
  232. self.z = -self.z;
  233. }
  234. }
  236. impl Sub<Vector, Vector> for Vector
  237. {
  238. fn sub(&self, other: &Vector) -> Vector
  239. {
  240. Vector { x : self.x - other.x, y : self.y - other.y, z : self.z - other. z}
  241. }
  242. }
  244. impl Add<Vector, Vector> for Vector
  245. {
  246. fn add(&self, other : &Vector) -> Vector
  247. {
  248. Vector { x : self.x + other.x, y : self.y + other.y, z : self.z + other.z }
  249. }
  250. }
  252. impl Mul<Rfloat, Vector> for Vector
  253. {
  254. fn mul(&self, s : &Rfloat) -> Vector
  255. {
  256. Vector { x : self.x * *s, y : self.y * *s, z : self.z * *s }
  257. }
  258. }
  260. impl fmt::Show for Vector {
  261. fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  262. write!(f, "({}, {}, {})", self.x, self.y, self.z)
  263. }
  264. }
  266. struct Camera
  267. {
  268. forward : Vector,
  269. fov_scale : Rfloat,
  270. }
  272. struct Scene
  273. {
  274. objects : Vec<Sphere>,
  275. lights : Vec<uint>,
  276. camera : Box<Camera>,
  277. }
  279. impl Scene
  280. {
  281. fn intersect(&self, ray : &Ray) -> Option<(Rfloat, &Sphere)>
  282. {
  283. let mut result = None;
  284. let mut min_t = f64::MAX_VALUE;
  286. for sphere in self.objects.iter()
  287. {
  288. let t = sphere.intersects(ray);
  289. if t > 0.0 && t < min_t
  290. {
  291. min_t = t;
  292. result = Some((min_t, sphere));
  293. }
  294. }
  295. (result)
  296. }
  297. fn collect_lights(&mut self)
  298. {
  299. for (index, object) in self.objects.iter().enumerate()
  300. {
  301. if object.is_light()
  302. {
  303. self.lights.push(index);
  304. }
  306. }
  307. }
  308. }
  310. struct Context
  311. {
  312. scene : Box<Scene>,
  313. samples : [Rfloat, ..SPP * 2]
  314. }
  316. fn rand01<T:Rng>(rng : &mut T) -> Rfloat
  317. {
  318. (rng.gen::<Rfloat>())
  319. }
  321. // Given 1 axis, returns other 2
  322. fn build_basis(v1 : &Vector) -> (Vector, Vector)
  323. {
  324. let mut v2 = Vector::zero();
  326. if v1.x.abs() > v1.y.abs()
  327. {
  328. let oo_len = 1.0 / (v1.x * v1.x + v1.z * v1.z).sqrt();
  329. v2.set(-v1.z*oo_len, 0.0, v1.x*oo_len);
  330. }
  331. else
  332. {
  333. let oo_len = 1.0 / (v1.y * v1.y + v1.z * v1.z).sqrt();
  334. v2.set(0.0, v1.z*oo_len, -v1.y*oo_len);
  335. }
  336. (v2, cross(v1, &v2))
  337. }
  339. fn transform_to_basis(vin : &Vector, vx : &Vector, vy : &Vector, vz : &Vector) -> Vector
  340. {
  341. Vector
  342. {
  343. x : vx.x*vin.x + vy.x*vin.y + vz.x*vin.z,
  344. y : vx.y*vin.x + vy.y*vin.y + vz.y*vin.z,
  345. z : vx.z*vin.x + vy.z*vin.y + vz.z*vin.z
  346. }
  347. }
  349. fn reflect(dir : &Vector, n : &Vector) -> Vector
  350. {
  351. let h = *n * (dot(dir, n) * 2.0);
  352. return h - *dir;
  353. }
  355. fn initialize_samples<T:Rng>(samples : &mut [Rfloat, ..SPP * 2], rng : &mut T)
  356. {
  357. let xstrata = (SPP as Rfloat).sqrt();
  358. let ystrata = (SPP as Rfloat) / xstrata;
  360. let mut is = 0;
  362. for ystep in range(0u, ystrata as uint)
  363. {
  364. for xstep in range(0u, xstrata as uint)
  365. {
  366. let fx = ((xstep as Rfloat) + rand01(rng)) / xstrata;
  367. let fy = ((ystep as Rfloat) + rand01(rng)) / ystrata;
  368. samples[is] = fx;
  369. samples[is + 1] = fy;
  370. is += 2;
  371. }
  372. }
  373. }
  375. impl Context
  376. {
  377. fn initialize_samples(&mut self)
  378. {
  379. let mut rng = rand::task_rng();
  380. initialize_samples(&mut self.samples, &mut rng);
  381. }
  382. }
  384. fn sample_hemisphere_cosine(u1 : Rfloat, u2 : Rfloat) -> Vector
  385. {
  386. let phi = 2.0 * f64::consts::PI * u1;
  387. let r = u2.sqrt();
  389. let sx = phi.cos() * r;
  390. let sy = phi.sin() * r;
  392. (Vector{x : sx, y : sy, z : (1.0 - sx*sx - sy*sy).sqrt()})
  393. }
  395. fn sample_hemisphere_specular(u1 : Rfloat, u2 : Rfloat, exp : Rfloat) -> Vector
  396. {
  397. let phi = 2.0 * f64::consts::PI * u1;
  399. let cos_theta = (1.0 - u2).powf(1.0 / (exp + 1.0));
  400. let sin_theta = (1.0 - cos_theta*cos_theta).sqrt();
  402. Vector { x : phi.cos() * sin_theta, y: phi.sin() * sin_theta, z : cos_theta }
  403. }
  406. fn interreflect_diffuse(normal : &Vector, intersection_point : &Vector, u1 : Rfloat, u2 : Rfloat) -> Ray
  407. {
  408. let (v2, v3) = build_basis(normal);
  410. let sampled_dir = sample_hemisphere_cosine(u1, u2);
  412. let new_ray = Ray { origin : *intersection_point,
  413. dir : transform_to_basis(&sampled_dir, &v2, &v3, normal) };
  415. return new_ray;
  416. }
  418. fn interreflect_specular(normal : &Vector, intersection_point : &Vector, u1 : Rfloat, u2 : Rfloat, exp : Rfloat,
  419. new_ray : &mut Ray)
  420. {
  421. let view = new_ray.dir * -1.0;
  422. let mut reflected = reflect(&view, normal);
  423. reflected.normalize();
  425. let (v2, v3) = build_basis(&reflected);
  427. let sampled_dir = sample_hemisphere_specular(u1, u2, exp);
  429. new_ray.origin = *intersection_point;
  430. new_ray.dir = transform_to_basis(&sampled_dir, &v2, &v3, &reflected);
  431. }
  433. fn sample_lights(scene : &Box<Scene>, intersection : &Vector, normal : &Vector, ray_dir : &Vector, material : &Box<Material>) -> Vector
  434. {
  435. let mut color = Vector::zero();
  437. for light_index in scene.lights.iter()
  438. {
  439. let ref light = scene.objects[*light_index];
  440. let mut l = light.center - *intersection;
  441. let light_dist_sqr = dot(&l, &l);
  442. l.normalize();
  444. let mut d = dot(normal, &l);
  445. if d < 0.0
  446. {
  447. d = 0.0
  448. }
  450. let shadow_ray = Ray { origin : *intersection, dir : l };
  451. match scene.intersect(&shadow_ray)
  452. {
  453. None => {}
  454. Some((t, object)) =>
  455. {
  456. if object as *const Sphere == light as *const Sphere
  457. {
  458. let sin_alpha_max_sqr = light.radius_sqr / light_dist_sqr;
  459. let cos_alpha_max = (1.0 - sin_alpha_max_sqr).sqrt();
  461. let omega = 2.0 * (1.0 - cos_alpha_max);
  462. d *= omega;
  464. let c = material.diffuse.vecmul(&light.material.emissive);
  465. color = color + c * d;
  467. // Specular part
  468. match material.material_type
  469. {
  470. DIFFUSE => {}
  471. GLOSSY | MIRROR =>
  472. {
  473. let reflected = reflect(&l, normal);
  474. d = -dot(&reflected, ray_dir);
  475. if d < 0.0
  476. {
  477. d = 0.0;
  478. }
  479. let smul = d.powf(material.exp);
  480. let spec_color = material.specular * smul;
  481. color = color + spec_color;
  482. }
  483. }
  484. }
  485. }
  486. }
  487. }
  488. (color)
  489. }
  491. fn trace<T:Rng>(ray : &mut Ray, scene : &Box<Scene>, samples : &[Rfloat, ..SPP * 2], mut u1 : Rfloat, mut u2 : Rfloat, rng : &mut T) -> Vector
  492. {
  493. let mut result = Vector::zero();
  494. let mut rr_scale = Vector { x : 1.0, y : 1.0, z : 1.0 };
  495. let mut direct = true;
  497. for bounce in range(0, MAX_BOUNCES)
  498. {
  499. match scene.intersect(ray)
  500. {
  501. None => break,
  503. Some((t, object)) =>
  504. {
  505. let ref material = object.material;
  506. if direct
  507. {
  508. result = result + material.emissive.vecmul(&rr_scale);
  509. }
  511. let mut diffuse = material.diffuse;
  512. let max_diffuse = diffuse.max_component();
  513. if bounce > MIN_BOUNCES || max_diffuse < f64::EPSILON
  514. {
  515. if rand01(rng) > max_diffuse
  516. {
  517. break;
  518. }
  519. diffuse = diffuse * (1.0 / max_diffuse);
  520. }
  522. let intersection_point = ray.calc_intersection_point(t);
  523. let mut normal = (intersection_point - object.center) * (1.0 / object.radius);
  524. if dot(&normal, &ray.dir) >= 0.0
  525. {
  526. normal.negate();
  527. }
  529. match material.material_type
  530. {
  531. DIFFUSE =>
  532. {
  533. direct = false;
  534. let direct_light = rr_scale.vecmul(&sample_lights(scene, &intersection_point, &normal, &ray.dir, material));
  535. result = result + direct_light;
  537. *ray = interreflect_diffuse(&normal, &intersection_point, u1, u2);
  538. rr_scale = rr_scale.vecmul(&diffuse);
  539. }
  541. GLOSSY =>
  542. {
  543. direct = false;
  544. let direct_light = rr_scale.vecmul(&sample_lights(scene, &intersection_point, &normal, &ray.dir, material));
  545. result = result + direct_light;
  547. // Specular/diffuse Russian roulette
  548. let max_spec = material.specular.max_component();
  549. let p = max_spec / (max_spec + max_diffuse);
  550. let smult = 1.0 / p;
  552. if rand01(rng) > p // diffuse
  553. {
  554. *ray = interreflect_diffuse(&normal, &intersection_point, u1, u2);
  555. let color = diffuse * (1.0 / (1.0 - 1.0/smult));
  556. rr_scale = rr_scale.vecmul(&color);
  557. }
  558. else
  559. {
  560. interreflect_specular(&normal, &intersection_point, u1, u2, material.exp, ray);
  561. let color = material.specular * smult;
  562. rr_scale = rr_scale.vecmul(&color);
  563. }
  564. }
  566. MIRROR =>
  567. {
  568. let view = ray.dir * -1.0;
  569. let mut reflected = reflect(&view, &normal);
  570. reflected.normalize();
  572. ray.origin = intersection_point;
  573. ray.dir = reflected;
  575. rr_scale = rr_scale.vecmul(&diffuse);
  576. }
  577. }
  579. let sample_index = rng.gen_range(0u, SPP);
  580. u1 = samples[sample_index*2];
  581. u2 = samples[sample_index*2+1];
  582. }
  583. }
  584. }
  585. (result)
  586. }
  588. fn apply_tent_filter(samples : &mut [Rfloat, ..SPP * 2])
  589. {
  590. for i in range(0, SPP)
  591. {
  592. let x = samples[i*2+0];
  593. let y = samples[i*2+1];
  595. samples[i * 2] = match x {
  596. x if x < 0.5 => (2.0 * x).sqrt() - 1.0,
  597. _ => 1.0 - (2.0 - 2.0 * x).sqrt()
  598. };
  599. samples[i * 2 + 1] = match y {
  600. y if y < 0.5 => (2.0 * y).sqrt() - 1.0,
  601. _ => 1.0 - (2.0 - 2.0 * y).sqrt()
  602. };
  603. }
  604. }
  606. fn process_chunk(context : &Context, buffer : &mut [u8], offset : uint, chunk_size : uint)
  607. {
  608. let res = RESOLUTION as Rfloat;
  609. let camera = &context.scene.camera;
  611. let cx = Vector { x : camera.fov_scale, y : 0.0, z : 0.0 };
  612. let mut cy = cross(&cx, &camera.forward);
  613. cy.normalize();
  614. cy = cy * camera.fov_scale;
  616. let ray_origin = Vector { x : 50.0, y : 52.0, z : 295.6 };
  618. let mut chunk_samples = [0.0, ..SPP*2];
  619. let mut sphere_samples = [0.0, ..SPP*2];
  621. let mut rng = rand::task_rng();
  623. initialize_samples(&mut chunk_samples, &mut rng);
  624. apply_tent_filter(&mut chunk_samples);
  626. let inv_spp = 1.0 / SPP as Rfloat;
  628. let start_x = offset % RESOLUTION;
  629. let start_y = offset / RESOLUTION;
  631. let mut y = start_y;
  632. let mut x = start_x;
  634. let end_offset = chunk_size * 4;
  635. for pixel_offset in iter::range_step(0, end_offset, 4)
  636. {
  637. initialize_samples(&mut sphere_samples, &mut rng);
  639. let mut cr = Vector::zero();
  640. for aa in range(0u, NUM_AA)
  641. {
  642. let mut pr = Vector::zero();
  644. let aax = (aa & 0x1) as Rfloat;
  645. let aay = (aa >> 1) as Rfloat;
  647. for s in range(0, SPP)
  648. {
  649. let dx = chunk_samples[s * 2];
  650. let dy = chunk_samples[s * 2 + 1];
  652. let px = (((aax + 0.5 + dx) / 2.0) + (x as Rfloat)) / res - 0.5;
  653. let py = -((((aay + 0.5 + dy) / 2.0) + y as Rfloat) / res - 0.5);
  655. let ccx = cx * px;
  656. let ccy = cy * py;
  658. let mut ray_dir = ccx + ccy + camera.forward;
  659. ray_dir.normalize();
  661. let mut ray = Ray{ origin : ray_origin + ray_dir * 136.0, dir : ray_dir};
  662. let u1 = sphere_samples[s*2];
  663. let u2 = sphere_samples[s*2+1];
  665. let r = trace(&mut ray, &context.scene, &context.samples, u1, u2, &mut rng);
  667. pr = pr + (r * inv_spp);
  668. }
  669. cr = cr + (pr * INV_AA);
  670. }
  671. let (r, g, b) = cr.get_color();
  673. buffer[pixel_offset + 3] = 0xFF;
  674. buffer[pixel_offset + 0] = b as u8;
  675. buffer[pixel_offset + 1] = g as u8;
  676. buffer[pixel_offset + 2] = r as u8;
  678. x = x + 1;
  679. if x == RESOLUTION
  680. {
  681. x = 0;
  682. y = y + 1;
  683. }
  684. }
  685. }
  687. fn put16(buffer : &mut [u8], index : uint, v : u16)
  688. {
  689. buffer[index + 0] = (v & 0xFF) as u8;
  690. buffer[index + 1] = (v >> 8) as u8;
  691. }
  693. fn write_tga_header(f : &mut File, width : uint, height : uint)
  694. {
  695. let mut header : [u8, ..18] = [0, ..18];
  697. header[2] = 2; // 32-bit
  698. put16(header, 12, width as u16);
  699. put16(header, 14, height as u16);
  700. header[16] = 32; // BPP
  701. header[17] = 0x20; // top down, non interlaced
  703. f.write(header);
  704. }
  706. fn write_tga(fname : &Path, pixels : &[u8], width : uint, height : uint)
  707. {
  708. let mut file = match File::create(fname) {
  709. Ok(f) => f,
  710. Err(e) => panic!("file error: {}", e),
  711. };
  713. write_tga_header(&mut file, width, height);
  715. file.write(pixels);
  716. }
  718. fn main()
  719. {
  720. let fov_scale = (55.0 * f64::consts::PI / 180.0 * 0.5).tan();
  721. let camera = Camera{ forward : Vector::new_normal(0.0, -0.042612, -1.0), fov_scale: fov_scale };
  723. let diffuse_grey = Material{ material_type : DIFFUSE, diffuse : Vector::new(0.75, 0.75, 0.75), ..Material::default() };
  724. let diffuse_red = Material{ material_type: DIFFUSE, diffuse: Vector::new(0.95, 0.15, 0.15), ..Material::default() };
  725. let diffuse_blue = Material{ material_type: DIFFUSE, diffuse: Vector::new(0.25, 0.25, 0.7), ..Material::default() };
  726. let diffuse_black = Material{ material_type: DIFFUSE, ..Material::default() };
  727. let diffuse_green = Material{ material_type: DIFFUSE, diffuse: Vector::new(0.0, 0.55, 14.0/255.0), ..Material::default() };
  728. let diffuse_white = Material{ material_type: DIFFUSE, diffuse: Vector::new(0.99, 0.99, 0.99), ..Material::default() };
  729. let glossy_white = Material{ material_type: GLOSSY, diffuse: Vector::new(0.3, 0.05, 0.05),
  730. specular: Vector::new(0.69, 0.69, 0.69), exp: 45.0, emissive: Vector::zero() };
  731. let white_light = Material{ material_type: DIFFUSE, emissive: Vector::new(400.0, 400.0, 400.0), ..Material::default() };
  732. let mirror = Material{material_type: MIRROR, diffuse: Vector::new(0.999, 0.999, 0.999), ..Material::default() };
  734. let mut scene = Scene
  735. {
  736. objects: vec!{
  737. Sphere::new(1e5, Vector::new(1e5 + 1.0, 40.8, 81.6), box diffuse_red),
  738. Sphere::new(1e5, Vector::new(-1e5 + 99.0, 40.8, 81.6), box diffuse_blue),
  739. Sphere::new(1e5, Vector::new(50.0, 40.8, 1e5), box diffuse_grey),
  740. Sphere::new(1e5, Vector::new(50.0, 40.8, -1e5 + 170.0), box diffuse_black),
  741. Sphere::new(1e5, Vector::new(50.0, 1e5, 81.6), box diffuse_grey),
  742. Sphere::new(1e5, Vector::new(50.0, -1e5 + 81.6, 81.6), box diffuse_grey),
  743. Sphere::new(16.5, Vector::new(27.0, 16.5, 57.0), box mirror),
  744. Sphere::new(10.5, Vector::new(17.0, 10.5, 97.0), box diffuse_green),
  745. Sphere::new(16.5, Vector::new(76.0, 16.5, 78.0), box glossy_white),
  746. Sphere::new(8.5, Vector::new(82.0, 8.5, 108.0), box diffuse_white),
  747. Sphere::new(1.5, Vector::new(50.0, 81.6 - 16.5, 81.6), box white_light)
  748. },
  749. lights: vec!{},
  750. camera : box camera
  751. };
  752. scene.collect_lights();
  754. let start_time = precise_time_s();
  756. let mut context = Context { scene : box scene, samples : [0.0, ..SPP*2] };
  757. context.initialize_samples();
  759. // in pixels
  760. let chunk_size = 16u;
  761. let num_tasks = (RESOLUTION * RESOLUTION) / chunk_size;
  762. println!("Num tasks = {}", num_tasks);
  764. let granularity = chunk_size * 4;
  765. let mut framebuffer:Vec<u8> = Vec::from_elem(RESOLUTION * RESOLUTION * 4, 0);
  767. let mut pool = SchedPool::new(PoolConfig::new());
  769. let raw::Slice { data, len } = unsafe { mem::transmute::<_, raw::Slice<u8>>(framebuffer.as_mut_slice()) };
  770. let context_arc = Arc::new(context);
  771. println!("granularity: {}", granularity);
  772. let futures = iter::range_step(0, len, granularity).map(|offset|
  773. {
  774. let local_arc = context_arc.clone();
  776. TaskBuilder::new().green(&mut pool).try_future(proc()
  777. {
  778. let slice = raw::Slice {
  779. data: unsafe { data.offset(offset as int) },
  780. len: cmp::min(granularity, len - offset)
  781. };
  782. let data = unsafe { mem::transmute::<_, &mut [u8]>(slice) };
  783. let local_context = local_arc.deref();
  784. process_chunk(local_context, data, offset >> 2, chunk_size);
  785. })
  786. }).collect::<Vec<_>>();
  788. for f in futures.into_iter()
  789. {
  790. if f.unwrap().is_err()
  791. {
  792. panic!();
  793. }
  794. }
  796. let time_taken = precise_time_s() - start_time;
  797. println!("Tracing took {} seconds", time_taken);
  799. pool.shutdown();
  801. write_tga(&Path::new("trace.tga"), framebuffer.as_slice(), RESOLUTION, RESOLUTION);
  802. }