constant_color_mapping.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
// \file
// \brief A constant color texture generation for mapping on geometry.
 
#ifndef NVIDIA_INDEX_BIN_GEOSPATIAL_EXAMPLE_CONSTANT_COLOR_MAPPING_H
#define NVIDIA_INDEX_BIN_GEOSPATIAL_EXAMPLE_CONSTANT_COLOR_MAPPING_H
 
#include <mi/dice.h>
#include <mi/base/interface_implement.h>
#include <mi/base/handle.h>
#include <mi/base/uuid.h>
#include <mi/math/vector.h>
 
#include <nv/index/idistributed_compute_technique.h>
#include <nv/index/idistributed_compute_destination_buffer.h>
 
#define USE_NVINDEX_ACCESS
#include "utility/example_shared.h"
 
#include <cassert>
#include <iostream>
 
// Constant color mapping.
//
class Distributed_compute_constant_color_mapping :
    public nv::index::Distributed_compute_technique<
        0x644c61ed,0x0865,0x4be8,0x94,0xdb,0x1e,0x75,0xaa,0xa6,0x8e,0x4c>
{
public:
    // constructor
    //
    // \param[in] extent local coordinate extent
    // \param[in] color a constant color of this texture buffer generation technique
    Distributed_compute_constant_color_mapping(
        const mi::math::Vector_struct<mi::Float32, 2>& extent,
        const mi::math::Color_struct & color)
        :
        m_extent(extent),
        m_color(color)
    {
        // empty
    }
 
    // Empty default constructor for serialization
    Distributed_compute_constant_color_mapping()
        :
        m_color(1.0f, 1.0f, 1.0f, 1.0f)
    {
        // empty
    }
 
public:
    virtual void launch_compute(
        mi::neuraylib::IDice_transaction*                   dice_transaction,
        nv::index::IDistributed_compute_destination_buffer* dst_buffer) const
    {
 
        using nv::index::IDistributed_compute_destination_buffer_2d_texture;
 
        // retrieve 2d texture buffer destination buffer interface
        const mi::base::Handle<IDistributed_compute_destination_buffer_2d_texture> dst_buffer_2d(
            dst_buffer->get_interface<IDistributed_compute_destination_buffer_2d_texture>());
 
        if (!dst_buffer_2d)
        {
            std::cerr << "Distributed compute technique (Constant_color_mapping): "
                      << "Unable to retrieve valid 2d texture destination buffer interface.";
            return;
        }
 
        // define the texture buffer format
        // * this example allows to use: INTENSITY_UINT8, RGBA_UINT8, RGBA_FLOAT32
        const IDistributed_compute_destination_buffer_2d_texture::Buffer_format     texture_format = IDistributed_compute_destination_buffer_2d_texture::FORMAT_RGBA_FLOAT32;
 
        // define the texture buffer layout
        // * this example allows to use: ONE_DIMENSIONAL_ARRAY, TWO_DIMENSIONAL_ARRAY
        // * the screen-space area (in raster space) that the subregion covers enables the user-defined generation to
        //   choose, for instance, the most efficient texture generation technique (for example, based on geometry area
        //   or window, or on ray/geometry intersection).
        const IDistributed_compute_destination_buffer_2d_texture::Buffer_layout     texture_layout = IDistributed_compute_destination_buffer_2d_texture::TWO_DIMENSIONAL_ARRAY;
 
        // set the buffer config to the destination buffer, initializing the internal buffer storage to the required size.
        IDistributed_compute_destination_buffer_2d_texture::Buffer_config   texture_config;
        texture_config.format = texture_format;
        texture_config.layout = texture_layout;
 
        {
            const mi::math::Bbox<mi::Float32, 2>   surface_area = dst_buffer_2d->get_surface_area();
 
            // Compute the tile resolution
            texture_config.resolution.x = 1u;
            texture_config.resolution.y = 1u;
 
            // Compute the area that is covered by the tile, which is probably larger than the requested
            // surface_area due to rounding to full texels.
            texture_config.covered_area = surface_area;
 
            if (!dst_buffer_2d->generate_buffer_storage(texture_config))
            {
                std::cerr << "Distributed compute technique (Constant_color_mapping): "
                          << "unable to generate destination buffer storage.";
                return;
            }
 
            const mi::math::Vector_struct<mi::Uint32, 2>&   tile_resolution = 
                dst_buffer_2d->get_buffer_config().resolution;
            const mi::Size tile_buf_size = tile_resolution.x * tile_resolution.y;
            assert(tile_buf_size > 0);
 
            // Allocate the texture buffer
            mi::math::Color_struct* texture_tile =
                reinterpret_cast<mi::math::Color_struct*>(dst_buffer_2d->get_buffer_storage());
            
            // Fill in the constant color
            for(mi::Size i = 0; i < tile_buf_size; ++i){
                texture_tile[i] = m_color;
            }            
        }
    }
 
public:
    virtual mi::neuraylib::IElement* copy() const
    {
        Distributed_compute_constant_color_mapping* other = new Distributed_compute_constant_color_mapping();
        other->m_extent = this->m_extent;
        other->m_color  = this->m_color;
        return other;
    }
    virtual const char* get_class_name() const
    {
        return "Constant_color_mapping";
    }
    virtual void serialize(mi::neuraylib::ISerializer *serializer) const
    {
        serializer->write(&(m_extent.x), 2);
        serializer->write(&(m_color.r),  4);
    }
    virtual void deserialize(mi::neuraylib::IDeserializer* deserializer)
    {
        deserializer->read(&(m_extent.x), 2);
        deserializer->read(&(m_color.r),  4);
    }
    virtual void get_references(
        mi::neuraylib::ITag_set* result) const
    {
        // empty
    }
 
private:
    // Extent of the texture
    mi::math::Vector<mi::Float32, 2> m_extent;
    // The constant color
    mi::math::Color m_color;
 
private:
    // copy constructor. prohibit until proved useful.
    Distributed_compute_constant_color_mapping(Distributed_compute_constant_color_mapping const &);
    // operator=. prohibit until proved useful.
    Distributed_compute_constant_color_mapping const & operator=(Distributed_compute_constant_color_mapping const &);
};
 
#endif // NVIDIA_INDEX_BIN_GEOSPATIAL_EXAMPLE_CONSTANT_COLOR_MAPPING_H