iparticle_volume_subset.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_IPARTICLE_VOLUME_SUBSET_H
#define NVIDIA_INDEX_IPARTICLE_VOLUME_SUBSET_H
 
#include <mi/dice.h>
#include <mi/base/interface_declare.h>
#include <mi/math/vector.h>
 
#include <nv/index/idistributed_data_subset.h>
 
namespace nv {
namespace index {
 
// forward declarations
class IParticle_volume_subset;
class IParticle_volume_subset_device;
 
class IParticle_volume_attribute_set_descriptor :
    public mi::base::Interface_declare<0x27f160e3,0x1412,0x4264,0xa2,0x5b,0x89,0x3d,0xe6,0xaa,0xb3,0x37,
                                       IDistributed_data_attribute_set_descriptor>
{
public:
    struct Attribute_parameters
    {
        Distributed_data_attribute_format   format;     
    };
 
    virtual bool    setup_attribute(
                        mi::Uint32                  attrib_index,
                        const Attribute_parameters& attrib_params) = 0;
 
    virtual bool    get_attribute_parameters(
                        mi::Uint32                  attrib_index,
                        Attribute_parameters&       attrib_params) const = 0;
 
    virtual mi::Uint32  get_attribute_count_limit() const = 0;
 
};
 
class IParticle_volume_subset :
    public mi::base::Interface_declare<0x7694224f,0x93e6,0x4d5c,0x91,0x82,0xad,0x90,0x6a,0xb1,0x12,0x70,
                                       IDistributed_data_subset>
{
public:
    virtual const IParticle_volume_attribute_set_descriptor*  get_attribute_set_descriptor() const = 0;
 
    virtual bool generate_volume_storage(
        mi::Size    nb_subset_particles,
        mi::Float32 fixed_particle_radius = -1.0f,
        bool        enable_particle_normals = false) = 0;
 
    virtual mi::Size                                    get_number_of_particles() const = 0;
 
    virtual mi::math::Vector_struct<mi::Float32, 3>*    get_positions_buffer() const = 0;
 
    virtual mi::Float32*                                get_radii_buffer() const = 0;
 
    virtual mi::Float32                                 get_fixed_radius() const = 0;
 
    virtual mi::math::Vector_struct<mi::Float32, 3>*    get_normals_buffer() const = 0;
 
 
    virtual void*                                       get_attribute_buffer(mi::Uint32 attrib_index) const = 0;
 
 
    virtual IParticle_volume_subset_device*             get_device_subset() const = 0;
 
};
 
 
class IParticle_volume_subset_device :
    public mi::base::Interface_declare<0x7259b57b,0x18e8,0x411e,0x8f,0x28,0xfd,0xad,0x94,0xf0,0x1f,0xd6,
                                       IDistributed_data_subset_device>
{
public:
    enum Particle_radii_format
    {
        PVOL_radii_none,                            
        PVOL_radii_f32                              
    };
 
    enum Particle_normals_format
    {
        PVOL_normals_none,                          
        PVOL_normals_f32_3,                         
        PVOL_normals_compressed_1_32                
    };
 
    enum Particle_storage_format
    {
        PVOL_geometry_storage_separate,             
        PVOL_geometry_storage_combined,             
        PVOL_geometry_storage_interleaved           
    };
 
    enum Particle_geometry_buffer
    {
        PVOL_buffer_base,                           
        PVOL_buffer_positions,                      
        PVOL_buffer_radii,                          
        PVOL_buffer_normals                         
    };
 
    struct Geometry_parameters
    {
        mi::Uint32                  nb_particles;                   
        Particle_radii_format       radii_format;                   
        Particle_normals_format     normals_format;                 
        Particle_storage_format     storage_format;                 
        mi::Uint32                  element_stride;                 
        mi::Uint32                  component_offset_positions;     
        mi::Uint32                  component_offset_radii;         
        mi::Uint32                  component_offset_normals;       
    };
 
    struct Particle_size_parameters
    {
        mi::Float32                 fixed_radius;                   
        //mi::Float32                 min_radius;
        //mi::Float32                 max_radius;
    };
 
 
    virtual Geometry_parameters         get_geometry_parameters() const = 0;
 
    virtual Particle_size_parameters    get_particle_size_parameters() const = 0;
 
    virtual bool                        set_particle_size_parameters(
                                            const Particle_size_parameters& params) = 0;
 
    virtual void*                       get_geometry_storage(
                                            Particle_geometry_buffer buffer_selector) = 0;
 
 
    virtual bool                        resize_storage(
                                            const Geometry_parameters& params) = 0;
 
 
    virtual bool                        adopt_geometry_storage(
                                            const Geometry_parameters&  params,
                                            void* const                 geometry_device_buffers [],
                                            mi::Size const              byte_sizes_of_buffers [],
                                            mi::Uint32                  nb_buffers) = 0;
 
 
    virtual bool                        get_attribute_formats(
                                            mi::Uint32*                 formats,
                                            mi::Uint32                  nb_formats) const = 0;
 
    virtual bool                        set_attribute_formats(
                                            const mi::Uint32*           formats,
                                            mi::Uint32                  nb_formats) = 0;
 
 
    virtual void*                       get_attribute_storage(
                                            mi::Uint32          attrib_index) = 0;
 
    virtual bool                        adopt_attribute_storage(
                                            mi::Uint32          attrib_index,
                                            void*               attribute_storage,
                                            mi::Size            byte_size_of_storage) = 0;
 
    virtual bool                        is_internal_geometry_storage() const = 0;
 
    virtual bool                        is_internal_attribute_storage() const = 0;
 
    virtual void                        get_geometry_storage_byte_size(
                                            mi::Size            storage_sizes[],
                                            mi::Uint32          nb_storage_sizes) const = 0;
 
    virtual mi::Size                    get_attribute_storage_byte_size(
                                            mi::Uint32          attrib_index) const = 0;
 
 
    //virtual void                    signal_data_change(bool geometry, bool attributes) = 0;
};
 
} // namespace index
} // namespace nv
 
#endif // NVIDIA_INDEX_IPARTICLE_VOLUME_SUBSET_H