attribute_point_set.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "attribute_point_set.h"
 
#include "utility/example_shared.h"
 
//----------------------------------------------------------------------
Attribute_point_set::Attribute_point_set(
    const std::vector< mi::math::Vector_struct< mi::Float32, 3 > >& vertex_vec,
    const std::vector< mi::Float32 >&                               attibute_vec,
    nv::index::IPoint_set::Point_style                         point_style)
    :
    m_vertex_vec(vertex_vec),
    m_per_vertex_color_values(),
    m_per_vertex_radii(),
    m_point_style(point_style),
    m_rendering_enabled(true),
    m_pickable(true),
    m_meta_data(mi::neuraylib::NULL_TAG)
{
    this->set_attribute(attibute_vec);
}
 
//----------------------------------------------------------------------
void Attribute_point_set::set_attribute(std::vector< mi::Float32 > const & attribute_vec)
{
    check_success(m_vertex_vec.size() == attribute_vec.size());
 
    m_per_vertex_color_values.clear();
    m_per_vertex_radii.clear();
 
    mi::Size const attrib_count = attribute_vec.size();
    check_success(attrib_count > 0);
 
    for(mi::Size i = 0; i < attrib_count; ++i)
    {
        const mi::Float32 attrib = attribute_vec.at(i);
        m_per_vertex_color_values.push_back(this->get_color_from_attribute(attrib));
        m_per_vertex_radii.       push_back(this->get_radius_from_attribute(attrib));
    }
}
 
//----------------------------------------------------------------------
mi::math::Vector_struct<mi::Float32, 3> * Attribute_point_set::peek_vertices()
{
    if(!(m_vertex_vec.empty()))
    {
        return &m_vertex_vec[0];
    }
    else{
        return 0;
    }
}
 
//----------------------------------------------------------------------
const mi::math::Vector_struct<mi::Float32, 3>* Attribute_point_set::get_vertices() const
{
    if(!(m_vertex_vec.empty()))
    {
        return &m_vertex_vec[0];
    }
    else{
        return 0;
    }
}
 
//----------------------------------------------------------------------
const mi::math::Color_struct* Attribute_point_set::get_colors() const
{
    if(!(m_per_vertex_color_values.empty()))
    {
        return &m_per_vertex_color_values[0];
    }
    else{
        return 0;
    }
}
 
//----------------------------------------------------------------------
const mi::Float32* Attribute_point_set::get_radii() const
{
    if(!(m_per_vertex_radii.empty()))
    {
        return &m_per_vertex_radii[0];
    }
    else{
        return 0;
    }
}
 
//----------------------------------------------------------------------
mi::neuraylib::IElement* Attribute_point_set::copy() const
{
    Attribute_point_set* other = new Attribute_point_set();
    other->m_vertex_vec              = this->m_vertex_vec;
    other->m_per_vertex_color_values = this->m_per_vertex_color_values;
    other->m_per_vertex_radii        = this->m_per_vertex_radii;
    other->m_point_style             = this->m_point_style;
    other->m_rendering_enabled       = this->m_rendering_enabled;
    other->m_pickable                = this->m_pickable;
    other->m_meta_data               = this->m_meta_data;
    return other;
}
 
//----------------------------------------------------------------------
const char* Attribute_point_set::get_class_name() const
{
    return "Attribute_point_set";
}
 
//----------------------------------------------------------------------
void Attribute_point_set::serialize(
    mi::neuraylib::ISerializer *serializer) const
{
    const mi::Size nb_elements = m_vertex_vec.size();
    serializer->write(&nb_elements, 1);
    if (nb_elements > 0)
    {
        serializer->write(&m_vertex_vec[0].x,              nb_elements * 3);
        serializer->write(&m_per_vertex_color_values[0].r, nb_elements * 4);
        serializer->write(&m_per_vertex_radii[0],          nb_elements);
    }
    
    const mi::Uint32 style = static_cast<mi::Uint32>(m_point_style);
    serializer->write(&style, 1);
 
    serializer->write(&m_rendering_enabled, 1);
    serializer->write(&m_pickable, 1);
    serializer->write(&m_meta_data.id, 1);
}
 
//----------------------------------------------------------------------
void Attribute_point_set::deserialize(
    mi::neuraylib::IDeserializer* deserializer)
{
    mi::Size nb_elements = 0;
    deserializer->read(&nb_elements, 1);
 
    m_vertex_vec.             resize(nb_elements);
    m_per_vertex_color_values.resize(nb_elements);
    m_per_vertex_radii.       resize(nb_elements);
 
    if (nb_elements > 0)
    {
        deserializer->read(&m_vertex_vec[0].x,              nb_elements * 3);
        deserializer->read(&m_per_vertex_color_values[0].r, nb_elements * 4);
        deserializer->read(&m_per_vertex_radii[0],          nb_elements);
    }
 
    mi::Uint32 style = 0;
    deserializer->read(&style, 1);
    m_point_style = static_cast<Point_style>(style);
 
    deserializer->read(&m_rendering_enabled, 1);
    deserializer->read(&m_pickable, 1);
    deserializer->read(&m_meta_data.id, 1);
}
 
//----------------------------------------------------------------------
mi::math::Color_struct Attribute_point_set::get_color_from_attribute(mi::Float32 attrib)
{
    mi::Sint32 const intval = static_cast< mi::Sint32 >(fabs(attrib));
    mi::math::Color_struct col;
    const mi::Float32 coef = 1.0f / 15.0f;
    col.r = coef * static_cast< mi::Float32 >(intval & 15);
    col.g = coef * static_cast< mi::Float32 >((intval >> 4) & 15);
    col.b = coef * static_cast< mi::Float32 >((intval >> 8) & 15);
    col.a = 1.0;
 
    return col;
}
 
//----------------------------------------------------------------------
mi::Float32 Attribute_point_set::get_radius_from_attribute(mi::Float32 attrib)
{
    const mi::Float32 rad =
        static_cast< mi::Float32 >(static_cast< mi::Sint32 >(fabs(attrib)) % 12);
    return rad;
}
 
//----------------------------------------------------------------------