Look at chapter 16.2 of the Physically Based Rendering book for the theoretical background on this topic and a simple test scene for caustics. Let's use that scene to see caustic from light passing through the glass becoming increasingly sharper.

Compare C++ vs. Rust render times (on purism laptop) :

$ time ~/builds/pbrt/release/pbrt anim-bluespheres.pbrt
pbrt version 3 (built Apr  1 2019 at 17:45:44) [Detected 4 cores]
Copyright (c)1998-2018 Matt Pharr, Greg Humphreys, and Wenzel Jakob.
The source code to pbrt (but *not* the book contents) is covered by the BSD License.
See the file LICENSE.txt for the conditions of the license.
Rendering: [++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++]  (897.6s)
Statistics:
...
real    14m58.087s
user    52m55.853s
sys     0m0.932s

So, the C++ implementation needs about 15 minutes on a 4 processor Linux laptop.

Recently (in July 2017) Matt Pharr added the DisneyMaterial to the C++ version of PBRT:

commit d9bfba3e9f185894a67563e9c52b55381fcfeef4
Author: Matt Pharr <[email protected]>
Date:   Tue Jul 11 17:07:05 2017 -0700

    Added implementation of Disney BSDF
    
    Specifically, this is the extended model with integrated subsurface
    scattering described in
    http://blog.selfshadow.com/publications/s2015-shading-course/burley/s201
    5_pbs_disney_bsdf_notes.pdf.

Let's do the same on the Rust side ...

The test scene ~/git/gitlab/rs-pbrt-test-scenes/pbrt/pbrt_vw_van/vw-van.pbrt uses a fourier material:

$ rg fourier /home/jan/git/gitlab/rs-pbrt-test-scenes/pbrt/pbrt_vw_van
/home/jan/git/gitlab/rs-pbrt-test-scenes/pbrt/pbrt_vw_van/vw-van.pbrt
55:    "string type" "fourier" "string bsdffile" "bsdfs/ceramic.bsdf"

On the C++ side we have this class:

// FourierMaterial Declarations
class FourierMaterial : public Material {
  public:
    // FourierMaterial Public Methods
    FourierMaterial(const std::string &filename,
                    const std::shared_ptr<Texture<Float>> &bump);
    void ComputeScatteringFunctions(SurfaceInteraction *si, MemoryArena &arena,
                                    TransportMode mode,
                                    bool allowMultipleLobes) const;

  private:
    // FourierMaterial Private Data
    FourierBSDFTable *bsdfTable;
    std::shared_ptr<Texture<Float>> bumpMap;
    static std::map<std::string, std::unique_ptr<FourierBSDFTable>> loadedBSDFs;
};

We have to implement the Rust counterpart ...

Did we break anything by replacing the sampler traits by enum?

Integrator "ambientocclusion":

> imf_diff -d -f pbrt_rust.exr pbrt.exr
pbrt_rust.exr pbrt.exr: no differences.
== "pbrt_rust.exr" and "pbrt.exr" are identical

Integrator "directlighting" "integer maxdepth" [10]:

> imf_diff -d -f pbrt_rust.exr pbrt.exr
pbrt_rust.exr pbrt.exr: no differences.
== "pbrt_rust.exr" and "pbrt.exr" are identical

Integrator "whitted" "integer maxdepth" [5]:

> imf_diff -d -f pbrt_rust.exr pbrt.exr
pbrt_rust.exr pbrt.exr: no differences.
== "pbrt_rust.exr" and "pbrt.exr" are identical

Integrator "path":

> imf_diff -d -f pbrt_rust.exr pbrt.exr
pbrt_rust.exr pbrt.exr: no differences.
== "pbrt_rust.exr" and "pbrt.exr" are identical

Integrator "bdpt":

> imf_diff -d -f pbrt_rust.exr pbrt.exr diff.jpg
differing pixels:	 81.946% (204866 of 250000)
average difference:	 12.432%
maximum difference:	 85.706%
Summary: Many pixels differ strongly.
== "pbrt_rust.exr" and "pbrt.exr" are different

Once we solved issue #37 to create curves, which can be used as hair, we need a matching HairMaterial:

$ rg '"hair"' ~/Graphics/Rendering/PBRT/pbrt-v3-scenes/hair/
/home/jan/Graphics/Rendering/PBRT/pbrt-v3-scenes/hair/curly-hair.pbrt
14:	Material "hair" "float eumelanin" .3

/home/jan/Graphics/Rendering/PBRT/pbrt-v3-scenes/hair/straight-hair.pbrt
14:	MakeNamedMaterial "black_hair" "string type" [ "hair" ] "float eumelanin" [ 8 ]
15:	MakeNamedMaterial "red_hair" "string type" [ "hair" ] "float eumelanin" [ 3 ]
16:	MakeNamedMaterial "brown_hair" "string type" [ "hair" ] "float eumelanin" [ 1.3 ] "float beta_m" .25 "float alpha" 2
17:	MakeNamedMaterial "blonde_hair" "string type" [ "hair" ] "float	eumelanin" [ .3 ]

/home/jan/Graphics/Rendering/PBRT/pbrt-v3-scenes/hair/sphere-hairblock.pbrt
17:  Material "hair" "rgb color" [ .2 .8 .3 ]

Here is the source code for the C++ implementation:

$ rg -tcpp "class HairMaterial :" ~/git/github/pbrt-v3/src/
/home/jan/git/github/pbrt-v3/src/materials/hair.h
57:class HairMaterial : public Material {

I'm going to move the documentation to a new web page:

https://www.rs-pbrt.org/doc/crates/pbrt/index.html

There are some hardcoded paths to https://www.janwalter.org which have to be replaced by relative paths:

> rg -trust janwalter
src/lib.rs
18://! [here]: https://www.janwalter.org/doc/rust/pbrt/integrators/fn.render.html
19://! [render_bdpt]: https://www.janwalter.org/doc/rust/pbrt/integrators/bdpt/fn.render_bdpt.html
20://! [render_mlt]: https://www.janwalter.org/doc/rust/pbrt/integrators/mlt/fn.render_mlt.html

src/integrators/mod.rs
23://! ![Ambient Occlusion](https://www.janwalter.org/assets/cornell_box_pbrt_rust_ao.png)
33://! ![Direct Lighting](https://www.janwalter.org/assets/cornell_box_v0.1.13.png)
40://! ![Path Tracing](https://www.janwalter.org/assets/cornell_box_v0.2.0_high.png)
51://! Tracing](https://www.janwalter.org/assets/art_gallery_pbrt_rust_07n.png)

src/media/mod.rs
10://! ![A Volumetric Caustic](https://www.janwalter.org/assets/volume-caustic.png)

src/integrators/bdpt.rs
2177:/// ![bdpt](https://www.janwalter.org/assets/uml/pbrt/render_bdpt.png)

src/integrators/mlt.rs
390:/// ![bdpt](https://www.janwalter.org/assets/uml/pbrt/render_mlt.png)

src/cameras/mod.rs
18://! ![Perspective Camera](https://www.janwalter.org/assets/Perspectiva-2.png)

src/materials/mod.rs
21://! ![HairMaterial](https://www.janwalter.org/assets/hair_rust_pbrt.png)
25://! ![SubstrateMaterial](https://www.janwalter.org/assets/ganesha.png)

src/samplers/mod.rs
19://! ![halton](https://www.janwalter.org/assets/pbrt_rust_halton.png)
28://! ![random](https://www.janwalter.org/assets/pbrt_rust_random.png)
37://! ![sobol](https://www.janwalter.org/assets/pbrt_rust_sobol.png)
49://! ![lowdiscrepancy](https://www.janwalter.org/assets/pbrt_rust_lowdiscrepancy.png)

I will add a new test scene to the GitLab repository (for test scenes):

This will probably spawn more issues to be created. For example we will have to implement a new material, FourierMaterial:

$ rg bsdf -B 1  
vw-van.pbrt
54-MakeNamedMaterial "Mat.1"  # white painted stuff
55:    "string type" "fourier" "string bsdffile" "bsdfs/ceramic.bsdf"

Which can read .bsdf files. I'm also not sure if the already existing MetalMaterial can read .spd files:

$ rg spd -B 3
vw-van.pbrt
49-MakeNamedMaterial "Metal - Chrome" 
50-        "float roughness" [ 0.01 ] 
51-        "string type" [ "metal" ] 
52:        "spectrum k" "spds/Al.k.spd"
53:        "spectrum eta" "spds/Al.eta.spd"

Goal of this issue is to document the progress until we can render the entire VW test scene without changes ...

Since commit 87b0b5ecb94aaada973381bde8e9497eb9eeb14d we can generate bootstrap paths multi-threaded. While debugging something else I figured that the generated bootstrap samples differ slightly between the C++ and Rust version. To dig deeper into the problem I modified both versions to print out very specialized information regarding the test scene (assets/scenes/caustic.pbrt) and the resulting bootstrap samples.

In Rust (src/core/sampling.rs):

impl Distribution1D {
    pub fn new(f: Vec<Float>) -> Self {
        let n: i32 = f.len() as i32;
        // compute integral of step function at $x_i$
        let mut cdf: Vec<Float> = Vec::with_capacity(n as usize + 1);
        cdf.push(0.0 as Float);
        for i in 1..(n + 1) {
...
            if n == 600000 && f[(i - 1) as usize] > 0.0 as Float {
                println!("f[{:?}] = {1:2.8}", i - 1, f[(i - 1) as usize]);
            }
        }
...
    }
...
}

In C++ (src/core/sampling.h):

struct Distribution1D {
    // Distribution1D Public Methods
    Distribution1D(const Float *f, int n) : func(f, f + n), cdf(n + 1) {
        // Compute integral of step function at $x_i$
        cdf[0] = 0;
        for (int i = 1; i < n + 1; ++i) {
          if (n == 600000 && f[i - 1] > 0.0) {
            printf("f[%d] = %2.8f\n", i - 1, f[i - 1]);
          }
...
    }
...
};

I will attach the resulting difference between both versions to the issue and report on any progress ...

For debugging we use a lower resolution and the bdpt integrator, instead of mlt:

diff --git a/assets/scenes/caustic.pbrt b/assets/scenes/caustic.pbrt                                                                        
index 382670a..c17389a 100644                                                                                                               
--- a/assets/scenes/caustic.pbrt                                                                                                            
+++ b/assets/scenes/caustic.pbrt                                                                                                            
@@ -3,11 +3,12 @@ MakeNamedMedium "vol"                                                                                                     
         "rgb sigma_a" [ 0.0199999996 0.0199999996 0.0199999996 ]                                                                           
         "rgb sigma_s" [ 0.3499999940 0.3499999940 0.3499999940 ]                                                                           
 Film "image"                                                                                                                               
-        "integer xresolution" [ 800 ]                                                                                                      
-        "integer yresolution" [ 800 ]                                                                                                      
-        "string filename" [ "caustic.exr" ]                                                                                                
-Integrator "mlt"                                                                                                                           
-        "integer mutationsperpixel" [ 16384 ]                                                                                              
+        "integer xresolution" [ 400 ]                                                                                                      
+        "integer yresolution" [ 400 ]                                                                                                      
+        "string filename" [ "f16-22a.exr" ]                                                                                                
+Sampler "02sequence"                                                                                                                       
+        "integer pixelsamples" [ 64 ]                                                                                                      
+Integrator "bdpt"                                                                                                                          
 MediumInterface "" "vol"                                                                                                                   
 LookAt -0.75 0.800000012 -1.25                                                                                                             
         -1 0.800000012 0                                                                                                                   
@@ -30,7 +31,7 @@ AttributeEnd                                                                                                              
 AttributeBegin                                                                                                                             
     Rotate -60 0 0 1                                                                                                                       
     LightSource "infinite"                                                                                                                 
-            "string mapname" [ "textures/skylight-day.hdr" ]                                                                               
+            "string mapname" [ "textures/skylight-day.exr" ]                                                                               
             "rgb scale" [ 1.5000000000 1.5000000000 1.3999999762 ]                                                                         
 AttributeEnd                                                                                                                               
 LightSource "spot"                                                                                                                         

We can render the scene with bdpt (bi-directional path tracing) but the results of the C++ and Rust versions render very differently:

> imf_diff -d f16-22a_cpp.png f16-22a_rust.png diff.jpg
differing pixels:	100.000% (160000 of 160000)
average difference:	 51.499%
maximum difference:	 86.603%
Summary: Many pixels differ strongly.
== "f16-22a_cpp.png" and "f16-22a_rust.png" are different

The pest crate reached now version 1.0 (or later): https://github.com/pest-parser/pest This needs some re-writing of the current code in examples/pest_test.rs.

Hey @wahn , It finally happened. I found time again to work on communication with tev. This definitely is just a barely working prototype, but it can actually display progress while rendering. It is just full of unwraps that should be handled properly and many things are done in a very un-rust way, but we have something that works somewhat. At the moment the values sent to tev are not scaled properly and I would love to work on fixing and improving from here on with you together if you can find time.

It would be useful to be able to specify depth of field (DOF) settings within the Blender scene and use those on the rs-pbrt side. For .pbrt files those should work correctly already, but forparse_blend_file we still need a way how to translate the settings from the Blender UI to camera settings, which can be used for e.g. the struct PerspectiveCamera. Here an example from the Italian Flat scene:

In Blender version 2.79 the two settings in questions are shown here:

The depth of field distance can be used as parameter focaldistance directly, but Blender's f-stop value has to be translated somehow to PBRT's lensradius (in this example I used lensradius = 0.0125):

diff --git a/src/cameras/perspective.rs b/src/cameras/perspective.rs                                  
index 92c77db..72f9d98 100644                                                                         
--- a/src/cameras/perspective.rs                                                                      
+++ b/src/cameras/perspective.rs                                                                      
@@ -173,6 +173,10 @@ impl PerspectiveCamera {                                                         
         //     params.find_one_float(String::from("halffov"), -1.0);                                 
         // TODO: if (halffov > 0.f)                                                                  
         // TODO: let perspective_camera: Arc<Camera + Sync + Send> =                                 
+       // TMP                                                                                        
+        let lensradius: Float = 0.0125;                                                              
+        let focaldistance: Float = 5.6;                                                              
+       // TMP                                                                                        
         Arc::new(Camera::Perspective(Box::new(PerspectiveCamera::new(                                
             cam2world,                                                                               
             screen,                                                                                  

The best solution would be to look into Blender's source code to find a proper translation hint.

On the Blender Cloud there is a project called Attic Close-up (by Gleb Alexandrov). You can download a Blender scene from there. The goal of this issue is to create a similar Blender (version 2.79) scene, which can be used to render directly with parse_blend_file (see examples folder).