ANARIScene.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
 
#ifndef vtk_m_interop_anari_ANARIScene_h
#define vtk_m_interop_anari_ANARIScene_h
 
#include <vtkm/interop/anari/ANARIMapper.h>
// std
#include <string>
#include <type_traits>
 
namespace vtkm
{
namespace interop
{
namespace anari
{
 
struct VTKM_ANARI_EXPORT ANARIScene
{
  ANARIScene(anari_cpp::Device device);
 
  ~ANARIScene();
 
  ANARIScene(const ANARIScene&) = delete;
  ANARIScene(ANARIScene&&) = delete;
  ANARIScene& operator=(const ANARIScene&) = delete;
  ANARIScene& operator=(ANARIScene&&) = delete;
 
  template <typename ANARIMapperType>
  ANARIMapperType& AddMapper(const ANARIMapperType& mapper, bool visible = true);
 
  template <typename ANARIMapperType>
  void ReplaceMapper(const ANARIMapperType& newMapper, vtkm::IdComponent id, bool visible);
 
  vtkm::IdComponent GetNumberOfMappers() const;
 
  bool HasMapperWithName(const char* name) const;
 
  vtkm::IdComponent GetMapperIndexByName(const char* name);
 
  ANARIMapper& GetMapper(vtkm::IdComponent id);
 
  ANARIMapper& GetMapper(const char* name);
 
  bool GetMapperVisible(vtkm::IdComponent id) const;
  void SetMapperVisible(vtkm::IdComponent id, bool shown);
 
  void RemoveMapper(vtkm::IdComponent id);
 
  void RemoveMapper(const char* name);
 
  void RemoveAllMappers();
 
  anari_cpp::Device GetDevice() const;
 
  anari_cpp::World GetANARIWorld();
 
private:
  void UpdateWorld();
 
  anari_cpp::Device Device{ nullptr };
  anari_cpp::World World{ nullptr };
 
  struct SceneMapper
  {
    std::unique_ptr<ANARIMapper> Mapper;
    bool Show{ true };
  };
 
  std::vector<SceneMapper> Mappers;
};
 
// Inlined definitions ////////////////////////////////////////////////////////
 
template <typename ANARIMapperType>
inline ANARIMapperType& ANARIScene::AddMapper(const ANARIMapperType& mapper, bool visible)
{
  static_assert(std::is_base_of<ANARIMapper, ANARIMapperType>::value,
                "Only ANARIMapper types can be added to ANARIScene");
 
  auto* name = mapper.GetName();
  if (HasMapperWithName(name))
  {
    auto idx = GetMapperIndexByName(name);
    ReplaceMapper(mapper, idx, visible);
    return (ANARIMapperType&)GetMapper(idx);
  }
  else
  {
    this->Mappers.push_back({ std::make_unique<ANARIMapperType>(mapper), visible });
    UpdateWorld();
    return (ANARIMapperType&)GetMapper(GetNumberOfMappers() - 1);
  }
}
 
template <typename ANARIMapperType>
inline void ANARIScene::ReplaceMapper(const ANARIMapperType& newMapper,
                                      vtkm::IdComponent id,
                                      bool visible)
{
  static_assert(std::is_base_of<ANARIMapper, ANARIMapperType>::value,
                "Only ANARIMapper types can be added to ANARIScene");
  const bool wasVisible = GetMapperVisible(id);
  Mappers[id] = { std::make_unique<ANARIMapperType>(newMapper), visible };
  if (wasVisible || visible)
    UpdateWorld();
}
 
} // namespace anari
} // namespace interop
} // namespace vtkm
 
#endif