~wahn/rs-pbrt

356e30bf35926873dfee9a61e1aded2f74b95cf5 — Jan Walter 3 months ago 9bc6c98
Cleanup.
1 files changed, 1 insertions(+), 2047 deletions(-)

M examples/parse_blend_file.rs
M examples/parse_blend_file.rs => examples/parse_blend_file.rs +1 -2047
@@ 1821,7 1821,7 @@ fn main() -> std::io::Result<()> {
    )?;
    if verbose {
        println!(
            "TODO: Do something with the {} bytes returned by use_dna(...).",
            "Do something with the {} bytes returned by use_dna(...).",
            bytes_read.len()
        );
    }


@@ 2701,2052 2701,6 @@ fn main() -> std::io::Result<()> {
    if verbose {
        println!("byte_index = {}", byte_index);
    }

    // // then use the DNA
    // {
    //     if !decode_blender_header(&buffer, &mut blender_version, false) {
    //     } else {
    //         let mut data_following_mesh: bool = false;
    //         let mut data_following_object: bool = false;
    //         let mut is_smooth: bool = false;
    //         // Blender
    //         let mut loop_indices: Vec<u32> = Vec::with_capacity(4194304); // 2^22
    //         loop {
    //             // code
    //             let mut buffer = [0; 4];
    //             f.read(&mut buffer)?;
    //             counter += 4;
    //             let code = make_id(&buffer);
    //             // len
    //             let mut buffer = [0; 4];
    //             f.read(&mut buffer)?;
    //             counter += 4;
    //             let mut len: u32 = 0;
    //             len += (buffer[0] as u32) << 0;
    //             len += (buffer[1] as u32) << 8;
    //             len += (buffer[2] as u32) << 16;
    //             len += (buffer[3] as u32) << 24;
    //             // for now ignore the old entry
    //             let mut buffer = [0; 8];
    //             f.read(&mut buffer)?;
    //             counter += 8;
    //             // get SDNAnr
    //             let mut buffer = [0; 4];
    //             f.read(&mut buffer)?;
    //             counter += 4;
    //             let mut sdna_nr: u32 = 0;
    //             sdna_nr += (buffer[0] as u32) << 0;
    //             sdna_nr += (buffer[1] as u32) << 8;
    //             sdna_nr += (buffer[2] as u32) << 16;
    //             sdna_nr += (buffer[3] as u32) << 24;
    //             // get data len
    //             let mut buffer = [0; 4];
    //             f.read(&mut buffer)?;
    //             counter += 4;
    //             let mut data_len: u32 = 0;
    //             data_len += (buffer[0] as u32) << 0;
    //             data_len += (buffer[1] as u32) << 8;
    //             data_len += (buffer[2] as u32) << 16;
    //             data_len += (buffer[3] as u32) << 24;
    //             // are we done?
    //             if code == String::from("ENDB") {
    //                 break;
    //             }
    //             if code == String::from("DNA1") {
    //                 // read len bytes
    //                 let mut buffer = vec![0; len as usize];
    //                 f.read(&mut buffer)?;
    //                 counter += len as usize;
    //                 if data_following_object {
    //                     if base_name.starts_with("PbrtSphere") {
    //                         // store sphere values for later
    //                         let pbrt_sphere: PbrtSphere = PbrtSphere::new(
    //                             prop_radius as f32,
    //                             prop_zmin as f32,
    //                             prop_zmax as f32,
    //                             prop_phimax as f32,
    //                         );
    //                         spheres_hm.insert(base_name.clone(), pbrt_sphere);
    //                     } else if base_name.starts_with("PbrtCylinder") {
    //                         // store cylinder values for later
    //                         let pbrt_cylinder: PbrtCylinder = PbrtCylinder::new(
    //                             prop_radius as f32,
    //                             prop_zmin as f32,
    //                             prop_zmax as f32,
    //                             prop_phimax as f32,
    //                         );
    //                         cylinders_hm.insert(base_name.clone(), pbrt_cylinder);
    //                     } else if base_name.starts_with("PbrtDisk") {
    //                         // store disk values for later
    //                         let pbrt_disk: PbrtDisk = PbrtDisk::new(
    //                             prop_height as f32,
    //                             prop_radius as f32,
    //                             prop_innerradius as f32,
    //                             prop_phimax as f32,
    //                         );
    //                         disks_hm.insert(base_name.clone(), pbrt_disk);
    //                     }
    //                 }
    //                 if data_following_mesh {
    //                     if base_name.starts_with("PbrtSphere") {
    //                         // create sphere after mesh data
    //                         if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                             object_to_world = *o2w;
    //                         } else {
    //                             println!(
    //                                 "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                 base_name
    //                             );
    //                         }
    //                         let world_to_object: Transform = Transform::inverse(&object_to_world);
    //                         if let Some(sphere) = spheres_hm.get(&base_name) {
    //                             builder.add_sphere(
    //                                 base_name.clone(),
    //                                 object_to_world,
    //                                 world_to_object,
    //                                 sphere.radius,
    //                                 sphere.zmin,
    //                                 sphere.zmax,
    //                                 sphere.phimax,
    //                             );
    //                         }
    //                     } else if base_name.starts_with("PbrtCylinder") {
    //                         // create cylinder after mesh data
    //                         if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                             object_to_world = *o2w;
    //                         } else {
    //                             println!(
    //                                 "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                 base_name
    //                             );
    //                         }
    //                         let world_to_object: Transform = Transform::inverse(&object_to_world);
    //                         if let Some(cylinder) = cylinders_hm.get(&base_name) {
    //                             builder.add_cylinder(
    //                                 base_name.clone(),
    //                                 object_to_world,
    //                                 world_to_object,
    //                                 cylinder.radius,
    //                                 cylinder.zmin,
    //                                 cylinder.zmax,
    //                                 cylinder.phimax,
    //                             );
    //                         }
    //                     } else if base_name.starts_with("PbrtDisk") {
    //                         // create disk after mesh data
    //                         if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                             object_to_world = *o2w;
    //                         } else {
    //                             println!(
    //                                 "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                 base_name
    //                             );
    //                         }
    //                         let world_to_object: Transform = Transform::inverse(&object_to_world);
    //                         if let Some(disk) = disks_hm.get(&base_name) {
    //                             builder.add_disk(
    //                                 base_name.clone(),
    //                                 object_to_world,
    //                                 world_to_object,
    //                                 disk.height,
    //                                 disk.radius,
    //                                 disk.innerradius,
    //                                 disk.phimax,
    //                             );
    //                         }
    //                     } else {
    //                         read_mesh(
    //                             &base_name,
    //                             &object_to_world_hm,
    //                             &mut object_to_world,
    //                             &p,
    //                             &n,
    //                             &mut uvs,
    //                             &loops,
    //                             vertex_indices.clone(),
    //                             vertex_colors.clone(),
    //                             is_smooth,
    //                             &mut builder,
    //                         );
    //                     }
    //                     vertex_indices.clear();
    //                     vertex_colors.clear();
    //                 }
    //                 // reset booleans
    //                 data_following_mesh = false;
    //                 data_following_object = false;
    //                 is_smooth = false;
    //             } else {
    //                 // read len bytes
    //                 let mut buffer = vec![0; len as usize];
    //                 f.read(&mut buffer)?;
    //                 counter += len as usize;
    //                 if code == String::from("IM") {
    //                     // IM
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Image (len=1992) { ... }
    //                     // v280: Image (len=1440) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // id
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // char name[1024]
    //                     let mut img_name = String::new();
    //                     for i in 0..1024 {
    //                         if buffer[skip_bytes + i] == 0 {
    //                             break;
    //                         }
    //                         img_name.push(buffer[skip_bytes + i] as char);
    //                     }
    //                     // skip_bytes += 1024;
    //                     if img_name.len() > 2 {
    //                         // println!("  img_name = {}", img_name);
    //                         let image_path: &Path = Path::new(&img_name);
    //                         // println!("  image_path = {:?}", image_path);
    //                         if let Some(img_ext) = image_path.extension() {
    //                             // println!("  img_ext = {:?}", img_ext);
    //                             if img_ext == "hdr" {
    //                                 if image_path.starts_with("//") {
    //                                     if let Ok(relative) = image_path.strip_prefix("//") {
    //                                         let canonicalized = parent
    //                                             .join(relative.clone())
    //                                             .canonicalize()
    //                                             .unwrap();
    //                                         println!("{:?}", canonicalized);
    //                                         hdr_path = canonicalized.into_os_string();
    //                                     }
    //                                 }
    //                             } else {
    //                                 if image_path.starts_with("//") {
    //                                     if let Ok(relative) = image_path.strip_prefix("//") {
    //                                         let canonicalized = parent
    //                                             .join(relative.clone())
    //                                             .canonicalize()
    //                                             .unwrap();
    //                                         println!("{:?}", canonicalized);
    //                                         texture_hm.insert(
    //                                             base_name.clone(),
    //                                             canonicalized.into_os_string(),
    //                                         );
    //                                     }
    //                                 }
    //                             }
    //                         }
    //                     }
    //                 } else if code == String::from("OB") {
    //                     if data_following_object {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // store sphere values for later
    //                             let pbrt_sphere: PbrtSphere = PbrtSphere::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             spheres_hm.insert(base_name.clone(), pbrt_sphere);
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // store cylinder values for later
    //                             let pbrt_cylinder: PbrtCylinder = PbrtCylinder::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             cylinders_hm.insert(base_name.clone(), pbrt_cylinder);
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // store disk values for later
    //                             let pbrt_disk: PbrtDisk = PbrtDisk::new(
    //                                 prop_height as f32,
    //                                 prop_radius as f32,
    //                                 prop_innerradius as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             disks_hm.insert(base_name.clone(), pbrt_disk);
    //                         }
    //                     }
    //                     // OB
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Object (len=1440) { ... }
    //                     // v280: Object (len=1408) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // id
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // adt
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // nothing there
    //                     } else {
    //                         // DrawDataList (len=16)
    //                         skip_bytes += 16;
    //                     }
    //                     // sculpt
    //                     skip_bytes += 8;
    //                     // type
    //                     // let mut ob_type: u16 = 0;
    //                     // ob_type += (buffer[skip_bytes] as u16) << 0;
    //                     // ob_type += (buffer[skip_bytes + 1] as u16) << 8;
    //                     skip_bytes += 2;
    //                     // match ob_type {
    //                     //     0 => println!("  ob_type = {}", "OB_EMPTY"),
    //                     //     1 => println!("  ob_type = {}", "OB_MESH"),
    //                     //     11 => println!("  ob_type = {}", "OB_CAMERA"),
    //                     //     _ => println!("  ob_type = {}", ob_type),
    //                     // }
    //                     // partype
    //                     skip_bytes += 2;
    //                     // par1, par2, par3
    //                     skip_bytes += 4 * 3;
    //                     // parsubstr[64]
    //                     skip_bytes += 64;
    //                     // parent, track, proxy, proxy_group, proxy_from
    //                     skip_bytes += 8 * 5;
    //                     // ipo
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // bb
    //                         skip_bytes += 8;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // action, poselib, pose, data, gpd
    //                     skip_bytes += 8 * 5;
    //                     // v279: bAnimVizSettings (len=48)
    //                     // v280: bAnimVizSettings (len=32)
    //                     if blender_version < 280 {
    //                         skip_bytes += 48;
    //                     } else {
    //                         skip_bytes += 32;
    //                     }
    //                     // mpath
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // ListBase * 4
    //                         skip_bytes += 16 * 4;
    //                     } else {
    //                         // _pad0
    //                         skip_bytes += 8;
    //                         // ListBase * 7
    //                         skip_bytes += 16 * 7;
    //                     }
    //                     // mode, restore_mode
    //                     skip_bytes += 4 * 2;
    //                     // mat, matbits
    //                     skip_bytes += 8 * 2;
    //                     // totcol, actcol
    //                     skip_bytes += 4 * 2;
    //                     // loc
    //                     skip_bytes += 4 * 3;
    //                     // dloc
    //                     skip_bytes += 4 * 3;
    //                     if blender_version < 280 {
    //                         // orig
    //                         skip_bytes += 4 * 3;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // size
    //                     skip_bytes += 4 * 3;
    //                     // dsize
    //                     skip_bytes += 4 * 3;
    //                     // dscale
    //                     skip_bytes += 4 * 3;
    //                     // rot
    //                     for _i in 0..3 {
    //                         let mut rot_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             rot_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let _rot: f32 = unsafe { mem::transmute(rot_buf) };
    //                         // println!("  rot[{}] = {}", i, rot);
    //                         skip_bytes += 4;
    //                     }
    //                     //skip_bytes += 4 * 3;
    //                     // drot
    //                     skip_bytes += 4 * 3;
    //                     // quat
    //                     skip_bytes += 4 * 4;
    //                     // dquat
    //                     skip_bytes += 4 * 4;
    //                     // rotAxis
    //                     skip_bytes += 4 * 3;
    //                     // drotAxis
    //                     skip_bytes += 4 * 3;
    //                     // rotAngle
    //                     let mut rot_angle_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         rot_angle_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let _rot_angle: f32 = unsafe { mem::transmute(rot_angle_buf) };
    //                     // println!("  rot_angle = {}", rot_angle);
    //                     skip_bytes += 4;
    //                     // drotAngle
    //                     skip_bytes += 4;
    //                     // obmat
    //                     let mut mat_values: [f32; 16] = [0.0_f32; 16];
    //                     for i in 0..4 {
    //                         for j in 0..4 {
    //                             let mut obmat_buf: [u8; 4] = [0_u8; 4];
    //                             for i in 0..4 as usize {
    //                                 obmat_buf[i] = buffer[skip_bytes + i];
    //                             }
    //                             let obmat: f32 = unsafe { mem::transmute(obmat_buf) };
    //                             // println!("  obmat[{}][{}] = {}", i, j, obmat);
    //                             mat_values[i * 4 + j] = obmat;
    //                             skip_bytes += 4;
    //                         }
    //                     }
    //                     object_to_world = Transform::new(
    //                         mat_values[0],
    //                         mat_values[4],
    //                         mat_values[8],
    //                         mat_values[12] * scale_length,
    //                         mat_values[1],
    //                         mat_values[5],
    //                         mat_values[9],
    //                         mat_values[13] * scale_length,
    //                         mat_values[2],
    //                         mat_values[6],
    //                         mat_values[10],
    //                         mat_values[14] * scale_length,
    //                         mat_values[3],
    //                         mat_values[7],
    //                         mat_values[11],
    //                         mat_values[15],
    //                     );
    //                     object_to_world_hm.insert(base_name.clone(), object_to_world);
    //                     // parentinv
    //                     for _i in 0..4 {
    //                         for _j in 0..4 {
    //                             let mut parentinv_buf: [u8; 4] = [0_u8; 4];
    //                             for i in 0..4 as usize {
    //                                 parentinv_buf[i] = buffer[skip_bytes + i];
    //                             }
    //                             let _parentinv: f32 = unsafe { mem::transmute(parentinv_buf) };
    //                             // println!("  parentinv[{}][{}] = {}", i, j, parentinv);
    //                             skip_bytes += 4;
    //                         }
    //                     }
    //                     // constinv
    //                     for _i in 0..4 {
    //                         for _j in 0..4 {
    //                             let mut constinv_buf: [u8; 4] = [0_u8; 4];
    //                             for i in 0..4 as usize {
    //                                 constinv_buf[i] = buffer[skip_bytes + i];
    //                             }
    //                             let _constinv: f32 = unsafe { mem::transmute(constinv_buf) };
    //                             // println!("  constinv[{}][{}] = {}", i, j, constinv);
    //                             skip_bytes += 4;
    //                         }
    //                     }
    //                     // imat
    //                     for _i in 0..4 {
    //                         for _j in 0..4 {
    //                             let mut imat_buf: [u8; 4] = [0_u8; 4];
    //                             for i in 0..4 as usize {
    //                                 imat_buf[i] = buffer[skip_bytes + i];
    //                             }
    //                             let _imat: f32 = unsafe { mem::transmute(imat_buf) };
    //                             // println!("  imat[{}][{}] = {}", i, j, imat);
    //                             skip_bytes += 4;
    //                         }
    //                     }
    //                     // imat_ren
    //                     for _i in 0..4 {
    //                         for _j in 0..4 {
    //                             let mut imat_ren_buf: [u8; 4] = [0_u8; 4];
    //                             for i in 0..4 as usize {
    //                                 imat_ren_buf[i] = buffer[skip_bytes + i];
    //                             }
    //                             let _imat_ren: f32 = unsafe { mem::transmute(imat_ren_buf) };
    //                             // println!("  imat_ren[{}][{}] = {}", i, j, imat_ren);
    //                             skip_bytes += 4;
    //                         }
    //                     }
    //                     // reset booleans
    //                     data_following_mesh = false;
    //                     data_following_object = true;
    //                     is_smooth = false;
    //                 } else if code == String::from("ME") {
    //                     if data_following_object {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // store sphere values for later
    //                             let pbrt_sphere: PbrtSphere = PbrtSphere::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             spheres_hm.insert(base_name.clone(), pbrt_sphere);
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // store cylinder values for later
    //                             let pbrt_cylinder: PbrtCylinder = PbrtCylinder::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             cylinders_hm.insert(base_name.clone(), pbrt_cylinder);
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // store disk values for later
    //                             let pbrt_disk: PbrtDisk = PbrtDisk::new(
    //                                 prop_height as f32,
    //                                 prop_radius as f32,
    //                                 prop_innerradius as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             disks_hm.insert(base_name.clone(), pbrt_disk);
    //                         }
    //                     }
    //                     if data_following_mesh {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // create sphere after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(sphere) = spheres_hm.get(&base_name) {
    //                                 builder.add_sphere(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     sphere.radius,
    //                                     sphere.zmin,
    //                                     sphere.zmax,
    //                                     sphere.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // create cylinder after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(cylinder) = cylinders_hm.get(&base_name) {
    //                                 builder.add_cylinder(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     cylinder.radius,
    //                                     cylinder.zmin,
    //                                     cylinder.zmax,
    //                                     cylinder.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // create disk after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(disk) = disks_hm.get(&base_name) {
    //                                 builder.add_disk(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     disk.height,
    //                                     disk.radius,
    //                                     disk.innerradius,
    //                                     disk.phimax,
    //                                 );
    //                             }
    //                         } else {
    //                             read_mesh(
    //                                 &base_name,
    //                                 &object_to_world_hm,
    //                                 &mut object_to_world,
    //                                 &p,
    //                                 &n,
    //                                 &mut uvs,
    //                                 &loops,
    //                                 vertex_indices.clone(),
    //                                 vertex_colors.clone(),
    //                                 is_smooth,
    //                                 &mut builder,
    //                             );
    //                         }
    //                         vertex_indices.clear();
    //                         vertex_colors.clear();
    //                     }
    //                     // ME
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // Mesh (len=1416) { ... }
    //                     // let mut skip_bytes: usize = 0;
    //                     // id
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     // if blender_version < 280 {
    //                     //     skip_bytes += 120;
    //                     // } else {
    //                     //     skip_bytes += 152;
    //                     // }
    //                     // adt
    //                     // skip_bytes += 8;
    //                     // bb, ipo, key, mat, mselect, mpoly, mtpoly, mloop, mloopuv, mloopcol
    //                     // skip_bytes += 8 * 10;
    //                     // mface, mtface, tface, mvert, medge, dvert, mcol, texcomesh, edit_btmesh
    //                     // skip_bytes += 8 * 9;
    //                     // CustomData * 5
    //                     // skip_bytes += 208 * 5;
    //                     // totvert
    //                     // let mut totvert: u32 = 0;
    //                     // totvert += (buffer[skip_bytes] as u32) << 0;
    //                     // totvert += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totvert += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totvert += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totvert = {}", totvert);
    //                     // skip_bytes += 4;
    //                     // totedge
    //                     // let mut totedge: u32 = 0;
    //                     // totedge += (buffer[skip_bytes] as u32) << 0;
    //                     // totedge += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totedge += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totedge += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totedge = {}", totedge);
    //                     // skip_bytes += 4;
    //                     // totface
    //                     // let mut totface: u32 = 0;
    //                     // totface += (buffer[skip_bytes] as u32) << 0;
    //                     // totface += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totface += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totface += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totface = {}", totface);
    //                     // skip_bytes += 4;
    //                     // totselect
    //                     // let mut totselect: u32 = 0;
    //                     // totselect += (buffer[skip_bytes] as u32) << 0;
    //                     // totselect += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totselect += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totselect += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totselect = {}", totselect);
    //                     // skip_bytes += 4;
    //                     // totpoly
    //                     // let mut totpoly: u32 = 0;
    //                     // totpoly += (buffer[skip_bytes] as u32) << 0;
    //                     // totpoly += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totpoly += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totpoly += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totpoly = {}", totpoly);
    //                     // // skip_bytes += 4;
    //                     // totloop
    //                     // let mut totloop: u32 = 0;
    //                     // totloop += (buffer[skip_bytes] as u32) << 0;
    //                     // totloop += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // totloop += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // totloop += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("  totloop = {}", totloop);
    //                     // skip_bytes += 4;
    //                     // check tlen
    //                     // for n in 0..types.len() {
    //                     //     if types[n] == "CustomData" {
    //                     //         println!("  {:?} = types[{}] needs {} bytes", types[n], n, tlen[n]);
    //                     //     }
    //                     // }
    //                     // data_following_mesh
    //                     data_following_mesh = true;
    //                     // clear all Vecs
    //                     p.clear();
    //                     n.clear();
    //                     uvs.clear();
    //                     loops.clear();
    //                     vertex_indices.clear();
    //                     vertex_colors.clear();
    //                     loop_indices.clear();
    //                 } else if code == String::from("SC") {
    //                     // SC
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Scene (len=5472) { ... }
    //                     // v280: Scene (len=6392) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // v279: ID (len=120)
    //                     // v280: ID (len=152)
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // adt
    //                     skip_bytes += 8;
    //                     // camera, world, set
    //                     skip_bytes += 8 * 3;
    //                     // ListBase * 1
    //                     skip_bytes += 16 * 1;
    //                     // basact
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // obedit
    //                         skip_bytes += 8;
    //                         // cursor
    //                         skip_bytes += 4 * 3;
    //                         // twcent
    //                         skip_bytes += 4 * 3;
    //                         // twmin
    //                         skip_bytes += 4 * 3;
    //                         // twmax
    //                         skip_bytes += 4 * 3;
    //                     } else {
    //                         // _pad1
    //                         skip_bytes += 8;
    //                         // View3DCursor (len=64)
    //                         skip_bytes += 64;
    //                     }
    //                     // lay, layact, lay_updated/_pad2[4]
    //                     skip_bytes += 4 * 3;
    //                     // flag
    //                     skip_bytes += 2;
    //                     // use_nodes
    //                     skip_bytes += 1;
    //                     // pad/_pad3
    //                     skip_bytes += 1;
    //                     // nodetree, ed, toolsettings, stats/_pad4
    //                     skip_bytes += 8 * 4;
    //                     // DisplaySafeAreas (len=32)
    //                     skip_bytes += 32;
    //                     // v279: RenderData (len=4432)
    //                     // v280: RenderData (len=4192)
    //                     let mut render_data_bytes: usize = 0;
    //                     // ImageFormatData (len=256)
    //                     skip_bytes += 256;
    //                     render_data_bytes += 256;
    //                     // avicodecdata
    //                     skip_bytes += 8;
    //                     render_data_bytes += 8;
    //                     if blender_version < 280 {
    //                         // qtcodecdata
    //                         skip_bytes += 8;
    //                         render_data_bytes += 8;
    //                         // QuicktimeCodecSettings (len=64)
    //                         skip_bytes += 64;
    //                         render_data_bytes += 64;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // FFMpegCodecData (len=88)
    //                     skip_bytes += 88;
    //                     render_data_bytes += 88;
    //                     // cfra
    //                     // let mut cfra: u32 = 0;
    //                     // cfra += (buffer[skip_bytes] as u32) << 0;
    //                     // cfra += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // cfra += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // cfra += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("    cfra = {}", cfra);
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     // sfra
    //                     // let mut sfra: u32 = 0;
    //                     // sfra += (buffer[skip_bytes] as u32) << 0;
    //                     // sfra += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // sfra += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // sfra += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("    sfra = {}", sfra);
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     // efra
    //                     // let mut efra: u32 = 0;
    //                     // efra += (buffer[skip_bytes] as u32) << 0;
    //                     // efra += (buffer[skip_bytes + 1] as u32) << 8;
    //                     // efra += (buffer[skip_bytes + 2] as u32) << 16;
    //                     // efra += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("    efra = {}", efra);
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     // subframe
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     // psfra, pefra, images, framapto
    //                     skip_bytes += 4 * 4;
    //                     render_data_bytes += 4 * 4;
    //                     // flag, threads
    //                     skip_bytes += 2 * 2;
    //                     render_data_bytes += 2 * 2;
    //                     // framelen, blurfac,
    //                     skip_bytes += 4 * 2;
    //                     render_data_bytes += 4 * 2;
    //                     if blender_version < 280 {
    //                         // edgeR, edgeG, edgeB
    //                         skip_bytes += 4 * 3;
    //                         render_data_bytes += 4 * 3;
    //                         // fullscreen, xplay, yplay, freqplay, depth, attrib
    //                         skip_bytes += 2 * 6;
    //                         render_data_bytes += 2 * 6;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // frame_step
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     // stereomode, dimensionspreset
    //                     skip_bytes += 2 * 2;
    //                     render_data_bytes += 2 * 2;
    //                     if blender_version < 280 {
    //                         // filtertype
    //                         skip_bytes += 2;
    //                         render_data_bytes += 2;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // size in %
    //                     resolution_percentage = 0;
    //                     resolution_percentage += (buffer[skip_bytes] as u16) << 0;
    //                     resolution_percentage += (buffer[skip_bytes + 1] as u16) << 8;
    //                     // println!("resolution_percentage: {}", resolution_percentage);
    //                     skip_bytes += 2;
    //                     render_data_bytes += 2;
    //                     if blender_version < 280 {
    //                         // maximsize, pad6
    //                         skip_bytes += 2;
    //                         render_data_bytes += 2;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // pad6
    //                     skip_bytes += 2;
    //                     render_data_bytes += 2;
    //                     // xsch
    //                     let mut xsch: u32 = 0;
    //                     xsch += (buffer[skip_bytes] as u32) << 0;
    //                     xsch += (buffer[skip_bytes + 1] as u32) << 8;
    //                     xsch += (buffer[skip_bytes + 2] as u32) << 16;
    //                     xsch += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("    xsch = {}", xsch);
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     resolution_x = xsch;
    //                     // ysch
    //                     let mut ysch: u32 = 0;
    //                     ysch += (buffer[skip_bytes] as u32) << 0;
    //                     ysch += (buffer[skip_bytes + 1] as u32) << 8;
    //                     ysch += (buffer[skip_bytes + 2] as u32) << 16;
    //                     ysch += (buffer[skip_bytes + 3] as u32) << 24;
    //                     // println!("    ysch = {}", ysch);
    //                     skip_bytes += 4;
    //                     render_data_bytes += 4;
    //                     resolution_y = ysch;
    //                     // skip remaining RenderData
    //                     if blender_version < 280 {
    //                         skip_bytes += 4432 - render_data_bytes;
    //                     } else {
    //                         skip_bytes += 4192 - render_data_bytes;
    //                     }
    //                     // AudioData (len=32)
    //                     skip_bytes += 32;
    //                     // ListBase * 2
    //                     skip_bytes += 16 * 2;
    //                     if blender_version < 280 {
    //                         // nothing there
    //                     } else {
    //                         // TransformOrientationSlot (16) * 4
    //                         skip_bytes += 16 * 4;
    //                     }
    //                     // sound_scene, playback_handle, sound_scrub_handle, speaker_handles, fps_info
    //                     skip_bytes += 8 * 5;
    //                     // depsgraph/depsgraph_hash
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // pad1, theDag
    //                         skip_bytes += 8 * 2;
    //                         // dagflags, pad3
    //                         skip_bytes += 2 * 2;
    //                     } else {
    //                         // _pad7
    //                         skip_bytes += 4;
    //                     }
    //                     // active_keyingset
    //                     skip_bytes += 4;
    //                     // ListBase * 1
    //                     skip_bytes += 16 * 1;
    //                     if blender_version < 280 {
    //                         // GameFraming (len=16)
    //                         skip_bytes += 16;
    //                         // GameData (len=192)
    //                         skip_bytes += 192;
    //                     } else {
    //                         // nothing there
    //                     }
    //                     // v279: UnitSettings (len=8)
    //                     // v280: UnitSettings (len=16)
    //                     // scale_length
    //                     let mut scale_length_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         scale_length_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     scale_length = unsafe { mem::transmute(scale_length_buf) };
    //                     // println!("    scale_length = {}", scale_length);
    //                     // skip_bytes += 4;
    //                     // reset booleans
    //                     data_following_mesh = false;
    //                     data_following_object = false;
    //                     is_smooth = false;
    //                 } else if code == String::from("CA") {
    //                     // CA
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Camera (len=248) { ... }
    //                     // v280: Camera (len=520) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // v279: ID (len=120)
    //                     // v280: ID (len=152)
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // adt
    //                     skip_bytes += 8;
    //                     // type, dtx
    //                     skip_bytes += 2;
    //                     // flag
    //                     skip_bytes += 2;
    //                     // passepartalpha
    //                     skip_bytes += 4;
    //                     // clipsta
    //                     let mut clipsta_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         clipsta_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let clipsta: f32 = unsafe { mem::transmute(clipsta_buf) };
    //                     // println!("  clipsta = {}", clipsta);
    //                     skip_bytes += 4;
    //                     // clipend
    //                     // let mut clipend_buf: [u8; 4] = [0_u8; 4];
    //                     // for i in 0..4 as usize {
    //                     //     clipend_buf[i] = buffer[skip_bytes + i];
    //                     // }
    //                     // let clipend: f32 = unsafe { mem::transmute(clipend_buf) };
    //                     // println!("  clipend = {}", clipend);
    //                     skip_bytes += 4;
    //                     // lens
    //                     let mut lens_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         lens_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let lens: f32 = unsafe { mem::transmute(lens_buf) };
    //                     // println!("  lens = {}", lens);
    //                     skip_bytes += 4;
    //                     // ortho_scale
    //                     // let mut ortho_scale_buf: [u8; 4] = [0_u8; 4];
    //                     // for i in 0..4 as usize {
    //                     //     ortho_scale_buf[i] = buffer[skip_bytes + i];
    //                     // }
    //                     // let ortho_scale: f32 = unsafe { mem::transmute(ortho_scale_buf) };
    //                     // println!("  ortho_scale = {}", ortho_scale);
    //                     skip_bytes += 4;
    //                     // drawsize
    //                     // let mut drawsize_buf: [u8; 4] = [0_u8; 4];
    //                     // for i in 0..4 as usize {
    //                     //     drawsize_buf[i] = buffer[skip_bytes + i];
    //                     // }
    //                     // let drawsize: f32 = unsafe { mem::transmute(drawsize_buf) };
    //                     // println!("  drawsize = {}", drawsize);
    //                     skip_bytes += 4;
    //                     // sensor_x
    //                     let mut sensor_x_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         sensor_x_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let sensor_x: f32 = unsafe { mem::transmute(sensor_x_buf) };
    //                     // println!("  sensor_x = {}", sensor_x);
    //                     skip_bytes += 4;
    //                     // sensor_y
    //                     let mut sensor_y_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         sensor_y_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let sensor_y: f32 = unsafe { mem::transmute(sensor_y_buf) };
    //                     // println!("  sensor_y = {}", sensor_y);
    //                     // skip_bytes += 4;
    //                     // calculate angle_x and angle_y
    //                     angle_x = degrees(focallength_to_fov(lens, sensor_x) as Float);
    //                     angle_y = degrees(focallength_to_fov(lens, sensor_y) as Float);
    //                     // println!("  angle_x = {}", angle_x);
    //                     // println!("  angle_y = {}", angle_y);
    //                     // shiftx
    //                     // let mut shiftx_buf: [u8; 4] = [0_u8; 4];
    //                     // for i in 0..4 as usize {
    //                     //     shiftx_buf[i] = buffer[skip_bytes + i];
    //                     // }
    //                     // let shiftx: f32 = unsafe { mem::transmute(shiftx_buf) };
    //                     // println!("  shiftx = {}", shiftx);
    //                     // skip_bytes += 4;
    //                     // shifty
    //                     // let mut shifty_buf: [u8; 4] = [0_u8; 4];
    //                     // for i in 0..4 as usize {
    //                     //     shifty_buf[i] = buffer[skip_bytes + i];
    //                     // }
    //                     // let shifty: f32 = unsafe { mem::transmute(shifty_buf) };
    //                     // println!("  shifty = {}", shifty);
    //                     // skip_bytes += 4;
    //                     let cam: BlendCamera = BlendCamera {
    //                         lens,
    //                         angle_x,
    //                         angle_y,
    //                         clipsta,
    //                     };
    //                     camera_hm.insert(base_name.clone(), cam);
    //                     // reset booleans
    //                     data_following_mesh = false;
    //                     data_following_object = false;
    //                     is_smooth = false;
    //                 } else if code == String::from("MA") {
    //                     if data_following_object {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // store sphere values for later
    //                             let pbrt_sphere: PbrtSphere = PbrtSphere::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             spheres_hm.insert(base_name.clone(), pbrt_sphere);
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // store cylinder values for later
    //                             let pbrt_cylinder: PbrtCylinder = PbrtCylinder::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             cylinders_hm.insert(base_name.clone(), pbrt_cylinder);
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // store disk values for later
    //                             let pbrt_disk: PbrtDisk = PbrtDisk::new(
    //                                 prop_height as f32,
    //                                 prop_radius as f32,
    //                                 prop_innerradius as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             disks_hm.insert(base_name.clone(), pbrt_disk);
    //                         }
    //                     }
    //                     if data_following_mesh {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // create sphere after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(sphere) = spheres_hm.get(&base_name) {
    //                                 builder.add_sphere(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     sphere.radius,
    //                                     sphere.zmin,
    //                                     sphere.zmax,
    //                                     sphere.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // create cylinder after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(cylinder) = cylinders_hm.get(&base_name) {
    //                                 builder.add_cylinder(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     cylinder.radius,
    //                                     cylinder.zmin,
    //                                     cylinder.zmax,
    //                                     cylinder.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // create disk after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(disk) = disks_hm.get(&base_name) {
    //                                 builder.add_disk(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     disk.height,
    //                                     disk.radius,
    //                                     disk.innerradius,
    //                                     disk.phimax,
    //                                 );
    //                             }
    //                         } else {
    //                             read_mesh(
    //                                 &base_name,
    //                                 &object_to_world_hm,
    //                                 &mut object_to_world,
    //                                 &p,
    //                                 &n,
    //                                 &mut uvs,
    //                                 &loops,
    //                                 vertex_indices.clone(),
    //                                 vertex_colors.clone(),
    //                                 is_smooth,
    //                                 &mut builder,
    //                             );
    //                         }
    //                         vertex_indices.clear();
    //                         vertex_colors.clear();
    //                     }
    //                     // MA
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Material (len=1528) { ... }
    //                     // v280: Material (len=320) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // v279: ID (len=120)
    //                     // v280: ID (len=152)
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // adt
    //                     skip_bytes += 8;
    //                     if blender_version < 280 {
    //                         // material_type, flag
    //                         skip_bytes += 2 * 2;
    //                         // r
    //                         let mut r_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             r_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let r: f32 = unsafe { mem::transmute(r_buf) };
    //                         // println!("  r = {}", r);
    //                         skip_bytes += 4;
    //                         // g
    //                         let mut g_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             g_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let g: f32 = unsafe { mem::transmute(g_buf) };
    //                         // println!("  g = {}", g);
    //                         skip_bytes += 4;
    //                         // b
    //                         let mut b_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             b_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let b: f32 = unsafe { mem::transmute(b_buf) };
    //                         // println!("  b = {}", b);
    //                         skip_bytes += 4;
    //                         // specr
    //                         let mut specr_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specr_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specr: f32 = unsafe { mem::transmute(specr_buf) };
    //                         // println!("  specr = {}", specr);
    //                         skip_bytes += 4;
    //                         // specg
    //                         let mut specg_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specg_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specg: f32 = unsafe { mem::transmute(specg_buf) };
    //                         // println!("  specg = {}", specg);
    //                         skip_bytes += 4;
    //                         // specb
    //                         let mut specb_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specb_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specb: f32 = unsafe { mem::transmute(specb_buf) };
    //                         // println!("  specb = {}", specb);
    //                         skip_bytes += 4;
    //                         // mirr
    //                         let mut mirr_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             mirr_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let mirr: f32 = unsafe { mem::transmute(mirr_buf) };
    //                         // println!("  mirr = {}", mirr);
    //                         skip_bytes += 4;
    //                         // mirg
    //                         let mut mirg_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             mirg_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let mirg: f32 = unsafe { mem::transmute(mirg_buf) };
    //                         // println!("  mirg = {}", mirg);
    //                         skip_bytes += 4;
    //                         // mirb
    //                         let mut mirb_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             mirb_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let mirb: f32 = unsafe { mem::transmute(mirb_buf) };
    //                         // println!("  mirb = {}", mirb);
    //                         skip_bytes += 4;
    //                         // ambr, ambg, ambb
    //                         skip_bytes += 4 * 3;
    //                         // amb
    //                         skip_bytes += 4;
    //                         // emit
    //                         let mut emit_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             emit_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let emit: f32 = unsafe { mem::transmute(emit_buf) };
    //                         // println!("  emit = {}", emit);
    //                         skip_bytes += 4;
    //                         // ang (called "IOR" in Blender's UI)
    //                         let mut ang_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             ang_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let ang: f32 = unsafe { mem::transmute(ang_buf) };
    //                         // println!("  ang = {}", ang);
    //                         skip_bytes += 4;
    //                         // spectra
    //                         skip_bytes += 4;
    //                         // ray_mirror
    //                         let mut ray_mirror_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             ray_mirror_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let ray_mirror: f32 = unsafe { mem::transmute(ray_mirror_buf) };
    //                         // println!("  ray_mirror = {}", ray_mirror);
    //                         skip_bytes += 4;
    //                         // alpha, ref, spec, zoffs, add, translucency
    //                         skip_bytes += 4 * 6;
    //                         // VolumeSettings (len=88)
    //                         skip_bytes += 88;
    //                         // GameSettings (len=16)
    //                         skip_bytes += 16;
    //                         // 7 floats
    //                         skip_bytes += 4 * 7;
    //                         // 3 shorts
    //                         skip_bytes += 2 * 3;
    //                         // 2 chars
    //                         skip_bytes += 2;
    //                         // 2 floats
    //                         skip_bytes += 4 * 2;
    //                         // 2 shorts
    //                         skip_bytes += 2 * 2;
    //                         // 4 floats
    //                         skip_bytes += 4 * 4;
    //                         // 2 shorts
    //                         skip_bytes += 2 * 2;
    //                         // 4 ints
    //                         skip_bytes += 4 * 4;
    //                         // 4 shorts
    //                         skip_bytes += 2 * 4;
    //                         // 10 floats
    //                         skip_bytes += 4 * 10;
    //                         // 64 chars
    //                         skip_bytes += 64;
    //                         // 3 floats
    //                         skip_bytes += 4 * 3;
    //                         // 1 int
    //                         skip_bytes += 4;
    //                         // 4 chars
    //                         skip_bytes += 4;
    //                         // 3 shorts
    //                         skip_bytes += 2 * 3;
    //                         // 2 chars
    //                         skip_bytes += 2;
    //                         // 2 shorts
    //                         skip_bytes += 2 * 2;
    //                         // roughness
    //                         let mut roughness_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             roughness_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let roughness: f32 = unsafe { mem::transmute(roughness_buf) };
    //                         // println!("  roughness = {}", roughness);
    //                         // skip_bytes += 4;
    //                         // Blend279Material
    //                         let mat: Blend279Material = Blend279Material {
    //                             r: r,
    //                             g: g,
    //                             b: b,
    //                             a: 1.0,
    //                             specr: specr,
    //                             specg: specg,
    //                             specb: specb,
    //                             mirr: mirr,
    //                             mirg: mirg,
    //                             mirb: mirb,
    //                             emit: emit,
    //                             ang: ang,
    //                             ray_mirror: ray_mirror,
    //                             roughness: roughness,
    //                         };
    //                         // println!("  mat[{:?}] = {:?}", base_name, mat);
    //                         material_hm.insert(base_name.clone(), mat);
    //                     } else {
    //                         // flag
    //                         skip_bytes += 2;
    //                         // _pad1
    //                         skip_bytes += 2;
    //                         // r
    //                         let mut r_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             r_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let r: f32 = unsafe { mem::transmute(r_buf) };
    //                         // println!("  r = {}", r);
    //                         skip_bytes += 4;
    //                         // g
    //                         let mut g_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             g_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let g: f32 = unsafe { mem::transmute(g_buf) };
    //                         // println!("  g = {}", g);
    //                         skip_bytes += 4;
    //                         // b
    //                         let mut b_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             b_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let b: f32 = unsafe { mem::transmute(b_buf) };
    //                         // println!("  b = {}", b);
    //                         skip_bytes += 4;
    //                         // a
    //                         let mut a_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             a_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let a: f32 = unsafe { mem::transmute(a_buf) };
    //                         // println!("  a = {}", a);
    //                         skip_bytes += 4;
    //                         // specr
    //                         let mut specr_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specr_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specr: f32 = unsafe { mem::transmute(specr_buf) };
    //                         // println!("  specr = {}", specr);
    //                         skip_bytes += 4;
    //                         // specg
    //                         let mut specg_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specg_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specg: f32 = unsafe { mem::transmute(specg_buf) };
    //                         // println!("  specg = {}", specg);
    //                         skip_bytes += 4;
    //                         // specb
    //                         let mut specb_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             specb_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let specb: f32 = unsafe { mem::transmute(specb_buf) };
    //                         // println!("  specb = {}", specb);
    //                         skip_bytes += 4;
    //                         // alpha
    //                         skip_bytes += 4;
    //                         // ray_mirror
    //                         let mut ray_mirror_buf: [u8; 4] = [0_u8; 4];
    //                         for i in 0..4 as usize {
    //                             ray_mirror_buf[i] = buffer[skip_bytes + i];
    //                         }
    //                         let ray_mirror: f32 = unsafe { mem::transmute(ray_mirror_buf) };
    //                         // println!("  ray_mirror = {}", ray_mirror);
    //                         skip_bytes += 4;
    //                         // spec, gloss_mir, roughness, metallic
    //                         skip_bytes += 4 * 4;
    //                         // use_nodes
    //                         let _use_nodes: u8 = buffer[skip_bytes] as u8;
    //                         // println!("  use_nodes = {}", use_nodes);
    //                         // skip_bytes += 1;
    //                         let mat: Blend279Material = Blend279Material {
    //                             r: r,
    //                             g: g,
    //                             b: b,
    //                             a: a,
    //                             specr: specr,
    //                             specg: specg,
    //                             specb: specb,
    //                             mirr: 0.0,
    //                             mirg: 0.0,
    //                             mirb: 0.0,
    //                             emit: 0.0,
    //                             ang: 1.0,
    //                             ray_mirror: ray_mirror,
    //                             roughness: 0.0,
    //                         };
    //                         // println!("  mat[{:?}] = {:?}", base_name, mat);
    //                         material_hm.insert(base_name.clone(), mat);
    //                     }
    //                     // reset booleans
    //                     data_following_mesh = false;
    //                     data_following_object = false;
    //                     is_smooth = false;
    //                 } else if code == String::from("LA") {
    //                     // LA
    //                     // println!("{} ({})", code, len);
    //                     // println!("  SDNAnr = {}", sdna_nr);
    //                     // v279: Lamp (len=536) { ... }
    //                     // v280: Lamp (len=TODO) { ... }
    //                     let mut skip_bytes: usize = 0;
    //                     // id
    //                     let mut id_name = String::new();
    //                     base_name = String::new();
    //                     for i in 32..(32 + 66) {
    //                         if buffer[i] == 0 {
    //                             break;
    //                         }
    //                         id_name.push(buffer[i] as char);
    //                         if i != 32 && i != 33 {
    //                             base_name.push(buffer[i] as char);
    //                         }
    //                     }
    //                     // println!("  id_name = {}", id_name);
    //                     // println!("  base_name = {}", base_name);
    //                     if blender_version < 280 {
    //                         skip_bytes += 120;
    //                     } else {
    //                         skip_bytes += 152;
    //                     }
    //                     // adt
    //                     skip_bytes += 8;
    //                     // type
    //                     let mut la_type: u16 = 0;
    //                     la_type += (buffer[skip_bytes] as u16) << 0;
    //                     la_type += (buffer[skip_bytes + 1] as u16) << 8;
    //                     // println!("  la_type = {}", la_type);
    //                     skip_bytes += 2;
    //                     // flag
    //                     skip_bytes += 2;
    //                     // mode
    //                     skip_bytes += 4;
    //                     // colormodel, totex
    //                     skip_bytes += 2 * 2;
    //                     // r
    //                     let mut r_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         r_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let r: f32 = unsafe { mem::transmute(r_buf) };
    //                     // println!("  r = {}", r);
    //                     skip_bytes += 4;
    //                     // g
    //                     let mut g_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         g_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let g: f32 = unsafe { mem::transmute(g_buf) };
    //                     // println!("  g = {}", g);
    //                     skip_bytes += 4;
    //                     // b
    //                     let mut b_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         b_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let b: f32 = unsafe { mem::transmute(b_buf) };
    //                     // println!("  b = {}", b);
    //                     skip_bytes += 4;
    //                     // k, shdwr, shdwg, shdwb, shdwpad
    //                     skip_bytes += 4 * 5;
    //                     // energy
    //                     let mut energy_buf: [u8; 4] = [0_u8; 4];
    //                     for i in 0..4 as usize {
    //                         energy_buf[i] = buffer[skip_bytes + i];
    //                     }
    //                     let energy: f32 = unsafe { mem::transmute(energy_buf) };
    //                     // println!("  energy = {}", energy);
    //                     // skip_bytes += 4;
    //                     // check light type
    //                     if la_type == 0 {
    //                         // LA_LOCAL
    //                         if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                             object_to_world = *o2w;
    //                         } else {
    //                             println!(
    //                                 "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                 base_name
    //                             );
    //                         }
    //                         let l: Spectrum = Spectrum::rgb(r, g, b);
    //                         // point light
    //                         builder.add_point_light(object_to_world, l, args.light_scale * energy);
    //                     } else if la_type == 1 {
    //                         // LA_SUN
    //                         if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                             object_to_world = *o2w;
    //                         } else {
    //                             println!(
    //                                 "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                 base_name
    //                             );
    //                         }
    //                         let l: Spectrum = Spectrum::rgb(r, g, b);
    //                         // distant light
    //                         builder.add_distant_light(
    //                             object_to_world,
    //                             l,
    //                             args.light_scale * energy,
    //                         );
    //                     } else {
    //                         println!("WARNING: la_type = {} not supported (yet)", la_type);
    //                     }
    //                 } else if code == String::from("DATA") {
    //                     // DATA
    //                     if data_following_mesh {
    //                         // type_id
    //                         let type_id: usize = dna_2_type_id[sdna_nr as usize] as usize;
    //                         if types[type_id] == "MPoly" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             let mut skip_bytes: usize = 0;
    //                             for _p in 0..data_len {
    //                                 // println!("  {}:", p + 1);
    //                                 // loopstart
    //                                 let mut loopstart: u32 = 0;
    //                                 loopstart += (buffer[skip_bytes] as u32) << 0;
    //                                 loopstart += (buffer[skip_bytes + 1] as u32) << 8;
    //                                 loopstart += (buffer[skip_bytes + 2] as u32) << 16;
    //                                 loopstart += (buffer[skip_bytes + 3] as u32) << 24;
    //                                 // println!("    loopstart = {}", loopstart);
    //                                 skip_bytes += 4;
    //                                 // totloop
    //                                 let mut totloop: u32 = 0;
    //                                 totloop += (buffer[skip_bytes] as u32) << 0;
    //                                 totloop += (buffer[skip_bytes + 1] as u32) << 8;
    //                                 totloop += (buffer[skip_bytes + 2] as u32) << 16;
    //                                 totloop += (buffer[skip_bytes + 3] as u32) << 24;
    //                                 // println!("    totloop = {}", totloop);
    //                                 skip_bytes += 4;
    //                                 // mat_nr
    //                                 // let mut mat_nr: u16 = 0;
    //                                 // mat_nr += (buffer[skip_bytes] as u16) << 0;
    //                                 // mat_nr += (buffer[skip_bytes + 1] as u16) << 8;
    //                                 // println!("    mat_nr = {}", mat_nr);
    //                                 skip_bytes += 2;
    //                                 // flag
    //                                 let flag: u8 = buffer[skip_bytes];
    //                                 // println!("    flag = {}", flag);
    //                                 is_smooth = flag % 2 == 1;
    //                                 // println!("    is_smooth = {}", is_smooth);
    //                                 skip_bytes += 1;
    //                                 // pad
    //                                 // println!("    pad = {}", buffer[skip_bytes]);
    //                                 skip_bytes += 1;
    //                                 // PBRT
    //                                 if totloop == 3_u32 {
    //                                     loops.push(totloop as u8);
    //                                     // triangle
    //                                     for i in 0..3 {
    //                                         vertex_indices.push(
    //                                             loop_indices[(loopstart + i) as usize] as u32,
    //                                         );
    //                                     }
    //                                 } else if totloop == 4_u32 {
    //                                     loops.push(totloop as u8);
    //                                     // quads
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 0) as usize] as u32);
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 1) as usize] as u32);
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 2) as usize] as u32);
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 0) as usize] as u32);
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 2) as usize] as u32);
    //                                     vertex_indices
    //                                         .push(loop_indices[(loopstart + 3) as usize] as u32);
    //                                 } else {
    //                                     println!(
    //                                         "WARNING: quads or triangles expected (totloop = {}): {:?}",
    //                                         totloop, base_name
    //                                     )
    //                                 }
    //                             }
    //                         // println!("  vertex_indices = {:?}", vertex_indices);
    //                         } else if types[type_id] == "MVert" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             let mut skip_bytes: usize = 0;
    //                             let factor: f32 = 1.0 / 32767.0;
    //                             let mut coords: [f32; 3] = [0.0_f32; 3];
    //                             for _v in 0..data_len {
    //                                 // println!("  {}:", v + 1);
    //                                 // co
    //                                 for i in 0..3 {
    //                                     let mut co_buf: [u8; 4] = [0_u8; 4];
    //                                     for b in 0..4 as usize {
    //                                         co_buf[b] = buffer[skip_bytes + b];
    //                                     }
    //                                     let co: f32 = unsafe { mem::transmute(co_buf) };
    //                                     // println!("    co[{}] = {}", i, co);
    //                                     coords[i] = co;
    //                                     skip_bytes += 4;
    //                                 }
    //                                 p.push(Point3f {
    //                                     x: (coords[0] * scale_length) as Float,
    //                                     y: (coords[1] * scale_length) as Float,
    //                                     z: (coords[2] * scale_length) as Float,
    //                                 });
    //                                 // no
    //                                 for i in 0..3 {
    //                                     let mut no: i16 = 0;
    //                                     no += (buffer[skip_bytes] as i16) << 0;
    //                                     no += (buffer[skip_bytes + 1] as i16) << 8;
    //                                     let nof: f32 = no as f32 * factor;
    //                                     // println!("    no[{}] = {}", i, nof);
    //                                     coords[i] = nof;
    //                                     skip_bytes += 2;
    //                                 }
    //                                 n.push(Normal3f {
    //                                     x: coords[0] as Float,
    //                                     y: coords[1] as Float,
    //                                     z: coords[2] as Float,
    //                                 });
    //                                 // flag
    //                                 // println!("    flag = {}", buffer[skip_bytes]);
    //                                 skip_bytes += 1;
    //                                 // bweight
    //                                 // println!("    bweight = {}", buffer[skip_bytes]);
    //                                 skip_bytes += 1;
    //                             }
    //                         // for v in 0..data_len as usize {
    //                         //     println!("  {}:", v + 1);
    //                         //     println!("    co: {:?}", p[v]);
    //                         //     println!("    no: {:?}", n[v]);
    //                         // }
    //                         } else if types[type_id] == "MLoop" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             let mut skip_bytes: usize = 0;
    //                             for _l in 0..data_len {
    //                                 // println!("  {}:", l + 1);
    //                                 // v
    //                                 let mut v: u32 = 0;
    //                                 v += (buffer[skip_bytes] as u32) << 0;
    //                                 v += (buffer[skip_bytes + 1] as u32) << 8;
    //                                 v += (buffer[skip_bytes + 2] as u32) << 16;
    //                                 v += (buffer[skip_bytes + 3] as u32) << 24;
    //                                 // println!("    v = {}", v);
    //                                 loop_indices.push(v);
    //                                 skip_bytes += 4;
    //                                 // e
    //                                 // let mut e: u32 = 0;
    //                                 // e += (buffer[skip_bytes] as u32) << 0;
    //                                 // e += (buffer[skip_bytes + 1] as u32) << 8;
    //                                 // e += (buffer[skip_bytes + 2] as u32) << 16;
    //                                 // e += (buffer[skip_bytes + 3] as u32) << 24;
    //                                 // println!("    e = {}", e);
    //                                 skip_bytes += 4;
    //                             }
    //                         // println!("    loop_indices = {:?}", loop_indices);
    //                         } else if types[type_id] == "MLoopUV" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             let mut skip_bytes: usize = 0;
    //                             let mut coords: [f32; 2] = [0.0_f32; 2];
    //                             for _l in 0..data_len {
    //                                 // println!("  {}:", l + 1);
    //                                 // float uv[2]
    //                                 for i in 0..2 {
    //                                     let mut uv_buf: [u8; 4] = [0_u8; 4];
    //                                     for b in 0..4 as usize {
    //                                         uv_buf[b] = buffer[skip_bytes + b];
    //                                     }
    //                                     let uv: f32 = unsafe { mem::transmute(uv_buf) };
    //                                     // println!("    uv[{}] = {}", i, uv);
    //                                     coords[i] = uv;
    //                                     skip_bytes += 4;
    //                                 }
    //                                 uvs.push(Point2f {
    //                                     x: coords[0] as Float,
    //                                     y: coords[1] as Float,
    //                                 });
    //                                 // int flag
    //                                 skip_bytes += 4;
    //                             }
    //                         // for l in 0..data_len as usize {
    //                         //     println!("  {}:", l + 1);
    //                         //     println!("    uv: {:?}", uvs[l]);
    //                         // }
    //                         } else if types[type_id] == "MLoopCol" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             // println!("  base_name = {}", base_name);
    //                             let mut skip_bytes: usize = 0;
    //                             for _l in 0..data_len {
    //                                 // r
    //                                 let mut red: u8 = 0;
    //                                 red += buffer[skip_bytes];
    //                                 skip_bytes += 1;
    //                                 // g
    //                                 let mut green: u8 = 0;
    //                                 green += buffer[skip_bytes];
    //                                 skip_bytes += 1;
    //                                 // b
    //                                 let mut blue: u8 = 0;
    //                                 blue += buffer[skip_bytes];
    //                                 skip_bytes += 1;
    //                                 // a
    //                                 let mut alpha: u8 = 0;
    //                                 alpha += buffer[skip_bytes];
    //                                 skip_bytes += 1;
    //                                 // println!("{}: {}, {}, {}, {}", l, red, green, blue, alpha);
    //                                 vertex_colors.push(red);
    //                                 vertex_colors.push(green);
    //                                 vertex_colors.push(blue);
    //                                 vertex_colors.push(alpha);
    //                             }
    //                             // println!("vertex_colors: {:?}", vertex_colors);
    //                         }
    //                     } else if data_following_object {
    //                         // type_id
    //                         let type_id: usize = dna_2_type_id[sdna_nr as usize] as usize;
    //                         if types[type_id] == "IDProperty" {
    //                             // println!("{}[{}] ({})", code, data_len, len);
    //                             // println!("  SDNAnr = {}", sdna_nr);
    //                             // println!("  {} ({})", types[type_id], tlen[type_id]);
    //                             let mut skip_bytes: usize = 0;
    //                             for _p in 0..data_len {
    //                                 // println!("  {}:", p + 1);
    //                                 // next
    //                                 skip_bytes += 8;
    //                                 // prev
    //                                 skip_bytes += 8;
    //                                 // type
    //                                 let prop_type: u8 = buffer[skip_bytes] as u8;
    //                                 // println!("  prop_type = {}", prop_type);
    //                                 skip_bytes += 1;
    //                                 if prop_type == 8_u8 {
    //                                     // IDP_DOUBLE (see DNA_ID.h)
    //                                     // subtype
    //                                     skip_bytes += 1;
    //                                     // flag
    //                                     skip_bytes += 2;
    //                                     // char name[64]
    //                                     let mut prop_name = String::new();
    //                                     for i in 0..64 {
    //                                         if buffer[skip_bytes + i] == 0 {
    //                                             break;
    //                                         }
    //                                         prop_name.push(buffer[skip_bytes + i] as char);
    //                                     }
    //                                     // if prop_name.len() > 0 {
    //                                     //     println!(
    //                                     //         "  prop_name[{}] = {}",
    //                                     //         prop_name.len(),
    //                                     //         prop_name
    //                                     //     );
    //                                     // }
    //                                     skip_bytes += 64;
    //                                     // saved
    //                                     skip_bytes += 4;
    //                                     // v279: data (len=32)
    //                                     // v280: data (len=32)
    //                                     skip_bytes += 8;
    //                                     // group
    //                                     skip_bytes += 16;
    //                                     // val
    //                                     // val2
    //                                     let mut val_buf: [u8; 8] = [0_u8; 8];
    //                                     for b in 0..8 as usize {
    //                                         val_buf[b] = buffer[skip_bytes + b];
    //                                     }
    //                                     let prop_val: f64 = unsafe { mem::transmute(val_buf) };
    //                                     // println!("  prop_val = {}", prop_val);
    //                                     skip_bytes += 8;
    //                                     if base_name.starts_with("PbrtSphere")
    //                                         || base_name.starts_with("PbrtCylinder")
    //                                         || base_name.starts_with("PbrtDisk")
    //                                     {
    //                                         // println!(
    //                                         //     "  {}.{} = {}",
    //                                         //     base_name, prop_name, prop_val
    //                                         // );
    //                                         if prop_name == String::from("height") {
    //                                             prop_height = prop_val;
    //                                         }
    //                                         if prop_name == String::from("radius") {
    //                                             prop_radius = prop_val;
    //                                         }
    //                                         if prop_name == String::from("innerradius") {
    //                                             prop_innerradius = prop_val;
    //                                         }
    //                                         if prop_name == String::from("zmin") {
    //                                             prop_zmin = prop_val;
    //                                         }
    //                                         if prop_name == String::from("zmax") {
    //                                             prop_zmax = prop_val;
    //                                         }
    //                                         if prop_name == String::from("phimax") {
    //                                             prop_phimax = prop_val;
    //                                         }
    //                                     }
    //                                 }
    //                             }
    //                         }
    //                     }
    //                 } else {
    //                     if data_following_object {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // store sphere values for later
    //                             let pbrt_sphere: PbrtSphere = PbrtSphere::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             spheres_hm.insert(base_name.clone(), pbrt_sphere);
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // store cylinder values for later
    //                             let pbrt_cylinder: PbrtCylinder = PbrtCylinder::new(
    //                                 prop_radius as f32,
    //                                 prop_zmin as f32,
    //                                 prop_zmax as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             cylinders_hm.insert(base_name.clone(), pbrt_cylinder);
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // store disk values for later
    //                             let pbrt_disk: PbrtDisk = PbrtDisk::new(
    //                                 prop_height as f32,
    //                                 prop_radius as f32,
    //                                 prop_innerradius as f32,
    //                                 prop_phimax as f32,
    //                             );
    //                             disks_hm.insert(base_name.clone(), pbrt_disk);
    //                         }
    //                     }
    //                     if data_following_mesh {
    //                         if base_name.starts_with("PbrtSphere") {
    //                             // create sphere after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(sphere) = spheres_hm.get(&base_name) {
    //                                 builder.add_sphere(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     sphere.radius,
    //                                     sphere.zmin,
    //                                     sphere.zmax,
    //                                     sphere.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtCylinder") {
    //                             // create cylinder after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(cylinder) = cylinders_hm.get(&base_name) {
    //                                 builder.add_cylinder(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     cylinder.radius,
    //                                     cylinder.zmin,
    //                                     cylinder.zmax,
    //                                     cylinder.phimax,
    //                                 );
    //                             }
    //                         } else if base_name.starts_with("PbrtDisk") {
    //                             // create disk after mesh data
    //                             if let Some(o2w) = object_to_world_hm.get(&base_name) {
    //                                 object_to_world = *o2w;
    //                             } else {
    //                                 println!(
    //                                     "WARNING: looking up object_to_world by name ({:?}) failed",
    //                                     base_name
    //                                 );
    //                             }
    //                             let world_to_object: Transform =
    //                                 Transform::inverse(&object_to_world);
    //                             if let Some(disk) = disks_hm.get(&base_name) {
    //                                 builder.add_disk(
    //                                     base_name.clone(),
    //                                     object_to_world,
    //                                     world_to_object,
    //                                     disk.height,
    //                                     disk.radius,
    //                                     disk.innerradius,
    //                                     disk.phimax,
    //                                 );
    //                             }
    //                         } else {
    //                             read_mesh(
    //                                 &base_name,
    //                                 &object_to_world_hm,
    //                                 &mut object_to_world,
    //                                 &p,
    //                                 &n,
    //                                 &mut uvs,
    //                                 &loops,
    //                                 vertex_indices.clone(),
    //                                 vertex_colors.clone(),
    //                                 is_smooth,
    //                                 &mut builder,
    //                             );
    //                         }
    //                         vertex_indices.clear();
    //                         vertex_colors.clear();
    //                     }
    //                     // reset booleans
    //                     data_following_mesh = false;
    //                     data_following_object = false;
    //                     is_smooth = false;
    //                 }
    //                 if code != String::from("DATA")
    //                     && code != String::from("REND")
    //                     && code != String::from("TEST")
    //                 {
    //                     let type_id: usize = dna_2_type_id[sdna_nr as usize] as usize;
    //                     if len != tlen[type_id] as u32 {
    //                         println!("WARNING: {} ({} != {})", code, len, tlen[type_id]);
    //                     }
    //                 }
    //             }
    //         }
    //         println!("{} bytes read", counter);
    //     }
    // }

    // TODO
    // use HDR image if one was found
    if !hdr_path.is_empty() {
        let axis: Vector3f = Vector3f {