It would be nice to have the following features:

• Each message has their own level. Which level to be output can be configurable.
• Each message also has their own type. One message can have multiple types at the same time.
• Multiple output streams support. ( Visual studio output, external log file.)
• Better implementation. Logging system doesn't need to be a singleton, global variable may be a better choice for all-life-time access.

This is a relatively big issue.
I haven't paid much attention since the project is transferred to github.

Relatively low priority.

Somehow the fourier BSDF is very noisy, which is especially true for transparent material.
Need to investigate it.

Enhance code on math operation

Should be an easy task.

Current build system only supports visual studio on windows.

CMake file is only used to generate .slh project for visual studio now.

Need to work on it so that it can also generate makefile for Mac and Ubuntu.

Export the scene from Blender to PBRT so that we have a reference renderer to compare.

Current implementation is a rough one and it doesn't work on Mac.

blender bxdf layer.
Current implementation of blending bxdf is not flexible because the blender factors can't be varied depending on the specific shading case.
Things like fresnel blending won't be supported.

Use the way that doxygen understands so that a reference manual can be generated automatically.

SORT supports multi-thread rendering. However, in order further exploit parallelism, cross machine rendering on a network may be a desired feature.

Current microfacet model only supports brdf, microfacet transmitance is in the plan.

Need investigation.

Delta function introduces many special cases in basically every integrator. And it is likely impossible to sample a path with delta bxdf and delta light directly connected in current design.
Although it reduces dimension and increases performance a little, I don't particularly like its presence in my renderer because it can be totally replaced by Microfacet bxdf.

Need to delete the two bxdf in the near future.

Not well implemented so far.

It should improve the performance of uniform grid, kd-tree.

8x16 is an example that fails the plugin.

It seems that LTS is not well supported on Mac.
Need to find a workaround or fix the LTS issue.

Use shared memory to update progress in Blender

Current implementation is very noisy even if the spp is large.

The convergence rate of sampling microfacet brdf highly depends on its roughness, the less rougher it is, the more spiky the brdf is, thus it is more difficult to sample it, if not impossible.

Current implementation of material UI is far from being done, need to fix that.

Serialization of the following input:

• scene description
• material
• texture ( may not be necessary depending on situation )

It has been a while before my last update on ubuntu...
Hopefully I have some time on this one.

Priority is relatively low.

Need to fix that.

Need to check if there is anything new in BVH implementation comparing with the pervious version (pbrt v2).

Path tracing appears a little dimmer when DOF is enabled.
It doesn't happen to BDPT, light tracing or naive BDPT.

Will follow up the issue.

Sometimes material is missing at the start of Blender.

It seems that certain material information is lost somehow.

IO operation is relatively slow comparing with shared memory.
It may take me some time because it needs serialisation the whole scene information before starting it.

Import the data so that it is automatically converted to SORT data.

I find this error with MSVC 2013 under win7 x64. I are fixed on my local repo with this changes:

struct Splits
    {
#if defined(_MSC_VER) && _MSC_VER == 1800
        // Fix error c2536 under msvc 2013
        Split*		split[3] = {};      /**< Split planes along three different axis. */
        unsigned	split_c[3] = {};    /**< Number of split planes in each different axis. */
#else
        Split*		split[3] = { nullptr, nullptr, nullptr }; /**< Split planes along three different axis. */
        unsigned	split_c[3] = { 0, 0, 0 };                 /**< Number of split planes in each different axis. */
#endif
        //! Release the allcoated memory.
        void Release()
        {
            SAFE_DELETE_ARRAY(split[0]);
            SAFE_DELETE_ARRAY(split[1]);
            SAFE_DELETE_ARRAY(split[2]);
        }
    };

Greetings..

Only bmp and exr texture file formats are currently support in SORT now.
Need to support more.

Current plan is to use a light-weight simple library CImg.
An alternative is to make one by myself, however it takes longer time and may not be as robust as CImg if less effort is devoted on it.

The current implementation of BDPT is far from a correct one.
Need to fix it in the future.