attribute_line_set.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "attribute_line_set.h"
 
#include "utility/example_shared.h"
 
//----------------------------------------------------------------------
Attribute_line_set::Attribute_line_set(
    const std::vector<mi::math::Vector_struct<mi::Float32, 3> >& line_segments,
    const std::vector< mi::Float32 > &                           attribute_vec)
    :
    m_line_segments(line_segments),
    m_per_segment_colors(),
    m_per_segment_widths(),
    m_rendering_enabled(true),
    m_pickable(true),
    m_meta_data(mi::neuraylib::NULL_TAG)
{
    this->set_attribute(attribute_vec);
}
 
//----------------------------------------------------------------------
void Attribute_line_set::set_attribute(const std::vector< mi::Float32 >& attribute_vec)
{
    check_success(m_line_segments.size() == attribute_vec.size());
 
    m_per_segment_colors.clear();
    m_per_segment_widths.clear();
 
    mi::Size const attrib_count = attribute_vec.size();
    check_success(attrib_count > 0);
 
    for(mi::Size i = 0; i < attrib_count; ++i){
        mi::Float32 const attrib = attribute_vec.at(i);
        // DEBUG_LOG << "attrib = " << attrib;
 
        m_per_segment_colors.push_back(this->get_color_from_attribute(attrib));
        m_per_segment_widths.push_back(this->get_width_from_attribute(attrib));
        // DEBUG_LOG << "color = " << m_per_segment_colors.back() << ", width = " << m_per_segment_widths.back();
    }
}
 
nv::index::ILine_set::Cap_style Attribute_line_set::get_cap_style() const
{
    return nv::index::ILine_set::CAP_STYLE_FLAT;
}
 
void Attribute_line_set::set_cap_style(nv::index::ILine_set::Cap_style style)
{
 
}
 
//----------------------------------------------------------------------
mi::Size Attribute_line_set::get_nb_lines() const
{
    return m_line_segments.size() / 2;
}
 
//----------------------------------------------------------------------
mi::Size Attribute_line_set::get_nb_vertices() const
{
    return m_line_segments.size();
}
 
//----------------------------------------------------------------------
const mi::math::Vector_struct<mi::Float32, 3>* Attribute_line_set::get_lines() const
{
    if (!m_line_segments.empty())
        return &m_line_segments[0];
    else
        return NULL;
}
 
//----------------------------------------------------------------------
const mi::math::Color_struct* Attribute_line_set::get_colors() const
{
    if (!m_per_segment_colors.empty())
        return &m_per_segment_colors[0];
    else
        return NULL;
}
 
//----------------------------------------------------------------------
const mi::Float32* Attribute_line_set::get_widths() const
{
    if (!m_per_segment_widths.empty())
        return &m_per_segment_widths[0];
    else
        return NULL;
}
 
//----------------------------------------------------------------------
nv::index::ILine_set::Line_style Attribute_line_set::get_line_style() const
{
    // LINE_STYLE_DASHED FIXME
    // LINE_STYLE_DOTTED
    return nv::index::ILine_set::LINE_STYLE_SOLID;
}
 
nv::index::ILine_set::Line_type Attribute_line_set::get_line_type() const
{
    return nv::index::ILine_set::LINE_TYPE_SEGMENTS;
}
 
//----------------------------------------------------------------------
void Attribute_line_set::set_enabled(bool is_enable)
{
    m_rendering_enabled = is_enable;
}
 
//----------------------------------------------------------------------
bool Attribute_line_set::get_enabled() const
{
    return m_rendering_enabled;
}
 
//----------------------------------------------------------------------
mi::neuraylib::IElement* Attribute_line_set::copy() const
{
    Attribute_line_set* other = new Attribute_line_set();
    other->m_line_segments      = this->m_line_segments;
    other->m_per_segment_widths = this->m_per_segment_widths;
    other->m_per_segment_colors = this->m_per_segment_colors;
 
    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_line_set::get_class_name() const
{
    return "Attribute_line_set";
}
 
//----------------------------------------------------------------------
void Attribute_line_set::serialize(
    mi::neuraylib::ISerializer *serializer) const
{
    const mi::Size nb_elements = m_line_segments.size() / 2;
    serializer->write(&nb_elements, 1);
 
    serializer->write(&m_line_segments[0].x, nb_elements * 3 * 2);
    serializer->write(&m_per_segment_colors[0].r, nb_elements * 4);
    serializer->write(&m_per_segment_widths[0], nb_elements);
 
    serializer->write(&m_rendering_enabled, 1);
    serializer->write(&m_pickable, 1);
    serializer->write(&m_meta_data.id, 1);
}
 
//----------------------------------------------------------------------
void Attribute_line_set::deserialize(
    mi::neuraylib::IDeserializer* deserializer)
{
    mi::Size nb_elements = 0;
    deserializer->read(&nb_elements, 1);
    m_line_segments.resize(nb_elements * 2);
    deserializer->read(&m_line_segments[0].x, nb_elements * 3 * 2);
 
    m_per_segment_colors.resize(nb_elements);
    deserializer->read(&m_per_segment_colors[0].r, nb_elements * 4);
 
    m_per_segment_widths.resize(nb_elements);
    deserializer->read(&m_per_segment_widths[0], nb_elements);
 
    deserializer->read(&m_rendering_enabled, 1);
    deserializer->read(&m_pickable, 1);
    deserializer->read(&m_meta_data.id, 1);
}
 
//----------------------------------------------------------------------
mi::math::Color_struct Attribute_line_set::get_color_from_attribute(mi::Float32 attrib)
{
    mi::Sint32 const intval = static_cast< mi::Sint32 >(fabs(attrib));
    mi::math::Color_struct col;
    mi::Float32 const 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_line_set::get_width_from_attribute(mi::Float32 attrib)
{
    mi::Float32 const width =
        static_cast< mi::Float32 >(static_cast< mi::Sint32 >(fabs(attrib)) % 12);
    return width;
}
 
//----------------------------------------------------------------------