renderer.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 <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>


struct RTContext;
struct RenderingContextImpl;

struct FERMAT_API RenderingContext
{
    typedef std::shared_ptr< MipMapStorage<HOST_BUFFER> >   HostMipMapStoragePtr;
    typedef std::shared_ptr< MipMapStorage<CUDA_BUFFER> >   DeviceMipMapStoragePtr;

    RenderingContext();

    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;

    RenderingContextView view(const uint32 instance);

    Camera& get_camera();

    uint32 get_directional_light_count() const;

    const DirectionalLight* get_host_directional_lights() const;

    const DirectionalLight* get_device_directional_lights() const;

    void set_directional_light_count(const uint32 count);

    void set_directional_light(const uint32 i, const DirectionalLight& light);

    uint2 get_res() const;

    float get_aspect_ratio() const;

    void set_aspect_ratio(const float v);

    float get_exposure() const;

    void set_exposure(const float v);

    float get_gamma() const;

    void set_gamma(const float v);

    ShadingMode& get_shading_mode();

    FBufferStorage& get_frame_buffer();

    uint8* get_device_rgba_buffer();

    uint32 get_texture_count() const;

    HostMipMapStoragePtr* get_host_textures();

    DeviceMipMapStoragePtr* get_device_textures();

    MipMapView* get_host_texture_views();

    MipMapView* get_device_texture_views();

    MeshStorage& get_host_mesh();

    DeviceMeshStorage& get_device_mesh();

    MeshLightsStorage& get_mesh_lights();

    RTContext* get_rt_context() const;

    RendererInterface* get_renderer() const;

    TiledSequence& get_sequence();

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

    cugar::Bbox3f compute_bbox();

private:
    RenderingContextImpl* m_impl;
};