pathtracer.h

/*
 * Fermat
 *
 * Copyright (c) 2016-2019, NVIDIA CORPORATION. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * Neither the name of the NVIDIA CORPORATION nor the
 *      names of its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <types.h>
#include <buffers.h>
#include <ray.h>
#include <tiled_sequence.h>
#include <cugar/sampling/lfsr.h>
#include <cugar/sampling/variance.h>
#include <cugar/linalg/bbox.h>
#include <renderer_interface.h>

struct RenderingContext;
struct MeshVTLStorage;
struct ClusteredRLStorage;
struct AdaptiveClusteredRLStorage;





enum NEEAlgorithm {
    NEE_ALGORITHM_MESH  = 0,
    NEE_ALGORITHM_VPL   = 1,
    NEE_ALGORITHM_RL    = 2
};

struct PTOptions
{
    uint32  max_path_length;
    uint32  direct_lighting         : 1;
    uint32  direct_lighting_nee     : 1;
    uint32  direct_lighting_bsdf    : 1;
    uint32  indirect_lighting_nee   : 1;
    uint32  indirect_lighting_bsdf  : 1;
    uint32  visible_lights          : 1;
    uint32  diffuse_scattering      : 1;
    uint32  glossy_scattering       : 1;
    uint32  indirect_glossy         : 1;
    uint32  rr                      : 1;
    uint32  nee_type                : 2;
    uint32  backend;

    #if !defined(OPTIX_COMPILATION)
    PTOptions() :
        max_path_length(6),
        direct_lighting_nee(true),
        direct_lighting_bsdf(true),
        indirect_lighting_nee(true),
        indirect_lighting_bsdf(true),
        visible_lights(true),
        direct_lighting(true),
        diffuse_scattering(true),
        glossy_scattering(true),
        indirect_glossy(false),
        rr(true),
        nee_type(NEE_ALGORITHM_VPL),
        backend(0) {}
    #endif

    void parse(const int argc, char** argv)
    {
        for (int i = 0; i < argc; ++i)
        {
            if (strcmp(argv[i], "-pl") == 0 ||
                strcmp(argv[i], "-path-length") == 0 ||
                strcmp(argv[i], "-max-path-length") == 0)
                max_path_length = atoi(argv[++i]);
            else if (strcmp(argv[i], "-bounces") == 0)
                max_path_length = atoi(argv[++i]) + 1;
            else if (strcmp(argv[i], "-nee") == 0)
                direct_lighting_nee = indirect_lighting_nee = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-bsdf") == 0)
                direct_lighting_bsdf = indirect_lighting_bsdf = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-direct-nee") == 0)
                direct_lighting_nee = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-direct-bsdf") == 0)
                direct_lighting_bsdf = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-indirect-nee") == 0)
                indirect_lighting_nee = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-indirect-bsdf") == 0)
                indirect_lighting_bsdf = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-visible-lights") == 0)
                visible_lights = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-direct-lighting") == 0)
                direct_lighting = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-indirect-glossy") == 0)
                indirect_glossy = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-diffuse") == 0)
                diffuse_scattering = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-glossy") == 0)
                glossy_scattering = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-rr") == 0)
                rr = atoi(argv[++i]) > 0;
            else if (strcmp(argv[i], "-nee-algorithm") == 0 ||
                     strcmp(argv[i], "-nee-alg") == 0)
            {
                if (strcmp(argv[i+1], "mesh") == 0)
                    nee_type = NEE_ALGORITHM_MESH;
                else if (strcmp(argv[i+1], "vpl") == 0)
                    nee_type = NEE_ALGORITHM_VPL;
                else if (strcmp(argv[i+1], "rl") == 0)
                    nee_type = NEE_ALGORITHM_RL;

                ++i;
            }
        }
    }
};

struct PTStats
{
    cugar::Variance_estimator<float> primary_rt_time;
    cugar::Variance_estimator<float> path_rt_time;
    cugar::Variance_estimator<float> shadow_rt_time;
    cugar::Variance_estimator<float> path_shade_time;
    cugar::Variance_estimator<float> shadow_shade_time;
};

struct PathTracer : RendererInterface
{
    //typedef ClusteredRLStorage    VTLRLStorage;
    typedef AdaptiveClusteredRLStorage  VTLRLStorage;

    PathTracer();

    void init(int argc, char** argv, RenderingContext& renderer);

    void render(const uint32 instance, RenderingContext& renderer);

    void setup_samples(const uint32 instance);

    void keyboard(unsigned char character, int x, int y, bool& invalidate);

    void destroy() { delete this; }

    void dump_speed_stats(FILE* stats);

    void update_vtls_rl(const uint32 instance);

    static RendererInterface* factory() { return new PathTracer(); }

    DomainBuffer<CUDA_BUFFER, uint8>    m_memory_pool;

    PTOptions                   m_options;
    TiledSequence               m_sequence;

    cugar::LFSRGeneratorMatrix  m_generator;
    cugar::LFSRRandomStream     m_random;

    MeshVTLStorage*             m_mesh_vtls;
    VTLRLStorage*               m_vtls_rl;
    cugar::Bbox3f               m_bbox;

    float                       m_time;

    uint32                      m_pathtracer_raygen;

    PTStats                     m_stats;
};