renderer_impl.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 <renderer.h>
#include <buffers.h>
#include <framebuffer.h>
#include <texture.h>
#include <camera.h>
#include <ray.h>
#include <lights.h>
#include <mesh_lights.h>
#include <mesh/MeshStorage.h>
#include <vector>
#include <renderer_view.h>
#include <renderer_interface.h>
#include <tiled_sequence.h>
#include <dll.h>


struct RenderingContext;

struct RenderingContextImpl
{
    typedef RenderingContext::HostMipMapStoragePtr      HostMipMapStoragePtr;
    typedef RenderingContext::DeviceMipMapStoragePtr    DeviceMipMapStoragePtr;
    typedef DomainBuffer<HOST_BUFFER, DirectionalLight> HostDirectionalLightVector;
    typedef DomainBuffer<CUDA_BUFFER, DirectionalLight> DeviceDirectionalLightVector;

    RenderingContextImpl(RenderingContext* _context) : m_this( _context ) {}

    void init(int argc, char** argv);

    void render(const uint32 instance);

    void clear();

    void multiply_frame(const float scale);

    void rescale_frame(const uint32 instance);

    void clamp_frame(const float max_value);

    void update_variances(const uint32 instance);

    void update_model();

    void filter(const uint32 instance);

    uint2 res() const { return make_uint2(m_res_x, m_res_y); }

    RenderingContextView view(const uint32 instance);

    Camera& get_camera() { return m_camera; }

    uint2 get_res() const { return make_uint2(m_res_x, m_res_y); }

    float get_aspect_ratio() const { return m_aspect; }

    float get_exposure() const { return m_exposure; }

    float get_gamma() const { return m_gamma; }

    FBufferStorage& get_frame_buffer() { return m_fb; }

    std::vector<HostMipMapStoragePtr>& get_host_textures() { return m_textures_h; }

    std::vector<DeviceMipMapStoragePtr>& get_device_textures() { return m_textures_d; }

    MipMapView* get_host_texture_views() { return m_texture_views_h.ptr(); }

    MipMapView* get_device_texture_views() { return m_texture_views_d.ptr(); }

    MeshStorage& get_host_mesh() { return m_mesh; }

    DeviceMeshStorage& get_device_mesh() { return m_mesh_d; }

    MeshLightsStorage& get_mesh_lights() { return m_mesh_lights; }

    RTContext* get_rt_context() const { return m_rt_context; }

    RendererInterface* get_renderer() const { return m_renderer; }

    uint32 register_renderer(const char* name, RendererFactoryFunction factory);

    uint32 load_plugin(const char* plugin_name);

    cugar::Bbox3f compute_bbox();

    RenderingContext*       m_this;

    unsigned int            m_res_x;                            
    unsigned int            m_res_y;                            
    float                   m_aspect;                           
    float                   m_exposure;                         
    float                   m_gamma;                            
    float                   m_shading_rate;                     
    ShadingMode             m_shading_mode;                     

    MeshStorage             m_mesh;                             
    DeviceMeshStorage       m_mesh_d;                           
    MeshLightsStorage       m_mesh_lights;                      
    RTContext*              m_rt_context;                       
    //DeviceUVBvh             m_uv_bvh;

    Camera                                  m_camera;           
    DirectionalLight                        m_light;
    HostDirectionalLightVector              m_dir_lights_h;     
    DeviceDirectionalLightVector            m_dir_lights_d;     

    uint32                                  m_renderer_type;    
    RendererInterface*                      m_renderer;         

    std::vector<HostMipMapStoragePtr>       m_textures_h;       
    std::vector<DeviceMipMapStoragePtr>     m_textures_d;       
    DomainBuffer<HOST_BUFFER, MipMapView>   m_texture_views_h;  
    DomainBuffer<CUDA_BUFFER, MipMapView>   m_texture_views_d;  
    DomainBuffer<CUDA_BUFFER, float4>       m_ltc_M;            
    DomainBuffer<CUDA_BUFFER, float4>       m_ltc_Minv;         
    DomainBuffer<CUDA_BUFFER, float>        m_ltc_A;            
    uint32                                  m_ltc_size;         
    DomainBuffer<CUDA_BUFFER, float>        m_glossy_reflectance;   

    FBufferStorage                          m_fb;               
    FBufferChannelStorage                   m_fb_temp[4];       
    DomainBuffer<CUDA_BUFFER, float>        m_var;              
    DomainBuffer<CUDA_BUFFER, uint8>        m_rgba;             

    TiledSequence                           m_sequence;         

    std::vector<std::string>                m_renderer_names;       
    std::vector<RendererFactoryFunction>    m_renderer_factories;   
    std::vector<DLL>                        m_plugins;              
};