xac_compute.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#pragma once
 
#include <string>
#include <map>
#include <mi/math/vector.h>
#include <mi/math/matrix.h>
#include <mi/math/bbox.h>
#include <mi/neuraylib/iserializer.h>    // Tag_struct
#include <sstream>
#include <fstream>
 
namespace xac_compute {
 
// forward decls
class IXac_compute_scene_setup;
 
 
typedef mi::math::Bbox<mi::Sint32, 2>       Bbox2i;
typedef mi::math::Bbox<mi::Uint32, 2>       Bbox2u;
typedef mi::math::Bbox<mi::Float32, 2>      Bbox2f;
typedef mi::math::Bbox<mi::Sint32, 3>       Bbox3i;
typedef mi::math::Bbox<mi::Uint32, 3>       Bbox3u;
typedef mi::math::Bbox<mi::Float32, 3>      Bbox3f;
 
typedef mi::math::Vector<mi::Uint32, 2>     Vec2u;
typedef mi::math::Vector<mi::Sint32, 2>     Vec2i;
typedef mi::math::Vector<mi::Float32, 2>    Vec2f;
typedef mi::math::Vector<mi::Float64, 2>    Vec2d;
 
typedef mi::math::Vector<mi::Uint32, 3>     Vec3u;
typedef mi::math::Vector<mi::Sint32, 3>     Vec3i;
typedef mi::math::Vector<mi::Float32, 3>    Vec3f;
typedef mi::math::Vector<mi::Float64, 3>    Vec3d;
 
typedef mi::math::Vector<mi::Uint32, 4>     Vec4u;
typedef mi::math::Vector<mi::Sint32, 4>     Vec4i;
typedef mi::math::Vector<mi::Float32, 4>    Vec4f;
typedef mi::math::Vector<mi::Float64, 4>    Vec4d;
 
typedef mi::math::Matrix<mi::Float32, 2, 2> Mat2f;
typedef mi::math::Matrix<mi::Float32, 3, 3> Mat3f;
typedef mi::math::Matrix<mi::Float32, 4, 4> Mat4f;
 
typedef mi::math::Matrix<mi::Float64, 2, 2> Mat2d;
typedef mi::math::Matrix<mi::Float64, 3, 3> Mat3d;
typedef mi::math::Matrix<mi::Float64, 4, 4> Mat4d;
 
 
// Simple wrapper around map<string, string>
// returns empty string for non-existing keys.
class Option_map
{
public:
    typedef std::map<std::string, std::string> Map_type;
 
    // non-const access creates key
    std::string& operator[](const std::string& key) 
    { 
        return m_map[key]; 
    }
 
    // const access returns empty string, if key not present
    std::string operator[](const std::string& key) const
    {
        Map_type::const_iterator it = m_map.find(key);
        return (it != m_map.end()) ? it->second : std::string();
    }
 
 
    // access wrapped map for legacy code
    Map_type&       get_map() { return m_map; }
    const Map_type& get_map() const { return m_map; }
    bool            has_key(const std::string& key) const { return m_map.find(key) != m_map.end(); }
 
private:
    Map_type m_map;
};
 
inline bool has_key(const Option_map& opt_map, const std::string& key) { return opt_map.has_key(key); }
 
 
class Usage_helper
{
public:
    Usage_helper(const Option_map& opt_map)
        : m_opt_map(opt_map), m_indent("        ") {}
 
    void opt(const std::string& opt, const char* arg_info, const char* subline = "")
    {
        m_stream << m_indent << "[-" << opt;
        if (arg_info) {
            m_stream << " " << arg_info;
        }
        m_stream << "]";
        const std::string def = m_opt_map[opt];
        if (def.length() > 0) {
            m_stream << "   (default: " << def << " )";
        }
        m_stream << "\n";
        if (subline && subline[0]) {
            line(subline);
        }
    }
 
    void line(const char* info = "")
    {
        m_stream << m_indent << "    " << info << "\n";
    }
 
    std::string text() const { return m_stream.str(); }
 
    std::ostringstream& stream() { return m_stream; }
 
private:
    std::ostringstream  m_stream;
    const Option_map&   m_opt_map;
    std::string         m_indent;
};
 
 
struct Compute_launch_info
{
    mi::neuraylib::Tag  compute_program_tag;
    mi::neuraylib::Tag  scene_element_tag;
    mi::neuraylib::Tag  plane_compute_program_tag;
    mi::neuraylib::Tag  plane_tag;
    Bbox3f              compute_roi;
    Bbox3f              scene_roi;
};
 
// to be filled by IXac_compute_scene_setup::create_scene()
struct Scene_info
{
    Compute_launch_info compute_launch_info;
    std::string         rtc_program_source;
    std::string         plane_rtc_program_source;
};
 
 
}//xac_compute