iindex_canvas.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_IINDEX_CANVAS_H
#define NVIDIA_INDEX_IINDEX_CANVAS_H
 
#include <mi/dice.h>
 
namespace nv
{
namespace index
{
 
class IIndex_canvas :
    public mi::base::Interface_declare<0x46c5a5f7,0x31de,0x468d,0x9b,0x6c,0xb0,0x35,0x77,0xed,0xfe,0x61>
{
public:
    enum Frame_buffer_layer_type
    {
        FB_LAYER_UNDEFINED  = 0u,    
        FB_LAYER_RGB8       = 1u,    
        FB_LAYER_RGBA8      = 2u,    
        FB_LAYER_RGBE       = 3u,    
        FB_LAYER_DEPTH16    = 4u,    
        FB_LAYER_DEPTH32    = 5u,    
        FB_LAYER_UINT8      = 6u,    
        FB_LAYER_UINT32     = 7u,    
        FB_LAYER_FLOAT32    = 8u     
    };
 
    virtual mi::Uint32 get_nb_frame_buffer_layers() const = 0;
 
    virtual Frame_buffer_layer_type get_layer_type(mi::Uint32 layer_id) const = 0;
 
    virtual void prepare() = 0;
 
    virtual void render_tile(
        mi::Uint32                                      layer_id,
        Frame_buffer_layer_type                         layer_type,
        const mi::math::Bbox_struct<mi::Uint32, 2>&     area,
        mi::Uint8*                                      buffer) = 0;
 
    virtual void receive_tile(
        mi::Uint8*                                      buffer,
        mi::Uint32                                      buffer_size,
        const mi::math::Bbox_struct<mi::Uint32, 2>&     area) = 0;
 
    virtual void receive_tile_blend(
        mi::Uint8*                                      buffer,
        mi::Uint32                                      buffer_size,
        const mi::math::Bbox_struct<mi::Uint32, 2>&     area) = 0;
 
    virtual void finish() = 0;
 
    virtual bool is_multi_thread_capable() const = 0;
 
    virtual mi::math::Vector_struct<mi::Uint32, 2> get_resolution() const = 0;
 
    virtual mi::neuraylib::ICanvas* get_canvas() const = 0;
};
 
class IIndex_cuda_canvas :
    public mi::base::Interface_declare<0x631ca66c,0x5ed7,0x4275,0xb7,0xb8,0x10,0x23,0x85,0xf8,0x36,0x55, nv::index::IIndex_canvas>
{
public:
    virtual mi::neuraylib::ICanvas_cuda* get_cuda_canvas() const = 0;
 
    virtual mi::Sint32 get_device_id()                     const = 0;
};
 
class Index_cuda_canvas : public mi::base::Interface_implement<nv::index::IIndex_cuda_canvas>
{
public:
    virtual void set_resolution(const mi::math::Vector_struct<mi::Uint32, 2>& resolution) = 0;
};
 
 
class Index_canvas : public mi::base::Interface_implement<nv::index::IIndex_canvas>
{
public:
    virtual mi::Uint32 get_nb_frame_buffer_layers() const
    {
        return 0;
    }
 
    virtual Frame_buffer_layer_type get_layer_type(mi::Uint32 /*layer_id*/) const
    {
        return IIndex_canvas::FB_LAYER_UNDEFINED;
    }
 
    virtual void render_tile(
        mi::Uint32                                      /*layer_id*/,
        Frame_buffer_layer_type                         layer_type,
        const mi::math::Bbox_struct<mi::Uint32, 2>&     area,
        mi::Uint8*                                      buffer)
    {
        // Ignore the layer id but consider the layer type.
 
        const mi::Uint32 x_range = area.max.x - area.min.x;
        const mi::Uint32 y_range = area.max.y - area.min.y;
        const mi::Uint32 buffer_size = (x_range * y_range);
 
        if (layer_type == IIndex_canvas::FB_LAYER_RGB8)
        {
            this->receive_tile(buffer, buffer_size*3, area);
        }
        else if (layer_type == IIndex_canvas::FB_LAYER_RGBA8)
        {
            this->receive_tile_blend(buffer, buffer_size*4, area);
        }
    }
 
    virtual mi::neuraylib::ICanvas* get_canvas() const { return NULL; }
};
 
} // namespace index
} // namespace nv
 
#endif // NVIDIA_INDEX_IINDEX_CANVAS_H