SYMBOL INDEX (1000 symbols across 78 files)

FILE: psychoblend/__init__.py
  class RenderPsychopathSettingsScene (line 37) | class RenderPsychopathSettingsScene(PropertyGroup):
  class PsychopathCamera (line 74) | class PsychopathCamera(bpy.types.PropertyGroup):
  class PsychopathLight (line 81) | class PsychopathLight(bpy.types.PropertyGroup):
  class PsychopathMesh (line 98) | class PsychopathMesh(bpy.types.PropertyGroup):
  class PsychopathMaterial (line 105) | class PsychopathMaterial(bpy.types.PropertyGroup):
  class PsychopathPreferences (line 151) | class PsychopathPreferences(AddonPreferences):
    method draw (line 160) | def draw(self, context):
  function register (line 166) | def register():
  function unregister (line 182) | def unregister():

FILE: psychoblend/assembly.py
  class Assembly (line 5) | class Assembly:
    method __init__ (line 6) | def __init__(self, render_engine, objects, visible_layers, group_prefi...
    method export (line 52) | def export(self, render_engine, w):
    method take_sample (line 82) | def take_sample(self, render_engine, scene, time):
    method cleanup (line 101) | def cleanup(self):
    method get_mesh (line 107) | def get_mesh(self, ob, group_prefix):
    method get_sphere_lamp (line 136) | def get_sphere_lamp(self, ob, group_prefix):
    method get_rect_lamp (line 141) | def get_rect_lamp(self, ob, group_prefix):
  class Mesh (line 150) | class Mesh:
    method __init__ (line 153) | def __init__(self, render_engine, ob, name):
    method take_sample (line 159) | def take_sample(self, render_engine, scene, time):
    method cleanup (line 164) | def cleanup(self):
    method export (line 168) | def export(self, render_engine, w):
  class SphereLamp (line 205) | class SphereLamp:
    method __init__ (line 208) | def __init__(self, render_engine, ob, name):
    method take_sample (line 214) | def take_sample(self, render_engine, scene, time):
    method cleanup (line 226) | def cleanup(self):
    method export (line 229) | def export(self, render_engine, w):
  class RectLamp (line 248) | class RectLamp:
    method __init__ (line 251) | def __init__(self, render_engine, ob, name):
    method take_sample (line 257) | def take_sample(self, render_engine, scene, time):
    method cleanup (line 272) | def cleanup(self):
    method export (line 275) | def export(self, render_engine, w):
  class Instance (line 294) | class Instance:
    method __init__ (line 295) | def __init__(self, render_engine, ob, data_name):
    method take_sample (line 301) | def take_sample(self, render_engine, time, translation_offset):
    method export (line 310) | def export(self, render_engine, w):
  class Material (line 326) | class Material:
    method __init__ (line 327) | def __init__(self, render_engine, material):
    method take_sample (line 330) | def take_sample(self, render_engine, time, translation_offset):
    method export (line 334) | def export(self, render_engine, w):
    method cleanup (line 397) | def cleanup(self):

FILE: psychoblend/psy_export.py
  class IndentedWriter (line 10) | class IndentedWriter:
    method __init__ (line 11) | def __init__(self, file_handle):
    method indent (line 16) | def indent(self):
    method unindent (line 19) | def unindent(self):
    method write (line 24) | def write(self, text, do_indent=True):
  class PsychoExporter (line 31) | class PsychoExporter:
    method __init__ (line 32) | def __init__(self, f, render_engine, scene):
    method set_frame (line 53) | def set_frame(self, frame, fraction):
    method export_psy (line 59) | def export_psy(self):
    method _export_psy (line 71) | def _export_psy(self):

FILE: psychoblend/render.py
  class PsychopathRender (line 9) | class PsychopathRender(bpy.types.RenderEngine):
    method _locate_binary (line 15) | def _locate_binary():
    method _start_psychopath (line 37) | def _start_psychopath(self, scene, psy_filepath, use_stdin, crop):
    method _draw_bucket (line 65) | def _draw_bucket(self, crop, bucket_info, pixels_encoded):
    method render (line 88) | def render(self, scene):
    method _render (line 97) | def _render(self, scene):
  function register (line 232) | def register():
  function unregister (line 235) | def unregister():

FILE: psychoblend/ui.py
  class PsychopathPanel (line 17) | class PsychopathPanel():
    method poll (line 21) | def poll(cls, context):
  class RENDER_PT_psychopath_render_settings (line 26) | class RENDER_PT_psychopath_render_settings(PsychopathPanel, bpy.types.Pa...
    method draw (line 32) | def draw(self, context):
  class RENDER_PT_psychopath_export_settings (line 53) | class RENDER_PT_psychopath_export_settings(PsychopathPanel, bpy.types.Pa...
    method draw (line 59) | def draw(self, context):
  class WORLD_PT_psychopath_background (line 67) | class WORLD_PT_psychopath_background(PsychopathPanel, bpy.types.Panel):
    method poll (line 74) | def poll(cls, context):
    method draw (line 77) | def draw(self, context):
  class DATA_PT_psychopath_camera_dof (line 84) | class DATA_PT_psychopath_camera_dof(PsychopathPanel, bpy.types.Panel):
    method poll (line 91) | def poll(cls, context):
    method draw (line 95) | def draw(self, context):
  class DATA_PT_psychopath_lamp (line 106) | class DATA_PT_psychopath_lamp(PsychopathPanel, bpy.types.Panel):
    method poll (line 113) | def poll(cls, context):
    method draw (line 117) | def draw(self, context):
  class DATA_PT_psychopath_area_lamp (line 139) | class DATA_PT_psychopath_area_lamp(PsychopathPanel, bpy.types.Panel):
    method poll (line 146) | def poll(cls, context):
    method draw (line 151) | def draw(self, context):
  class DATA_PT_psychopath_mesh (line 167) | class DATA_PT_psychopath_mesh(PsychopathPanel, bpy.types.Panel):
    method poll (line 174) | def poll(cls, context):
    method draw (line 178) | def draw(self, context):
  class MATERIAL_PT_psychopath_context_material (line 186) | class MATERIAL_PT_psychopath_context_material(PsychopathPanel, bpy.types...
    method poll (line 194) | def poll(cls, context):
    method draw (line 197) | def draw(self, context):
  class MATERIAL_PT_psychopath_surface (line 237) | class MATERIAL_PT_psychopath_surface(PsychopathPanel, bpy.types.Panel):
    method poll (line 244) | def poll(cls, context):
    method draw (line 247) | def draw(self, context):
  function register (line 270) | def register():
  function unregister (line 281) | def unregister():

FILE: psychoblend/util.py
  class ExportCancelled (line 1) | class ExportCancelled(Exception):
  function mat2str (line 8) | def mat2str(m):
  function needs_def_mb (line 18) | def needs_def_mb(ob):
  function escape_name (line 60) | def escape_name(name):
  function needs_xform_mb (line 71) | def needs_xform_mb(ob):

FILE: psychoblend/world.py
  class World (line 8) | class World:
    method __init__ (line 9) | def __init__(self, render_engine, scene, visible_layers, aspect_ratio):
    method take_sample (line 21) | def take_sample(self, render_engine, scene, time):
    method export (line 30) | def export(self, render_engine, w):
    method cleanup (line 44) | def cleanup(self):
  class Camera (line 51) | class Camera:
    method __init__ (line 52) | def __init__(self, render_engine, ob, aspect_ratio):
    method take_sample (line 61) | def take_sample(self, render_engine, scene, time):
    method export (line 87) | def export(self, render_engine, w):
  class BackgroundShader (line 108) | class BackgroundShader:
    method __init__ (line 109) | def __init__(self, render_engine, world):
    method export (line 114) | def export(self, render_engine, w):
  class DistantDiskLamp (line 124) | class DistantDiskLamp:
    method __init__ (line 125) | def __init__(self, ob, name):
    method take_sample (line 132) | def take_sample(self, render_engine, scene, time):
    method export (line 145) | def export(self, render_engine, w):

FILE: src/accel/bvh.rs
  type BVH (line 16) | pub struct BVH<'a> {
  type BVHNode (line 22) | pub enum BVHNode<'a> {
  function from_objects (line 38) | pub fn from_objects<'b, T, F>(
  function tree_depth (line 66) | pub fn tree_depth(&self) -> usize {
  function traverse (line 70) | pub fn traverse<T, F>(&self, rays: &mut [AccelRay], objects: &[T], mut o...
  function construct_from_base (line 161) | fn construct_from_base(
  method bounds (line 213) | fn bounds(&self) -> &[BBox] {

FILE: src/accel/bvh4.rs
  function ray_code (line 29) | pub fn ray_code(dir: Vector) -> usize {
  type BVH4 (line 37) | pub struct BVH4<'a> {
  type BVH4Node (line 45) | pub enum BVH4Node<'a> {
  function from_objects (line 58) | pub fn from_objects<'b, T, F>(
  function tree_depth (line 97) | pub fn tree_depth(&self) -> usize {
  function traverse (line 101) | pub fn traverse<F>(&self, rays: &mut RayBatch, ray_stack: &mut RayStack,...
  function construct_from_base (line 186) | fn construct_from_base(
  method bounds (line 362) | fn bounds<'b>(&'b self) -> &'b [BBox] {

FILE: src/accel/bvh_base.rs
  constant BVH_MAX_DEPTH (line 7) | pub const BVH_MAX_DEPTH: usize = 42;
  constant USE_UNION_FACTOR (line 12) | const USE_UNION_FACTOR: f32 = 1.4;
  type BVHBase (line 16) | pub struct BVHBase {
    method new (line 48) | fn new() -> BVHBase {
    method from_objects (line 57) | pub fn from_objects<'b, T, F>(objects: &mut [T], objects_per_leaf: usi...
    method root_node_index (line 66) | pub fn root_node_index(&self) -> usize {
    method acc_bounds (line 70) | fn acc_bounds<'a, T, F>(&mut self, objects: &mut [T], bounder: &F)
    method recursive_build (line 96) | fn recursive_build<'a, T, F>(
  type BVHBaseNode (line 24) | pub enum BVHBaseNode {
    method bounds_range (line 38) | pub fn bounds_range(&self) -> (usize, usize) {

FILE: src/accel/light_array.rs
  type LightArray (line 12) | pub struct LightArray<'a> {
  function from_objects (line 19) | pub fn from_objects<'b, T, F>(
  method select (line 45) | fn select(
  method approximate_energy (line 76) | fn approximate_energy(&self) -> f32 {

FILE: src/accel/light_tree.rs
  constant ARITY_LOG2 (line 15) | const ARITY_LOG2: usize = 3;
  constant ARITY (line 18) | const ARITY: usize = 1 << ARITY_LOG2;
  type LightTree (line 21) | pub struct LightTree<'a> {
  type Node (line 27) | enum Node<'a> {
  function bounds (line 41) | fn bounds(&self) -> &'a [BBox] {
  function energy (line 47) | fn energy(&self) -> f32 {
  function light_index (line 53) | fn light_index(&self) -> usize {
  function from_objects (line 62) | pub fn from_objects<'b, T, F>(
  function construct_from_builder (line 89) | fn construct_from_builder(
  method select (line 135) | fn select(
  method approximate_energy (line 203) | fn approximate_energy(&self) -> f32 {
  type LightTreeBuilder (line 212) | struct LightTreeBuilder {
    method new (line 227) | fn new() -> LightTreeBuilder {
    method root_node_index (line 235) | pub fn root_node_index(&self) -> usize {
    method node_child_count (line 241) | pub fn node_child_count(&self, node_index: usize) -> usize {
    method node_nth_child_index (line 247) | pub fn node_nth_child_index(&self, node_index: usize, child_n: usize) ...
    method node_child_count_recurse (line 254) | pub fn node_child_count_recurse(&self, level_collapse: usize, node_ind...
    method node_nth_child_index_recurse (line 274) | pub fn node_nth_child_index_recurse(
    method recursive_build (line 296) | fn recursive_build<'a, T, F>(
  type BuilderNode (line 219) | struct BuilderNode {

FILE: src/accel/mod.rs
  type LightAccel (line 27) | pub trait LightAccel {
    method select (line 29) | fn select(
    method approximate_energy (line 40) | fn approximate_energy(&self) -> f32;

FILE: src/accel/objects_split.rs
  constant SAH_BIN_COUNT (line 13) | const SAH_BIN_COUNT: usize = 13;
  constant SPLIT_PLANE_COUNT (line 14) | const SPLIT_PLANE_COUNT: usize = 5;
  function free_sah_split (line 21) | pub fn free_sah_split<'a, T, F>(seed: u32, objects: &mut [T], bounder: &...
  function sah_split (line 153) | pub fn sah_split<'a, T, F>(objects: &mut [T], bounder: &F) -> (usize, us...
  function bounds_mean_split (line 244) | pub fn bounds_mean_split<'a, T, F>(objects: &mut [T], bounder: &F) -> (u...
  function median_split (line 291) | pub fn median_split<'a, T, F>(objects: &mut [T], bounder: &F) -> (usize,...

FILE: src/algorithm.rs
  function weighted_choice (line 17) | pub fn weighted_choice<T, F>(slc: &[T], n: f32, weight: F) -> (usize, f32)
  function partition (line 44) | pub fn partition<T, F>(slc: &mut [T], mut pred: F) -> usize
  function partition_with_side (line 94) | pub fn partition_with_side<T, F>(slc: &mut [T], mut pred: F) -> usize
  function partition_pair (line 146) | pub fn partition_pair<A, B, F>(slc1: &mut [A], slc2: &mut [B], mut pred:...
  function quick_select (line 203) | pub fn quick_select<T, F>(slc: &mut [T], n: usize, mut order: F)
  function merge_slices_append (line 234) | pub fn merge_slices_append<T: Lerp + Copy, F>(
  function merge_slices_to (line 266) | pub fn merge_slices_to<T: Lerp + Copy, F>(
  function quick_select_ints (line 312) | fn quick_select_ints(list: &mut [i32], i: usize) {
  function quick_select_1 (line 325) | fn quick_select_1() {
  function quick_select_2 (line 332) | fn quick_select_2() {
  function quick_select_3 (line 339) | fn quick_select_3() {
  function quick_select_4 (line 346) | fn quick_select_4() {

FILE: src/bbox.rs
  constant BBOX_MAXT_ADJUST (line 13) | const BBOX_MAXT_ADJUST: f32 = 1.000_000_24;
  type BBox (line 17) | pub struct BBox {
    method new (line 24) | pub fn new() -> BBox {
    method from_points (line 37) | pub fn from_points(min: Point, max: Point) -> BBox {
    method intersect_ray (line 42) | pub fn intersect_ray(&self, orig: Point, dir_inv: Vector, max_t: f32) ...
    method transformed (line 58) | pub fn transformed(&self, xform: Transform) -> BBox {
    method surface_area (line 82) | pub fn surface_area(&self) -> f32 {
    method center (line 87) | pub fn center(&self) -> Point {
    method diagonal (line 91) | pub fn diagonal(&self) -> f32 {
    method diagonal2 (line 95) | pub fn diagonal2(&self) -> f32 {
    type Output (line 124) | type Output = BBox;
    method bitor (line 126) | fn bitor(self, rhs: Point) -> BBox {
    method bitor_assign (line 139) | fn bitor_assign(&mut self, rhs: Point) {
  type Output (line 102) | type Output = BBox;
  method bitor (line 104) | fn bitor(self, rhs: BBox) -> BBox {
  method bitor_assign (line 117) | fn bitor_assign(&mut self, rhs: BBox) {
  method lerp (line 145) | fn lerp(self, other: BBox, alpha: f32) -> BBox {
  function transform_bbox_slice_from (line 153) | pub fn transform_bbox_slice_from(bbs_in: &[BBox], xforms: &[Transform], ...

FILE: src/bbox4.rs
  constant BBOX_MAXT_ADJUST (line 14) | const BBOX_MAXT_ADJUST: f32 = 1.000_000_24;
  type BBox4 (line 18) | pub struct BBox4 {
    method new (line 26) | pub fn new() -> BBox4 {
    method from_bboxes (line 45) | pub fn from_bboxes(b1: BBox, b2: BBox, b3: BBox, b4: BBox) -> BBox4 {
    method intersect_ray (line 63) | pub fn intersect_ray(&self, orig: Point, dir_inv: Vector, max_t: f32) ...
  type Output (line 102) | type Output = BBox4;
  method bitor (line 104) | fn bitor(self, rhs: BBox4) -> BBox4 {
  method bitor_assign (line 114) | fn bitor_assign(&mut self, rhs: BBox4) {
  method lerp (line 120) | fn lerp(self, other: BBox4, alpha: f32) -> BBox4 {

FILE: src/boundable.rs
  type Boundable (line 5) | pub trait Boundable {
    method bounds (line 6) | fn bounds(&self) -> &[BBox];

FILE: src/camera.rs
  type Camera (line 13) | pub struct Camera<'a> {
  function new (line 22) | pub fn new(
  function generate_ray (line 74) | pub fn generate_ray(&self, x: f32, y: f32, time: f32, wavelength: f32, u...

FILE: src/color.rs
  constant WL_MIN (line 15) | const WL_MIN: f32 = 380.0;
  constant WL_MAX (line 16) | const WL_MAX: f32 = 700.0;
  constant WL_RANGE (line 17) | const WL_RANGE: f32 = WL_MAX - WL_MIN;
  constant WL_RANGE_Q (line 18) | const WL_RANGE_Q: f32 = WL_RANGE / 4.0;
  function map_0_1_to_wavelength (line 20) | pub fn map_0_1_to_wavelength(n: f32) -> f32 {
  function nth_wavelength (line 25) | fn nth_wavelength(hero_wavelength: f32, n: usize) -> f32 {
  function wavelengths (line 36) | fn wavelengths(hero_wavelength: f32) -> Vec4 {
  type Color (line 48) | pub enum Color {
    method new_xyz (line 64) | pub fn new_xyz(xyz: (f32, f32, f32)) -> Self {
    method new_blackbody (line 69) | pub fn new_blackbody(temp: f32, fac: f32) -> Self {
    method new_temperature (line 77) | pub fn new_temperature(temp: f32, fac: f32) -> Self {
    method to_spectral_sample (line 84) | pub fn to_spectral_sample(self, hero_wavelength: f32) -> SpectralSample {
    method approximate_energy (line 127) | pub fn approximate_energy(self) -> f32 {
    method compressed_size (line 145) | pub fn compressed_size(&self) -> usize {
    method write_compressed (line 161) | pub fn write_compressed(&self, out_data: &mut [u8]) -> usize {
    method from_compressed (line 199) | pub fn from_compressed(in_data: &[u8]) -> (Color, usize) {
    type Output (line 253) | type Output = Self;
    method mul (line 255) | fn mul(self, rhs: f32) -> Self {
    method mul_assign (line 279) | fn mul_assign(&mut self, rhs: f32) {
  method lerp (line 294) | fn lerp(self, other: Self, alpha: f32) -> Self {
  function plancks_law (line 336) | fn plancks_law(temperature: f32, wavelength: f32) -> f32 {
  function plancks_law_normalized (line 380) | fn plancks_law_normalized(temperature: f32, wavelength: f32) -> f32 {
  type SpectralSample (line 388) | pub struct SpectralSample {
    method new (line 394) | pub fn new(wavelength: f32) -> SpectralSample {
    method from_value (line 403) | pub fn from_value(value: f32, wavelength: f32) -> SpectralSample {
    method from_parts (line 411) | pub fn from_parts(e: Vec4, wavelength: f32) -> SpectralSample {
    method wl_n (line 420) | fn wl_n(&self, n: usize) -> f32 {
    type Output (line 467) | type Output = SpectralSample;
    method mul (line 468) | fn mul(self, rhs: f32) -> Self::Output {
    method mul_assign (line 477) | fn mul_assign(&mut self, rhs: f32) {
    type Output (line 483) | type Output = SpectralSample;
    method div (line 484) | fn div(self, rhs: f32) -> Self::Output {
    method div_assign (line 493) | fn div_assign(&mut self, rhs: f32) {
  type Output (line 431) | type Output = SpectralSample;
  method add (line 432) | fn add(self, rhs: SpectralSample) -> Self::Output {
  method add_assign (line 442) | fn add_assign(&mut self, rhs: SpectralSample) {
  type Output (line 449) | type Output = SpectralSample;
  method mul (line 450) | fn mul(self, rhs: SpectralSample) -> Self::Output {
  method mul_assign (line 460) | fn mul_assign(&mut self, rhs: SpectralSample) {
  type XYZ (line 501) | pub struct XYZ {
    method new (line 508) | pub fn new(x: f32, y: f32, z: f32) -> XYZ {
    method from_wavelength (line 512) | pub fn from_wavelength(wavelength: f32, intensity: f32) -> XYZ {
    method from_spectral_sample (line 520) | pub fn from_spectral_sample(ss: &SpectralSample) -> XYZ {
    method to_tuple (line 528) | pub fn to_tuple(&self) -> (f32, f32, f32) {
    type Output (line 559) | type Output = XYZ;
    method mul (line 560) | fn mul(self, rhs: f32) -> Self::Output {
    method mul_assign (line 570) | fn mul_assign(&mut self, rhs: f32) {
    type Output (line 578) | type Output = XYZ;
    method div (line 579) | fn div(self, rhs: f32) -> Self::Output {
    method div_assign (line 589) | fn div_assign(&mut self, rhs: f32) {
  method lerp (line 534) | fn lerp(self, other: XYZ, alpha: f32) -> XYZ {
  type Output (line 540) | type Output = XYZ;
  method add (line 541) | fn add(self, rhs: XYZ) -> Self::Output {
  method add_assign (line 551) | fn add_assign(&mut self, rhs: XYZ) {
  function xyz_to_spectrum_4 (line 602) | fn xyz_to_spectrum_4(xyz: (f32, f32, f32), wavelengths: Vec4) -> Vec4 {
  function x_1931 (line 610) | pub fn x_1931(wavelength: f32) -> f32 {
  function y_1931 (line 618) | pub fn y_1931(wavelength: f32) -> f32 {
  function z_1931 (line 624) | pub fn z_1931(wavelength: f32) -> f32 {

FILE: src/fp_utils.rs
  function fp_gamma (line 9) | pub fn fp_gamma(n: u32) -> f32 {
  function increment_ulp (line 15) | pub fn increment_ulp(v: f32) -> f32 {
  function decrement_ulp (line 30) | pub fn decrement_ulp(v: f32) -> f32 {
  function robust_ray_origin (line 45) | pub fn robust_ray_origin(pos: Point, pos_err: f32, nor: Normal, ray_dir:...
  function inc_ulp (line 89) | fn inc_ulp() {
  function dec_ulp (line 95) | fn dec_ulp() {
  function inc_ulp_zero (line 101) | fn inc_ulp_zero() {
  function dec_ulp_zero (line 109) | fn dec_ulp_zero() {
  function inc_dec_ulp (line 117) | fn inc_dec_ulp() {
  function dec_inc_ulp (line 125) | fn dec_inc_ulp() {

FILE: src/hash.rs
  function hash_u32 (line 1) | pub fn hash_u32(n: u32, seed: u32) -> u32 {
  function hash_u64 (line 12) | pub fn hash_u64(n: u64, seed: u64) -> u64 {
  function hash_u32_to_f32 (line 26) | pub fn hash_u32_to_f32(n: u32, seed: u32) -> f32 {

FILE: src/hilbert.rs
  constant N (line 3) | const N: u32 = 1 << 16;
  function hil_rot (line 6) | fn hil_rot(n: u32, rx: u32, ry: u32, x: &mut u32, y: &mut u32) {
  function xy2d (line 23) | pub fn xy2d(x: u32, y: u32) -> u32 {
  function d2xy (line 47) | pub fn d2xy(d: u32) -> (u32, u32) {
  function reversible (line 70) | fn reversible() {

FILE: src/image.rs
  type Image (line 20) | pub struct Image {
    method new (line 29) | pub fn new(width: usize, height: usize) -> Image {
    method width (line 37) | pub fn width(&self) -> usize {
    method height (line 41) | pub fn height(&self) -> usize {
    method get (line 45) | pub fn get(&mut self, x: usize, y: usize) -> XYZ {
    method set (line 53) | pub fn set(&mut self, x: usize, y: usize, value: XYZ) {
    method get_bucket (line 61) | pub fn get_bucket<'a>(&'a self, min: (u32, u32), max: (u32, u32)) -> B...
    method write_ascii_ppm (line 98) | pub fn write_ascii_ppm(&mut self, path: &Path) -> io::Result<()> {
    method write_binary_ppm (line 118) | pub fn write_binary_ppm(&mut self, path: &Path) -> io::Result<()> {
    method write_png (line 138) | pub fn write_png(&mut self, path: &Path) -> io::Result<()> {
    method write_exr (line 167) | pub fn write_exr(&mut self, path: &Path) {
  type Bucket (line 199) | pub struct Bucket<'a> {
  function get (line 207) | pub fn get(&mut self, x: u32, y: u32) -> XYZ {
  function set (line 217) | pub fn set(&mut self, x: u32, y: u32, value: XYZ) {
  function rgba_base64 (line 235) | pub fn rgba_base64<F>(&mut self, color_convert: F) -> String
  method drop (line 259) | fn drop(&mut self) {
  function srgb_gamma (line 275) | fn srgb_gamma(n: f32) -> f32 {
  function srgb_inv_gamma (line 283) | fn srgb_inv_gamma(n: f32) -> f32 {
  function xyz_to_srgbe (line 291) | fn xyz_to_srgbe(xyz: (f32, f32, f32)) -> (f32, f32, f32) {
  function quantize_tri_255 (line 296) | fn quantize_tri_255(tri: (f32, f32, f32)) -> (u8, u8, u8) {

FILE: src/lerp.rs
  type Lerp (line 6) | pub trait Lerp: Copy {
    method lerp (line 7) | fn lerp(self, other: Self, alpha: f32) -> Self;
    method lerp (line 59) | fn lerp(self, other: f32, alpha: f32) -> f32 {
    method lerp (line 65) | fn lerp(self, other: f64, alpha: f32) -> f64 {
    method lerp (line 71) | fn lerp(self, other: (T, T), alpha: f32) -> (T, T) {
    method lerp (line 77) | fn lerp(self, other: Self, alpha: f32) -> Self {
    method lerp (line 83) | fn lerp(self, other: Self, alpha: f32) -> Self {
    method lerp (line 93) | fn lerp(self, other: Self, alpha: f32) -> Self {
    method lerp (line 104) | fn lerp(self, other: glam::Vec4, alpha: f32) -> glam::Vec4 {
    method lerp (line 110) | fn lerp(self, other: Transform, alpha: f32) -> Transform {
    method lerp (line 116) | fn lerp(self, other: Normal, alpha: f32) -> Normal {
    method lerp (line 122) | fn lerp(self, other: Point, alpha: f32) -> Point {
    method lerp (line 132) | fn lerp(self, other: Vector, alpha: f32) -> Vector {
  function lerp (line 11) | pub fn lerp<T: Lerp>(a: T, b: T, alpha: f32) -> T {
  function lerp_slice (line 20) | pub fn lerp_slice<T: Lerp>(s: &[T], alpha: f32) -> T {
  function lerp_slice_with (line 37) | pub fn lerp_slice_with<T, F>(s: &[T], alpha: f32, f: F) -> T
  function lerp1 (line 142) | fn lerp1() {
  function lerp2 (line 151) | fn lerp2() {
  function lerp3 (line 160) | fn lerp3() {
  function lerp_slice1 (line 169) | fn lerp_slice1() {
  function lerp_slice2 (line 177) | fn lerp_slice2() {
  function lerp_slice3 (line 185) | fn lerp_slice3() {
  function lerp_slice4 (line 193) | fn lerp_slice4() {
  function lerp_slice5 (line 201) | fn lerp_slice5() {
  function lerp_slice6 (line 209) | fn lerp_slice6() {
  function lerp_matrix (line 217) | fn lerp_matrix() {
  function lerp_point_1 (line 243) | fn lerp_point_1() {
  function lerp_point_2 (line 252) | fn lerp_point_2() {
  function lerp_point_3 (line 261) | fn lerp_point_3() {
  function lerp_normal_1 (line 270) | fn lerp_normal_1() {
  function lerp_normal_2 (line 279) | fn lerp_normal_2() {
  function lerp_normal_3 (line 288) | fn lerp_normal_3() {
  function lerp_vector_1 (line 297) | fn lerp_vector_1() {
  function lerp_vector_2 (line 306) | fn lerp_vector_2() {
  function lerp_vector_3 (line 315) | fn lerp_vector_3() {

FILE: src/light/distant_disk_light.rs
  type DistantDiskLight (line 17) | pub struct DistantDiskLight<'a> {
  function new (line 24) | pub fn new(
  method sample_from_point (line 59) | fn sample_from_point(
  method is_delta (line 87) | fn is_delta(&self) -> bool {
  method approximate_energy (line 91) | fn approximate_energy(&self) -> f32 {

FILE: src/light/mod.rs
  type SurfaceLight (line 19) | pub trait SurfaceLight: Surface {
    method sample_from_point (line 35) | fn sample_from_point(
    method is_delta (line 50) | fn is_delta(&self) -> bool;
    method approximate_energy (line 57) | fn approximate_energy(&self) -> f32;
  type WorldLightSource (line 62) | pub trait WorldLightSource: Debug + Sync {
    method sample_from_point (line 72) | fn sample_from_point(
    method is_delta (line 85) | fn is_delta(&self) -> bool;
    method approximate_energy (line 93) | fn approximate_energy(&self) -> f32;

FILE: src/light/rectangle_light.rs
  constant SIMPLE_SAMPLING_THRESHOLD (line 21) | const SIMPLE_SAMPLING_THRESHOLD: f32 = 0.01;
  type RectangleLight (line 24) | pub struct RectangleLight<'a> {
  function new (line 31) | pub fn new<'b>(
  function sample_pdf (line 52) | fn sample_pdf(
  method sample_from_point (line 121) | fn sample_from_point(
  method is_delta (line 245) | fn is_delta(&self) -> bool {
  method approximate_energy (line 249) | fn approximate_energy(&self) -> f32 {
  method intersect_rays (line 258) | fn intersect_rays(
  method bounds (line 341) | fn bounds(&self) -> &[BBox] {

FILE: src/light/sphere_light.rs
  constant SAMPLE_POINT_FUDGE (line 22) | const SAMPLE_POINT_FUDGE: f32 = 0.001;
  type SphereLight (line 27) | pub struct SphereLight<'a> {
  function new (line 34) | pub fn new<'b>(arena: &'b Arena, radii: &[f32], colors: &[Color]) -> Sph...
  function sample_pdf (line 51) | fn sample_pdf(
  method sample_from_point (line 85) | fn sample_from_point(
  method is_delta (line 194) | fn is_delta(&self) -> bool {
  method approximate_energy (line 198) | fn approximate_energy(&self) -> f32 {
  method intersect_rays (line 207) | fn intersect_rays(
  method bounds (line 342) | fn bounds(&self) -> &[BBox] {

FILE: src/main.rs
  constant VERSION (line 59) | const VERSION: &str = env!("CARGO_PKG_VERSION");
  function main (line 62) | fn main() {

FILE: src/math.rs
  function log2_64 (line 8) | pub fn log2_64(n: u64) -> u64 {
  function coordinate_system_from_vector (line 26) | pub fn coordinate_system_from_vector(v: Vector) -> (Vector, Vector, Vect...
  function zup_to_vec (line 47) | pub fn zup_to_vec(from: Vector, toz: Vector) -> Vector {
  function probit (line 67) | pub fn probit(n: f32, width: f32) -> f32 {
  function fast_ln (line 134) | pub fn fast_ln(x: f32) -> f32 {
  function fast_pow2 (line 138) | pub fn fast_pow2(p: f32) -> f32 {
  function fast_log2 (line 142) | pub fn fast_log2(x: f32) -> f32 {
  function fast_exp (line 146) | pub fn fast_exp(p: f32) -> f32 {
  function fast_pow (line 150) | pub fn fast_pow(x: f32, p: f32) -> f32 {
  function faster_pow2 (line 154) | pub fn faster_pow2(p: f32) -> f32 {
  function faster_exp (line 158) | pub fn faster_exp(p: f32) -> f32 {
  function log2_64_test (line 169) | fn log2_64_test() {

FILE: src/mis.rs
  function balance_heuristic (line 3) | pub fn balance_heuristic(a: f32, b: f32) -> f32 {
  function power_heuristic (line 12) | pub fn power_heuristic(a: f32, b: f32) -> f32 {

FILE: src/parse/basics.rs
  function ws_f32 (line 16) | pub fn ws_f32(input: &str) -> IResult<&str, f32, ()> {
  function ws_u32 (line 20) | pub fn ws_u32(input: &str) -> IResult<&str, u32, ()> {
  function ws_usize (line 24) | pub fn ws_usize(input: &str) -> IResult<&str, usize, ()> {
  function ws_i32 (line 28) | pub fn ws_i32(input: &str) -> IResult<&str, i32, ()> {
  function ws_u32_1 (line 47) | fn ws_u32_1() {
  function ws_usize_1 (line 56) | fn ws_usize_1() {
  function ws_i32_1 (line 65) | fn ws_i32_1() {
  function ws_i32_2 (line 74) | fn ws_i32_2() {
  function ws_f32_1 (line 84) | fn ws_f32_1() {
  function ws_f32_2 (line 93) | fn ws_f32_2() {
  function ws_f32_3 (line 102) | fn ws_f32_3() {
  function ws_f32_4 (line 111) | fn ws_f32_4() {

FILE: src/parse/data_tree.rs
  type DataTree (line 6) | pub enum DataTree<'a> {
  function from_str (line 22) | pub fn from_str(source_text: &'a str) -> Result<DataTree<'a>, ParseError> {
  function type_name (line 46) | pub fn type_name(&'a self) -> &'a str {
  function byte_offset (line 52) | pub fn byte_offset(&'a self) -> usize {
  function is_internal (line 60) | pub fn is_internal(&self) -> bool {
  function is_leaf (line 67) | pub fn is_leaf(&self) -> bool {
  function leaf_contents (line 74) | pub fn leaf_contents(&'a self) -> Option<&'a str> {
  function iter_children (line 81) | pub fn iter_children(&'a self) -> slice::Iter<'a, DataTree<'a>> {
  function iter_children_with_type (line 89) | pub fn iter_children_with_type(&'a self, type_name: &'static str) -> Dat...
  function iter_internal_children_with_type (line 103) | pub fn iter_internal_children_with_type(
  function iter_leaf_children_with_type (line 120) | pub fn iter_leaf_children_with_type(
  function internal_data_or_panic (line 138) | fn internal_data_or_panic(&'a self) -> (&'a str, Option<&'a str>, &'a Ve...
  function leaf_data_or_panic (line 151) | fn leaf_data_or_panic(&'a self) -> (&'a str, &'a str) {
  type DataTreeFilterIter (line 167) | pub struct DataTreeFilterIter<'a> {
  type Item (line 173) | type Item = &'a DataTree<'a>;
  method next (line 175) | fn next(&mut self) -> Option<&'a DataTree<'a>> {
  type DataTreeFilterInternalIter (line 193) | pub struct DataTreeFilterInternalIter<'a> {
  type Item (line 199) | type Item = (&'a str, Option<&'a str>, &'a Vec<DataTree<'a>>, usize);
  method next (line 201) | fn next(&mut self) -> Option<(&'a str, Option<&'a str>, &'a Vec<DataTree...
  type DataTreeFilterLeafIter (line 232) | pub struct DataTreeFilterLeafIter<'a> {
  type Item (line 238) | type Item = (&'a str, &'a str, usize);
  method next (line 240) | fn next(&mut self) -> Option<(&'a str, &'a str, usize)> {
  type ParseError (line 268) | pub enum ParseError {
  type Token (line 283) | enum Token<'a> {
  type ParseResult (line 294) | type ParseResult<'a> = Result<Option<(DataTree<'a>, (usize, &'a str))>, ...
  function parse_node (line 296) | fn parse_node<'a>(source_text: (usize, &'a str)) -> ParseResult<'a> {
  function parse_leaf_content (line 378) | fn parse_leaf_content(source_text: (usize, &str)) -> (&str, (usize, &str...
  function next_token (line 404) | fn next_token<'a>(source_text: (usize, &'a str)) -> (Token<'a>, (usize, ...
  function is_ws (line 484) | fn is_ws(c: char) -> bool {
  function is_nl (line 491) | fn is_nl(c: char) -> bool {
  function is_reserved_char (line 498) | fn is_reserved_char(c: char) -> bool {
  function is_ident_char (line 505) | fn is_ident_char(c: char) -> bool {
  function skip_ws (line 510) | fn skip_ws(text: &str) -> &str {
  function skip_comment (line 528) | fn skip_comment(text: &str) -> &str {
  function skip_ws_and_comments (line 548) | fn skip_ws_and_comments(text: (usize, &str)) -> (usize, &str) {
  function tokenize_1 (line 573) | fn tokenize_1() {
  function tokenize_2 (line 580) | fn tokenize_2() {
  function tokenize_3 (line 587) | fn tokenize_3() {
  function tokenize_4 (line 599) | fn tokenize_4() {
  function tokenize_5 (line 606) | fn tokenize_5() {
  function tokenize_6 (line 616) | fn tokenize_6() {
  function tokenize_7 (line 632) | fn tokenize_7() {
  function parse_1 (line 672) | fn parse_1() {
  function iter_1 (line 693) | fn iter_1() {
  function iter_2 (line 710) | fn iter_2() {
  function iter_3 (line 727) | fn iter_3() {

FILE: src/parse/psy.rs
  type PsyParseError (line 27) | pub enum PsyParseError {
    method print (line 41) | pub fn print(&self, psy_content: &str) {
  function line_count_to_byte_offset (line 90) | fn line_count_to_byte_offset(text: &str, offset: usize) -> usize {
  function parse_scene (line 95) | pub fn parse_scene<'a>(
  function parse_output_info (line 202) | fn parse_output_info(tree: &DataTree) -> Result<String, PsyParseError> {
  function parse_render_settings (line 260) | fn parse_render_settings(tree: &DataTree) -> Result<((u32, u32), u32, u3...
  function parse_camera (line 353) | fn parse_camera<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result<Came...
  function parse_world (line 455) | fn parse_world<'a>(arena: &'a Arena, tree: &'a DataTree) -> Result<World...
  function parse_matrix (line 556) | pub fn parse_matrix(contents: &str) -> Result<Transform, PsyParseError> {
  function make_transform_format_error (line 574) | pub fn make_transform_format_error(byte_offset: usize) -> PsyParseError {
  function parse_color (line 582) | pub fn parse_color(contents: &str) -> Result<Color, PsyParseError> {

FILE: src/parse/psy_assembly.rs
  function parse_assembly (line 17) | pub fn parse_assembly<'a>(

FILE: src/parse/psy_light.rs
  function parse_distant_disk_light (line 20) | pub fn parse_distant_disk_light<'a>(
  function parse_sphere_light (line 86) | pub fn parse_sphere_light<'a>(
  function parse_rectangle_light (line 135) | pub fn parse_rectangle_light<'a>(

FILE: src/parse/psy_mesh_surface.rs
  function parse_mesh_surface (line 27) | pub fn parse_mesh_surface<'a>(

FILE: src/parse/psy_surface_shader.rs
  function parse_surface_shader (line 24) | pub fn parse_surface_shader<'a>(

FILE: src/ray.rs
  type RayIndexType (line 7) | type RayIndexType = u16;
  type FlagType (line 8) | type FlagType = u8;
  constant OCCLUSION_FLAG (line 9) | const OCCLUSION_FLAG: FlagType = 1;
  constant DONE_FLAG (line 10) | const DONE_FLAG: FlagType = 1 << 1;
  type Ray (line 15) | pub struct Ray {
  type RayHot (line 25) | struct RayHot {
  type RayCold (line 35) | struct RayCold {
  type RayBatch (line 43) | pub struct RayBatch {
    method new (line 50) | pub fn new() -> RayBatch {
    method with_capacity (line 59) | pub fn with_capacity(n: usize) -> RayBatch {
    method push (line 66) | pub fn push(&mut self, ray: Ray, is_occlusion: bool) {
    method swap (line 81) | pub fn swap(&mut self, a: usize, b: usize) {
    method set_from_ray (line 86) | pub fn set_from_ray(&mut self, ray: &Ray, is_occlusion: bool, idx: usi...
    method truncate (line 100) | pub fn truncate(&mut self, len: usize) {
    method clear (line 108) | pub fn clear(&mut self) {
    method len (line 113) | pub fn len(&self) -> usize {
    method update_local (line 122) | pub fn update_local(&mut self, idx: usize, xform: &Transform) {
    method orig (line 133) | pub fn orig(&self, idx: usize) -> Point {
    method dir (line 138) | pub fn dir(&self, idx: usize) -> Vector {
    method orig_local (line 143) | pub fn orig_local(&self, idx: usize) -> Point {
    method dir_inv_local (line 148) | pub fn dir_inv_local(&self, idx: usize) -> Vector {
    method time (line 153) | pub fn time(&self, idx: usize) -> f32 {
    method max_t (line 158) | pub fn max_t(&self, idx: usize) -> f32 {
    method set_max_t (line 163) | pub fn set_max_t(&mut self, idx: usize, new_max_t: f32) {
    method wavelength (line 168) | pub fn wavelength(&self, idx: usize) -> f32 {
    method is_occlusion (line 174) | pub fn is_occlusion(&self, idx: usize) -> bool {
    method is_done (line 180) | pub fn is_done(&self, idx: usize) -> bool {
    method mark_occlusion (line 186) | pub fn mark_occlusion(&mut self, idx: usize) {
    method mark_done (line 192) | pub fn mark_done(&mut self, idx: usize) {
  type RayStack (line 199) | pub struct RayStack {
    method new (line 205) | pub fn new() -> RayStack {
    method is_empty (line 213) | pub fn is_empty(&self) -> bool {
    method ensure_lane_count (line 218) | pub fn ensure_lane_count(&mut self, count: usize) {
    method ray_count_in_next_task (line 227) | pub fn ray_count_in_next_task(&self) -> usize {
    method next_task_ray_idx (line 233) | pub fn next_task_ray_idx(&self, i: usize) -> usize {
    method clear (line 247) | pub fn clear(&mut self) {
    method push_ray_index (line 257) | pub fn push_ray_index(&mut self, ray_idx: usize, lane: usize) {
    method push_lane_to_task (line 267) | pub fn push_lane_to_task(&mut self, lane_idx: usize) -> bool {
    method push_lanes_to_tasks (line 282) | pub fn push_lanes_to_tasks(&mut self, lane_idxs: &[usize]) {
    method duplicate_next_task (line 288) | pub fn duplicate_next_task(&mut self) {
    method pop_task (line 315) | pub fn pop_task(&mut self) {
    method do_next_task (line 322) | pub fn do_next_task<F>(&mut self, mut handle_ray: F)
    method pop_do_next_task (line 339) | pub fn pop_do_next_task<F>(&mut self, handle_ray: F)
    method pop_do_next_task_and_push_rays (line 350) | pub fn pop_do_next_task_and_push_rays<F>(&mut self, output_lane_count:...
  type Lane (line 387) | struct Lane {
  type RayTask (line 398) | struct RayTask {

FILE: src/renderer.rs
  type Renderer (line 32) | pub struct Renderer<'a> {
  type RenderStats (line 41) | pub struct RenderStats {
    method new (line 52) | fn new() -> RenderStats {
    method collect (line 64) | fn collect(&mut self, other: RenderStats) {
  function render (line 76) | pub fn render(
  function render_job (line 194) | fn render_job(
  type LightPathEvent (line 363) | enum LightPathEvent {
  type LightPath (line 370) | pub struct LightPath {
    method new (line 392) | fn new(
    method next_lds_sequence (line 433) | fn next_lds_sequence(&mut self) {
    method next_lds_samp (line 438) | fn next_lds_samp(&mut self) -> (f32, f32, f32, f32) {
    method next (line 449) | fn next(
  function get_sample_4d (line 698) | fn get_sample_4d(
  function golden_ratio_sample (line 728) | fn golden_ratio_sample(i: u32, scramble: u32) -> f32 {
  type BucketJob (line 740) | struct BucketJob {

FILE: src/sampling/monte_carlo.rs
  function square_to_circle (line 10) | pub fn square_to_circle(x: f32, y: f32) -> (f32, f32) {
  function cosine_sample_hemisphere (line 34) | pub fn cosine_sample_hemisphere(u: f32, v: f32) -> Vector {
  function uniform_sample_hemisphere (line 40) | pub fn uniform_sample_hemisphere(u: f32, v: f32) -> Vector {
  function uniform_sample_sphere (line 49) | pub fn uniform_sample_sphere(u: f32, v: f32) -> Vector {
  function uniform_sample_cone (line 64) | pub fn uniform_sample_cone(u: f32, v: f32, cos_theta_max: f64) -> Vector {
  function uniform_sample_cone_pdf (line 75) | pub fn uniform_sample_cone_pdf(cos_theta_max: f64) -> f64 {
  function uniform_sample_triangle (line 82) | pub fn uniform_sample_triangle(va: Vector, vb: Vector, vc: Vector, i: f3...
  function triangle_surface_area (line 92) | pub fn triangle_surface_area(p0: Point, p1: Point, p2: Point) -> f32 {
  function spherical_triangle_solid_angle (line 99) | pub fn spherical_triangle_solid_angle(va: Vector, vb: Vector, vc: Vector...
  function uniform_sample_spherical_triangle (line 136) | pub fn uniform_sample_spherical_triangle(

FILE: src/scene/assembly.rs
  type Assembly (line 20) | pub struct Assembly<'a> {
  function sample_lights (line 46) | pub fn sample_lights(
  method bounds (line 144) | fn bounds(&self) -> &[BBox] {
  type AssemblyBuilder (line 150) | pub struct AssemblyBuilder<'a> {
  function new (line 171) | pub fn new(arena: &'a Arena) -> AssemblyBuilder<'a> {
  function add_surface_shader (line 185) | pub fn add_surface_shader(&mut self, name: &str, shader: &'a dyn Surface...
  function add_object (line 197) | pub fn add_object(&mut self, name: &str, obj: Object<'a>) {
  function add_assembly (line 208) | pub fn add_assembly(&mut self, name: &str, asmb: Assembly<'a>) {
  function add_instance (line 223) | pub fn add_instance(
  function name_exists (line 284) | pub fn name_exists(&self, name: &str) -> bool {
  function build (line 288) | pub fn build(mut self) -> Assembly<'a> {
  function instance_bounds (line 354) | fn instance_bounds(&self) -> (Vec<usize>, Vec<BBox>) {
  type Object (line 399) | pub enum Object<'a> {
  type Instance (line 405) | pub struct Instance {
  type InstanceType (line 414) | pub enum InstanceType {

FILE: src/scene/mod.rs
  type Scene (line 20) | pub struct Scene<'a> {
  function sample_lights (line 28) | pub fn sample_lights(
  type SceneLightSample (line 103) | pub enum SceneLightSample {
    method is_none (line 120) | pub fn is_none(&self) -> bool {
    method color (line 128) | pub fn color(&self) -> SpectralSample {
    method pdf (line 136) | pub fn pdf(&self) -> f32 {
    method selection_pdf (line 144) | pub fn selection_pdf(&self) -> f32 {

FILE: src/scene/world.rs
  type World (line 4) | pub struct World<'a> {

FILE: src/shading/mod.rs
  type SurfaceShader (line 10) | pub trait SurfaceShader: Debug + Sync {
    method shade (line 13) | fn shade(&self, data: &SurfaceIntersectionData, time: f32) -> SurfaceC...
    method shade (line 43) | fn shade(&self, data: &SurfaceIntersectionData, time: f32) -> SurfaceC...
  type SimpleSurfaceShader (line 28) | pub enum SimpleSurfaceShader {

FILE: src/shading/surface_closure.rs
  constant INV_PI (line 14) | const INV_PI: f32 = 1.0 / PI_32;
  constant H_PI (line 15) | const H_PI: f32 = PI_32 / 2.0;
  type SurfaceClosure (line 19) | pub enum SurfaceClosure {
    method is_delta (line 39) | pub fn is_delta(&self) -> bool {
    method sample (line 57) | pub fn sample(
    method evaluate (line 88) | pub fn evaluate(
    method estimate_eval_over_sphere_light (line 115) | pub fn estimate_eval_over_sphere_light(
    method compressed_size (line 158) | pub fn compressed_size(&self) -> usize {
    method write_compressed (line 176) | pub fn write_compressed(&self, out_data: &mut [u8]) -> usize {
    method from_compressed (line 213) | pub fn from_compressed(in_data: &[u8]) -> (SurfaceClosure, usize) {
  method lerp (line 254) | fn lerp(self, other: SurfaceClosure, alpha: f32) -> SurfaceClosure {
  function sample (line 284) | pub fn sample(
  function evaluate (line 312) | pub fn evaluate(
  function estimate_eval_over_sphere_light (line 334) | pub fn estimate_eval_over_sphere_light(
  function validate (line 415) | pub fn validate(roughness: f32, fresnel: f32) {
  function sample (line 420) | pub fn sample(
  function evaluate (line 456) | pub fn evaluate(
  function estimate_eval_over_sphere_light (line 535) | pub fn estimate_eval_over_sphere_light(
  function half_theta_sample (line 597) | fn half_theta_sample(u: f32, rough: f32) -> f32 {
  function ggx_d (line 612) | fn ggx_d(nh: f32, rough: f32) -> f32 {
  function ggx_g (line 626) | fn ggx_g(vh: f32, vn: f32, rough: f32) -> f32 {
  function sample (line 642) | pub fn sample(
  function evaluate (line 659) | pub fn evaluate(
  function estimate_eval_over_sphere_light (line 672) | pub fn estimate_eval_over_sphere_light(
  function dielectric_fresnel_from_fac (line 696) | fn dielectric_fresnel_from_fac(fresnel_fac: f32, c: f32) -> f32 {
  function schlick_fresnel_from_fac (line 714) | fn schlick_fresnel_from_fac(frensel_fac: f32, c: f32) -> f32 {
  function dielectric_fresnel (line 729) | fn dielectric_fresnel(ior_ratio: f32, c: f32) -> f32 {
  function schlick_fresnel (line 747) | fn schlick_fresnel(ior_ratio: f32, c: f32) -> f32 {

FILE: src/surface/bilinear_patch.rs
  type BilinearPatch (line 8) | pub struct BilinearPatch<'a> {
  function bilerp_point (line 29) | fn bilerp_point(patch: [Point; 4], uv: (f32, f32)) -> Point {
  type BilinearSubPatch (line 36) | pub struct BilinearSubPatch<'a> {
  method split (line 43) | fn split<F>(&self, metric: F) -> Option<(Self, Self)>

FILE: src/surface/micropoly_batch.rs
  constant MAX_LEAF_TRIANGLE_COUNT (line 19) | const MAX_LEAF_TRIANGLE_COUNT: usize = 3;
  type MicropolyBatch (line 28) | pub struct MicropolyBatch<'a> {
  function from_verts_and_indices (line 49) | pub fn from_verts_and_indices<'b>(
  method bounds (line 142) | fn bounds(&self) -> &[BBox] {
  function intersect_rays (line 148) | fn intersect_rays(

FILE: src/surface/mod.rs
  constant MAX_EDGE_DICE (line 19) | const MAX_EDGE_DICE: u32 = 128;
  type Surface (line 21) | pub trait Surface: Boundable + Debug + Sync {
    method intersect_rays (line 22) | fn intersect_rays(
  type Splitable (line 32) | pub trait Splitable: Copy {
    method split (line 34) | fn split<F>(&self, metric: F) -> Option<(Self, Self)>
  type PointOrder (line 40) | pub enum PointOrder {
  function point_order (line 45) | pub fn point_order(p1: Point, p2: Point) -> PointOrder {
  type SurfaceIntersection (line 72) | pub enum SurfaceIntersection {
  type SurfaceIntersectionData (line 82) | pub struct SurfaceIntersectionData {

FILE: src/surface/triangle.rs
  type RayTriPrecompute (line 9) | pub struct RayTriPrecompute {
    method new (line 15) | pub fn new(ray_dir: Vector) -> RayTriPrecompute {
  function intersect_ray (line 58) | pub fn intersect_ray(
  function surface_point (line 155) | pub fn surface_point(tri: (Point, Point, Point), bary: (f32, f32, f32)) ...
  function max_abs_3 (line 171) | fn max_abs_3(a: f32, b: f32, c: f32) -> f32 {

FILE: src/surface/triangle_mesh.rs
  constant MAX_LEAF_TRIANGLE_COUNT (line 17) | const MAX_LEAF_TRIANGLE_COUNT: usize = 3;
  type TriangleMesh (line 20) | pub struct TriangleMesh<'a> {
  function from_verts_and_indices (line 29) | pub fn from_verts_and_indices<'b>(
  method bounds (line 119) | fn bounds(&self) -> &[BBox] {
  method intersect_rays (line 125) | fn intersect_rays(

FILE: src/timer.rs
  type Timer (line 6) | pub struct Timer {
    method new (line 11) | pub fn new() -> Timer {
    method tick (line 19) | pub fn tick(&mut self) -> f32 {
    method elapsed (line 28) | pub fn elapsed(self) -> f32 {
    method sleep_until (line 34) | pub fn sleep_until(self, n: f32) {

FILE: src/tracer.rs
  type Tracer (line 15) | pub struct Tracer<'a> {
  function from_assembly (line 22) | pub fn from_assembly(assembly: &'a Assembly) -> Tracer<'a> {
  function trace (line 34) | pub fn trace<'b>(&'b mut self, rays: &mut RayBatch) -> &'b [SurfaceInter...
  function rays_traced (line 39) | pub fn rays_traced(&self) -> u64 {
  type TracerInner (line 44) | struct TracerInner<'a> {
  function trace (line 51) | fn trace<'b>(
  function trace_assembly (line 87) | fn trace_assembly<'b>(
  function trace_object (line 152) | fn trace_object<'b>(

FILE: src/transform_stack.rs
  type TransformStack (line 8) | pub struct TransformStack {
    method new (line 14) | pub fn new() -> TransformStack {
    method clear (line 26) | pub fn clear(&mut self) {
    method push (line 33) | pub fn push(&mut self, xforms: &[Transform]) {
    method pop (line 64) | pub fn pop(&mut self) {
    method top (line 76) | pub fn top(&self) -> &[Transform] {

FILE: sub_crates/bvh_order/build.rs
  function main (line 5) | fn main() {

FILE: sub_crates/bvh_order/src/lib.rs
  type SplitAxes (line 20) | pub enum SplitAxes {
  function calc_traversal_code (line 30) | pub fn calc_traversal_code(split: SplitAxes) -> u8 {

FILE: sub_crates/color/build.rs
  type Chromaticities (line 4) | struct Chromaticities {
  function main (line 11) | fn main() {
  function write_conversion_functions (line 72) | fn write_conversion_functions(space_name: &str, chroma: Chromaticities, ...
  function rgb_to_xyz (line 200) | fn rgb_to_xyz(chroma: Chromaticities, y: f64) -> [[f64; 3]; 3] {
  function inverse (line 246) | fn inverse(m: [[f64; 3]; 3]) -> [[f64; 3]; 3] {

FILE: sub_crates/color/src/lib.rs
  type Space (line 6) | pub enum Space {

FILE: sub_crates/compact/benches/bench.rs
  function unsigned32_encode_1000_values (line 11) | fn unsigned32_encode_1000_values(bench: &mut Bencher) {
  function unsigned32_decode_1000_values (line 23) | fn unsigned32_decode_1000_values(bench: &mut Bencher) {
  function unsigned40_encode_1000_values (line 33) | fn unsigned40_encode_1000_values(bench: &mut Bencher) {
  function unsigned40_decode_1000_values (line 45) | fn unsigned40_decode_1000_values(bench: &mut Bencher) {
  function signed48_encode_1000_values (line 61) | fn signed48_encode_1000_values(bench: &mut Bencher) {
  function signed48_decode_1000_values (line 73) | fn signed48_decode_1000_values(bench: &mut Bencher) {
  function fluv32_encode_1000_values (line 90) | fn fluv32_encode_1000_values(bench: &mut Bencher) {
  function fluv32_decode_1000_values (line 102) | fn fluv32_decode_1000_values(bench: &mut Bencher) {
  function fluv32_decode_yuv_1000_values (line 112) | fn fluv32_decode_yuv_1000_values(bench: &mut Bencher) {
  function oct32_encode_1000_values (line 122) | fn oct32_encode_1000_values(bench: &mut Bencher) {
  function oct32_encode_precise_1000_values (line 134) | fn oct32_encode_precise_1000_values(bench: &mut Bencher) {
  function oct32_decode_1000_values (line 146) | fn oct32_decode_1000_values(bench: &mut Bencher) {

FILE: sub_crates/compact/src/fluv/fluv32.rs
  constant EXP_BIAS (line 56) | const EXP_BIAS: i32 = 63;
  constant BIAS_OFFSET (line 57) | const BIAS_OFFSET: u32 = 127 - EXP_BIAS as u32;
  constant U_SCALE (line 60) | pub const U_SCALE: f32 = 817.0 / 2.0;
  constant V_SCALE (line 63) | pub const V_SCALE: f32 = 1235.0 / 3.0;
  constant Y_MAX (line 66) | pub const Y_MAX: f32 = ((1u128 << (128 - EXP_BIAS)) - (1u128 << (128 - E...
  constant Y_MIN (line 69) | pub const Y_MIN: f32 = 1.0 / (1u128 << (EXP_BIAS - 1)) as f32;
  constant Y_EPSILON (line 72) | pub const Y_EPSILON: f32 = 1.0 / 512.0;
  function encode (line 76) | pub fn encode(xyz: (f32, f32, f32)) -> u32 {
  function decode (line 131) | pub fn decode(fluv32: u32) -> (f32, f32, f32) {
  function decode_yuv (line 160) | pub fn decode_yuv(fluv32: u32) -> (f32, u8, u8) {
  function round_trip (line 176) | fn round_trip(floats: (f32, f32, f32)) -> (f32, f32, f32) {
  function all_zeros (line 181) | fn all_zeros() {
  function all_ones (line 192) | fn all_ones() {
  function powers_of_two (line 205) | fn powers_of_two() {
  function accuracy_01 (line 223) | fn accuracy_01() {
  function accuracy_02 (line 242) | fn accuracy_02() {
  function integers (line 253) | fn integers() {
  function precision_floor (line 268) | fn precision_floor() {
  function decode_yuv_01 (line 274) | fn decode_yuv_01() {
  function saturate_y (line 282) | fn saturate_y() {
  function inf_saturate (line 290) | fn inf_saturate() {
  function smallest_value_and_underflow (line 299) | fn smallest_value_and_underflow() {
  function negative_z_impossible (line 310) | fn negative_z_impossible() {
  function nans_01 (line 320) | fn nans_01() {
  function nans_02 (line 326) | fn nans_02() {
  function nans_03 (line 332) | fn nans_03() {
  function negative_01 (line 338) | fn negative_01() {
  function negative_02 (line 344) | fn negative_02() {
  function negative_03 (line 350) | fn negative_03() {
  function negative_04 (line 355) | fn negative_04() {

FILE: sub_crates/compact/src/shared_exp/mod.rs
  function fiddle_exp2 (line 15) | fn fiddle_exp2(exp: i32) -> f32 {
  function fiddle_log2 (line 28) | fn fiddle_log2(n: f32) -> i32 {

FILE: sub_crates/compact/src/shared_exp/signed48.rs
  constant MAX (line 21) | pub const MAX: f32 = ((1u128 << (64 - EXP_BIAS)) - (1 << (64 - EXP_BIAS ...
  constant MIN (line 27) | pub const MIN: f32 = -MAX;
  constant MIN_POSITIVE (line 32) | pub const MIN_POSITIVE: f32 = 1.0 / (1u128 << (EXP_BIAS + 12)) as f32;
  constant EPSILON (line 35) | pub const EPSILON: f32 = 1.0 / 4096.0;
  constant EXP_BIAS (line 37) | const EXP_BIAS: i32 = 26;
  function encode (line 48) | pub fn encode(floats: (f32, f32, f32)) -> [u8; 6] {
  function decode (line 56) | pub fn decode(trifloat: [u8; 6]) -> (f32, f32, f32) {
  function encode_64 (line 62) | fn encode_64(floats: (f32, f32, f32)) -> u64 {
  function decode_64 (line 102) | fn decode_64(trifloat: u64) -> (f32, f32, f32) {
  function u64_to_bytes (line 124) | fn u64_to_bytes(n: u64) -> [u8; 6] {
  function bytes_to_u64 (line 136) | fn bytes_to_u64(a: [u8; 6]) -> u64 {
  function round_trip (line 150) | fn round_trip(floats: (f32, f32, f32)) -> (f32, f32, f32) {
  function all_zeros (line 155) | fn all_zeros() {
  function powers_of_two (line 166) | fn powers_of_two() {
  function signs (line 172) | fn signs() {
  function accuracy (line 193) | fn accuracy() {
  function integers (line 203) | fn integers() {
  function precision_floor (line 211) | fn precision_floor() {
  function saturate (line 219) | fn saturate() {
  function inf_saturate (line 238) | fn inf_saturate() {
  function partial_saturate (line 250) | fn partial_saturate() {
  function smallest_value (line 259) | fn smallest_value() {
  function underflow (line 269) | fn underflow() {
  function garbage_upper_bits_decode (line 276) | fn garbage_upper_bits_decode() {
  function nans_01 (line 292) | fn nans_01() {
  function nans_02 (line 298) | fn nans_02() {
  function nans_03 (line 304) | fn nans_03() {

FILE: sub_crates/compact/src/shared_exp/unsigned32.rs
  constant MAX (line 17) | pub const MAX: f32 = ((1u64 << (32 - EXP_BIAS)) - (1 << (32 - EXP_BIAS -...
  constant MIN (line 20) | pub const MIN: f32 = 1.0 / (1 << (EXP_BIAS + 8)) as f32;
  constant EPSILON (line 23) | pub const EPSILON: f32 = 1.0 / 256.0;
  constant EXP_BIAS (line 25) | const EXP_BIAS: i32 = 11;
  function encode (line 36) | pub fn encode(floats: (f32, f32, f32)) -> u32 {
  function decode (line 71) | pub fn decode(trifloat: u32) -> (f32, f32, f32) {
  function round_trip (line 91) | fn round_trip(floats: (f32, f32, f32)) -> (f32, f32, f32) {
  function all_zeros (line 96) | fn all_zeros() {
  function powers_of_two (line 107) | fn powers_of_two() {
  function accuracy_01 (line 113) | fn accuracy_01() {
  function accuracy_02 (line 124) | fn accuracy_02() {
  function integers (line 134) | fn integers() {
  function precision_floor (line 142) | fn precision_floor() {
  function saturate (line 148) | fn saturate() {
  function inf_saturate (line 156) | fn inf_saturate() {
  function partial_saturate (line 165) | fn partial_saturate() {
  function smallest_value (line 172) | fn smallest_value() {
  function underflow (line 179) | fn underflow() {
  function nans_01 (line 187) | fn nans_01() {
  function nans_02 (line 193) | fn nans_02() {
  function nans_03 (line 199) | fn nans_03() {
  function negative_01 (line 205) | fn negative_01() {
  function negative_02 (line 211) | fn negative_02() {
  function negative_03 (line 217) | fn negative_03() {
  function negative_04 (line 222) | fn negative_04() {

FILE: sub_crates/compact/src/shared_exp/unsigned40.rs
  constant MAX (line 17) | pub const MAX: f32 = ((1u128 << (128 - EXP_BIAS)) - (1 << (128 - EXP_BIA...
  constant MIN (line 20) | pub const MIN: f32 = 1.0 / (1u128 << (EXP_BIAS + 10)) as f32;
  constant EPSILON (line 23) | pub const EPSILON: f32 = 1.0 / 1024.0;
  constant EXP_BIAS (line 25) | const EXP_BIAS: i32 = 32;
  function encode (line 36) | pub fn encode(floats: (f32, f32, f32)) -> [u8; 5] {
  function decode (line 44) | pub fn decode(trifloat: [u8; 5]) -> (f32, f32, f32) {
  function encode_64 (line 50) | fn encode_64(floats: (f32, f32, f32)) -> u64 {
  function decode_64 (line 83) | fn decode_64(trifloat: u64) -> (f32, f32, f32) {
  function u64_to_bytes (line 100) | fn u64_to_bytes(n: u64) -> [u8; 5] {
  function bytes_to_u64 (line 112) | fn bytes_to_u64(a: [u8; 5]) -> u64 {
  function round_trip (line 126) | fn round_trip(floats: (f32, f32, f32)) -> (f32, f32, f32) {
  function all_zeros (line 131) | fn all_zeros() {
  function powers_of_two (line 142) | fn powers_of_two() {
  function accuracy_01 (line 148) | fn accuracy_01() {
  function accuracy_02 (line 159) | fn accuracy_02() {
  function integers (line 169) | fn integers() {
  function precision_floor (line 177) | fn precision_floor() {
  function saturate (line 183) | fn saturate() {
  function inf_saturate (line 191) | fn inf_saturate() {
  function partial_saturate (line 200) | fn partial_saturate() {
  function smallest_value (line 214) | fn smallest_value() {
  function underflow (line 221) | fn underflow() {
  function nans_01 (line 229) | fn nans_01() {
  function nans_02 (line 235) | fn nans_02() {
  function nans_03 (line 241) | fn nans_03() {
  function negative_01 (line 247) | fn negative_01() {
  function negative_02 (line 253) | fn negative_02() {
  function negative_03 (line 259) | fn negative_03() {
  function negative_04 (line 264) | fn negative_04() {

FILE: sub_crates/compact/src/unit_vec/oct32.rs
  constant STEP_SIZE (line 7) | const STEP_SIZE: f32 = 1.0 / STEPS;
  constant STEPS (line 8) | const STEPS: f32 = ((1 << (16 - 1)) - 1) as f32;
  function encode (line 15) | pub fn encode(vec: (f32, f32, f32)) -> u32 {
  function encode_precise (line 24) | pub fn encode_precise(vec: (f32, f32, f32)) -> u32 {
  function decode (line 68) | pub fn decode(n: u32) -> (f32, f32, f32) {
  function vec3_to_oct (line 73) | fn vec3_to_oct(vec: (f32, f32, f32)) -> (f32, f32) {
  function oct_to_vec3 (line 86) | fn oct_to_vec3(oct: (f32, f32)) -> (f32, f32, f32) {
  function to_snorm_16 (line 101) | fn to_snorm_16(n: f32) -> u16 {
  function from_snorm_16 (line 106) | fn from_snorm_16(n: u16) -> f32 {
  function sign (line 111) | fn sign(n: f32) -> f32 {
  function axis_directions (line 124) | fn axis_directions() {

FILE: sub_crates/compact/tests/proptest_tests.rs
  function cos_gt (line 9) | fn cos_gt(a: (f32, f32, f32), b: (f32, f32, f32), cos: f64) -> bool {
  function l1_delta_lt (line 30) | fn l1_delta_lt(a: (f32, f32, f32), b: (f32, f32, f32), delta: f32) -> bo...

FILE: sub_crates/halton/build.rs
  constant NUM_DIMENSIONS (line 28) | const NUM_DIMENSIONS: usize = 128;
  function main (line 30) | fn main() {
  function is_prime (line 237) | fn is_prime(p: usize) -> bool {
  function get_faure_permutation (line 247) | fn get_faure_permutation(faure: &Vec<Vec<usize>>, b: usize) -> Vec<usize> {
  function invert (line 283) | fn invert(faure: &Vec<Vec<usize>>, base: usize, mut index: usize, digits...

FILE: sub_crates/math3d/src/lib.rs
  type DotProduct (line 11) | pub trait DotProduct {
    method dot (line 12) | fn dot(self, other: Self) -> f32;
  function dot (line 16) | pub fn dot<T: DotProduct>(a: T, b: T) -> f32 {
  type CrossProduct (line 21) | pub trait CrossProduct {
    method cross (line 22) | fn cross(self, other: Self) -> Self;
  function cross (line 26) | pub fn cross<T: CrossProduct>(a: T, b: T) -> T {

FILE: sub_crates/math3d/src/normal.rs
  type Normal (line 14) | pub struct Normal {
    method new (line 20) | pub fn new(x: f32, y: f32, z: f32) -> Normal {
    method length (line 27) | pub fn length(&self) -> f32 {
    method length2 (line 32) | pub fn length2(&self) -> f32 {
    method normalized (line 37) | pub fn normalized(&self) -> Normal {
    method into_vector (line 44) | pub fn into_vector(self) -> Vector {
    method get_n (line 49) | pub fn get_n(&self, n: usize) -> f32 {
    method x (line 59) | pub fn x(&self) -> f32 {
    method y (line 64) | pub fn y(&self) -> f32 {
    method z (line 69) | pub fn z(&self) -> f32 {
    method set_x (line 74) | pub fn set_x(&mut self, x: f32) {
    method set_y (line 79) | pub fn set_y(&mut self, y: f32) {
    method set_z (line 84) | pub fn set_z(&mut self, z: f32) {
    type Output (line 119) | type Output = Normal;
    method mul (line 122) | fn mul(self, other: f32) -> Normal {
    type Output (line 130) | type Output = Normal;
    method mul (line 133) | fn mul(self, other: Transform) -> Normal {
    type Output (line 141) | type Output = Normal;
    method div (line 144) | fn div(self, other: f32) -> Normal {
  method eq (line 91) | fn eq(&self, other: &Normal) -> bool {
  type Output (line 97) | type Output = Normal;
  method add (line 100) | fn add(self, other: Normal) -> Normal {
  type Output (line 108) | type Output = Normal;
  method sub (line 111) | fn sub(self, other: Normal) -> Normal {
  type Output (line 152) | type Output = Normal;
  method neg (line 155) | fn neg(self) -> Normal {
  method dot (line 162) | fn dot(self, other: Normal) -> f32 {
  method cross (line 169) | fn cross(self, other: Normal) -> Normal {
  function add (line 183) | fn add() {
  function sub (line 192) | fn sub() {
  function mul_scalar (line 201) | fn mul_scalar() {
  function mul_matrix_1 (line 210) | fn mul_matrix_1() {
  function div (line 223) | fn div() {
  function length (line 232) | fn length() {
  function length2 (line 238) | fn length2() {
  function normalized (line 244) | fn normalized() {
  function dot_test (line 254) | fn dot_test() {
  function cross_test (line 263) | fn cross_test() {

FILE: sub_crates/math3d/src/point.rs
  type Point (line 14) | pub struct Point {
    method new (line 20) | pub fn new(x: f32, y: f32, z: f32) -> Point {
    method min (line 27) | pub fn min(&self, other: Point) -> Point {
    method max (line 37) | pub fn max(&self, other: Point) -> Point {
    method into_vector (line 47) | pub fn into_vector(self) -> Vector {
    method get_n (line 52) | pub fn get_n(&self, n: usize) -> f32 {
    method x (line 62) | pub fn x(&self) -> f32 {
    method y (line 67) | pub fn y(&self) -> f32 {
    method z (line 72) | pub fn z(&self) -> f32 {
    method set_x (line 77) | pub fn set_x(&mut self, x: f32) {
    method set_y (line 82) | pub fn set_y(&mut self, y: f32) {
    method set_z (line 87) | pub fn set_z(&mut self, z: f32) {
    type Output (line 100) | type Output = Point;
    method add (line 103) | fn add(self, other: Vector) -> Point {
    type Output (line 122) | type Output = Point;
    method sub (line 125) | fn sub(self, other: Vector) -> Point {
    type Output (line 133) | type Output = Point;
    method mul (line 136) | fn mul(self, other: Transform) -> Point {
  method eq (line 94) | fn eq(&self, other: &Point) -> bool {
  type Output (line 111) | type Output = Vector;
  method sub (line 114) | fn sub(self, other: Point) -> Vector {
  function add (line 149) | fn add() {
  function sub (line 158) | fn sub() {
  function mul_matrix_1 (line 167) | fn mul_matrix_1() {
  function mul_matrix_2 (line 177) | fn mul_matrix_2() {
  function mul_matrix_3 (line 187) | fn mul_matrix_3() {

FILE: sub_crates/math3d/src/transform.rs
  type Transform (line 12) | pub struct Transform(pub Affine3A);
    method new (line 17) | pub fn new() -> Transform {
    method new_from_values (line 29) | pub fn new_from_values(
    method from_location (line 50) | pub fn from_location(loc: Point) -> Transform {
    method aprx_eq (line 58) | pub fn aprx_eq(&self, other: Transform, epsilon: f32) -> bool {
    method inverse (line 77) | pub fn inverse(&self) -> Transform {
    type Output (line 100) | type Output = Self;
    method mul (line 103) | fn mul(self, other: f32) -> Self {
  method default (line 83) | fn default() -> Self {
  type Output (line 90) | type Output = Self;
  method mul (line 93) | fn mul(self, other: Self) -> Self {
  type Output (line 110) | type Output = Self;
  method add (line 113) | fn add(self, other: Self) -> Self {
  function equality_test (line 125) | fn equality_test() {
  function approximate_equality_test (line 136) | fn approximate_equality_test() {
  function multiply_test (line 154) | fn multiply_test() {
  function inverse_test (line 169) | fn inverse_test() {

FILE: sub_crates/math3d/src/vector.rs
  type Vector (line 14) | pub struct Vector {
    method new (line 20) | pub fn new(x: f32, y: f32, z: f32) -> Vector {
    method length (line 27) | pub fn length(&self) -> f32 {
    method length2 (line 32) | pub fn length2(&self) -> f32 {
    method normalized (line 37) | pub fn normalized(&self) -> Vector {
    method abs (line 44) | pub fn abs(&self) -> Vector {
    method into_point (line 51) | pub fn into_point(self) -> Point {
    method into_normal (line 56) | pub fn into_normal(self) -> Normal {
    method get_n (line 61) | pub fn get_n(&self, n: usize) -> f32 {
    method x (line 71) | pub fn x(&self) -> f32 {
    method y (line 76) | pub fn y(&self) -> f32 {
    method z (line 81) | pub fn z(&self) -> f32 {
    method set_x (line 86) | pub fn set_x(&mut self, x: f32) {
    method set_y (line 91) | pub fn set_y(&mut self, y: f32) {
    method set_z (line 96) | pub fn set_z(&mut self, z: f32) {
    type Output (line 131) | type Output = Vector;
    method mul (line 134) | fn mul(self, other: f32) -> Vector {
    type Output (line 142) | type Output = Vector;
    method mul (line 145) | fn mul(self, other: Transform) -> Vector {
    type Output (line 153) | type Output = Vector;
    method div (line 156) | fn div(self, other: f32) -> Vector {
  method eq (line 103) | fn eq(&self, other: &Vector) -> bool {
  type Output (line 109) | type Output = Vector;
  method add (line 112) | fn add(self, other: Vector) -> Vector {
  type Output (line 120) | type Output = Vector;
  method sub (line 123) | fn sub(self, other: Vector) -> Vector {
  type Output (line 164) | type Output = Vector;
  method neg (line 167) | fn neg(self) -> Vector {
  method dot (line 174) | fn dot(self, other: Vector) -> f32 {
  method cross (line 181) | fn cross(self, other: Vector) -> Vector {
  function add (line 194) | fn add() {
  function sub (line 203) | fn sub() {
  function mul_scalar (line 212) | fn mul_scalar() {
  function mul_matrix_1 (line 221) | fn mul_matrix_1() {
  function mul_matrix_2 (line 230) | fn mul_matrix_2() {
  function div (line 239) | fn div() {
  function length (line 248) | fn length() {
  function length2 (line 254) | fn length2() {
  function normalized (line 260) | fn normalized() {
  function dot_test (line 270) | fn dot_test() {
  function cross_test (line 279) | fn cross_test() {

FILE: sub_crates/spectral_upsampling/build.rs
  constant RGB2SPEC_N_COEFFS (line 11) | const RGB2SPEC_N_COEFFS: usize = 3;
  constant TABLE_RES (line 14) | const TABLE_RES: usize = 64;
  constant MID_VALUE (line 17) | const MID_VALUE: f32 = 0.5;
  function main (line 19) | fn main() {
  type RGB2Spec (line 93) | pub struct RGB2Spec {
  function rgb2spec_load (line 99) | pub fn rgb2spec_load(filepath: &str) -> RGB2Spec {
  function rgb2spec_load_small (line 170) | pub fn rgb2spec_load_small(filepath: &str) -> Vec<[(f32, f32, f32); 2]> {
  function rgb2spec_find_interval (line 206) | fn rgb2spec_find_interval(values: &[f32], x: f32) -> usize {

FILE: sub_crates/spectral_upsampling/src/jakob.rs
  constant RGB2SPEC_N_COEFFS (line 12) | const RGB2SPEC_N_COEFFS: usize = 3;
  function rec709_to_spectrum_p4 (line 18) | pub fn rec709_to_spectrum_p4(lambdas: Vec4, rgb: (f32, f32, f32)) -> Vec4 {
  function rec2020_to_spectrum_p4 (line 29) | pub fn rec2020_to_spectrum_p4(lambdas: Vec4, rgb: (f32, f32, f32)) -> Ve...
  function aces_to_spectrum_p4 (line 40) | pub fn aces_to_spectrum_p4(lambdas: Vec4, rgb: (f32, f32, f32)) -> Vec4 {
  function small_rgb_to_spectrum_p4 (line 55) | fn small_rgb_to_spectrum_p4(
  function rgb2spec_fma_4 (line 136) | fn rgb2spec_fma_4(a: Vec4, b: Vec4, c: Vec4) -> Vec4 {
  function rgb2spec_eval_4 (line 140) | fn rgb2spec_eval_4(coeff: [f32; RGB2SPEC_N_COEFFS], lambda: Vec4) -> Vec4 {

FILE: sub_crates/spectral_upsampling/src/meng.rs
  function spectrum_xyz_to_p (line 35) | pub fn spectrum_xyz_to_p(lambda: f32, xyz: (f32, f32, f32)) -> f32 {
  function spectrum_xyz_to_p_4 (line 177) | pub fn spectrum_xyz_to_p_4(lambdas: Vec4, xyz: (f32, f32, f32)) -> Vec4 {
  function spectrum_apply_3x2 (line 332) | fn spectrum_apply_3x2(matrix: &[f32; 6], src: (f32, f32)) -> (f32, f32) {
  function spectrum_xy_to_uv (line 348) | fn spectrum_xy_to_uv(xy: (f32, f32)) -> (f32, f32) {

FILE: sub_crates/spectral_upsampling/src/meng/generate_meng_spectra_tables.py
  class Cmf (line 51) | class Cmf:
    method load (line 55) | def load(cls, filename):
    method num_bins (line 60) | def num_bins(cls):
    method bin_size (line 64) | def bin_size(cls):
    method wavelength (line 68) | def wavelength(cls):
    method x_bar (line 72) | def x_bar(cls):
    method y_bar (line 76) | def y_bar(cls):
    method z_bar (line 80) | def z_bar(cls):
    method xyz_from_spectrum (line 84) | def xyz_from_spectrum(cls, spectrum):
    method xyz_ee_white (line 98) | def xyz_ee_white(cls):
  class Transform (line 105) | class Transform:
    method hom (line 110) | def hom(v2):
    method dehom (line 115) | def dehom(v3):
    method xyz_from_xyy (line 126) | def xyz_from_xyy(xyy):
    method xyy_from_xyz (line 133) | def xyy_from_xyz(xyz):
    method xyz_from_srgb (line 140) | def xyz_from_srgb(srgb):
    method srgb_from_xyz (line 153) | def srgb_from_xyz(xyz):
    method xyz_from_ergb (line 161) | def xyz_from_ergb(ergb):
    method init_xystar (line 176) | def init_xystar(cls):
    method xystar_from_xy (line 208) | def xystar_from_xy(cls, xy):
    method xy_from_xystar (line 212) | def xy_from_xystar(cls, xystar):
    method init_uv (line 224) | def init_uv(cls, xystar_bbox, grid_res):
    method uv_from_xy (line 246) | def uv_from_xy(cls, xy):
    method xy_from_uv (line 250) | def xy_from_uv(cls, uv):
    method uv_from_xystar (line 254) | def uv_from_xystar(cls, xystar):
    method xystar_from_uv (line 258) | def xystar_from_uv(cls, uv):
  function multiprocess_progress (line 265) | def multiprocess_progress(data, functor, finished, data_size, early_clip...
  function find_spectrum (line 355) | def find_spectrum(xyz):
  function horseshoe_path (line 393) | def horseshoe_path():
  class DataPoint (line 419) | class DataPoint:
    method __init__ (line 420) | def __init__(self):
    method update_uv (line 430) | def update_uv(self):
  class GridCell (line 433) | class GridCell:
    method __init__ (line 434) | def __init__(self):
  function find_intersection (line 440) | def find_intersection(p0, p1, i0, i1, clip_path):
  function clip_edge (line 461) | def clip_edge(d0, d1, clip_path):
  function generate_xystar_grid (line 476) | def generate_xystar_grid(scale):
  function plot_grid (line 601) | def plot_grid(filename, data_points, grid, bbox_xystar, xystar=True):
  function compute_spectrum (line 670) | def compute_spectrum(data_point):
  function compute_spectra (line 702) | def compute_spectra(data_points):
  function plot_spectra (line 716) | def plot_spectra(data_points):
  function write_output (line 772) | def write_output(data_points, grid, grid_res, filename):
  function create_triangle_fans (line 907) | def create_triangle_fans(grid):
  function compute_max_brightness (line 945) | def compute_max_brightness(point):
  function compute_reflectance_map (line 961) | def compute_reflectance_map(res):

FILE: sub_crates/spectral_upsampling/src/meng/meng_spectra_tables.rs
  constant EQUAL_ENERGY_REFLECTANCE (line 10) | pub const EQUAL_ENERGY_REFLECTANCE: f32 = 0.009355121400914532;
  constant SPECTRUM_GRID_WIDTH (line 13) | pub(crate) const SPECTRUM_GRID_WIDTH: i32 = 12;
  constant SPECTRUM_GRID_HEIGHT (line 14) | pub(crate) const SPECTRUM_GRID_HEIGHT: i32 = 14;
  constant SPECTRUM_SAMPLE_MIN (line 17) | pub const SPECTRUM_SAMPLE_MIN: f32 = 360.0;
  constant SPECTRUM_SAMPLE_MAX (line 18) | pub const SPECTRUM_SAMPLE_MAX: f32 = 830.0;
  constant SPECTRUM_BIN_SIZE (line 19) | pub(crate) const SPECTRUM_BIN_SIZE: f32 = 5.0;
  constant SPECTRUM_NUM_SAMPLES (line 20) | pub(crate) const SPECTRUM_NUM_SAMPLES: i32 = 95;
  constant SPECTRUM_MAT_XY_TO_XYSTAR (line 23) | pub(crate) const SPECTRUM_MAT_XY_TO_XYSTAR: [f32; 6] = [
  constant SPECTRUM_MAT_XYSTAR_TO_XY (line 27) | pub(crate) const SPECTRUM_MAT_XYSTAR_TO_XY: [f32; 6] = [
  constant SPECTRUM_MAT_XY_TO_UV (line 32) | pub(crate) const SPECTRUM_MAT_XY_TO_UV: [f32; 6] = [
  constant SPECTRUM_MAT_UV_TO_XY (line 36) | pub(crate) const SPECTRUM_MAT_UV_TO_XY: [f32; 6] = [
  type SpectrumGridCell (line 43) | pub(crate) struct SpectrumGridCell {
  constant SPECTRUM_GRID (line 49) | pub(crate) const SPECTRUM_GRID: [SpectrumGridCell; 168] = [
  type SpectrumDataPoint (line 222) | pub(crate) struct SpectrumDataPoint {
  constant SPECTRUM_DATA_POINTS (line 228) | pub(crate) const SPECTRUM_DATA_POINTS: [SpectrumDataPoint; 186] = [
  constant CMF_WAVELENGTH (line 1162) | pub(crate) const CMF_WAVELENGTH: [f32; 95] = [
  constant CMF_X (line 1165) | pub(crate) const CMF_X: [f32; 95] = [
  constant CMF_Y (line 1168) | pub(crate) const CMF_Y: [f32; 95] = [
  constant CMF_Z (line 1171) | pub(crate) const CMF_Z: [f32; 95] = [