Separable samplers

include/nbl/asset/ICPUDescriptorSet.h

@@ -67,7 +67,7 @@ class NBL_API2 ICPUDescriptorSet final : public IDescriptorSet<ICPUDescriptorSet
  return 0xdeadbeefull;
  }
 
- inline core::SRange<SDescriptorInfo> getDescriptorInfoStorage(const IDescriptor::E_TYPE type) const
+ inline std::span<SDescriptorInfo> getDescriptorInfoStorage(const IDescriptor::E_TYPE type) const
  {
  // TODO: @Hazardu
  // Cannot do the mutability check here because it requires the function to be non-const, but the function cannot be non-const because it's called
@@ -78,14 +78,14 @@ class NBL_API2 ICPUDescriptorSet final : public IDescriptorSet<ICPUDescriptorSet
  // 
  // assert(!isImmutable_debug());
  if (!m_descriptorInfos[static_cast<uint32_t>(type)])
- return { nullptr, nullptr };
+ return { };
  else
  return { m_descriptorInfos[static_cast<uint32_t>(type)]->begin(), m_descriptorInfos[static_cast<uint32_t>(type)]->end() };
  }
 
- core::SRange<SDescriptorInfo> getDescriptorInfos(const ICPUDescriptorSetLayout::CBindingRedirect::binding_number_t binding, IDescriptor::E_TYPE type = IDescriptor::E_TYPE::ET_COUNT);
+ std::span<SDescriptorInfo> getDescriptorInfos(const ICPUDescriptorSetLayout::CBindingRedirect::binding_number_t binding, IDescriptor::E_TYPE type = IDescriptor::E_TYPE::ET_COUNT);
 
- core::SRange<const SDescriptorInfo> getDescriptorInfos(const ICPUDescriptorSetLayout::CBindingRedirect::binding_number_t binding, IDescriptor::E_TYPE type = IDescriptor::E_TYPE::ET_COUNT) const;
+ std::span<const SDescriptorInfo> getDescriptorInfos(const ICPUDescriptorSetLayout::CBindingRedirect::binding_number_t binding, IDescriptor::E_TYPE type = IDescriptor::E_TYPE::ET_COUNT) const;
 
  core::smart_refctd_ptr<IAsset> clone(uint32_t _depth = ~0u) const override;
 
@@ -101,35 +101,7 @@ class NBL_API2 ICPUDescriptorSet final : public IDescriptorSet<ICPUDescriptorSet
  private:
  static inline IDescriptor::E_CATEGORY getCategoryFromType(const IDescriptor::E_TYPE type)
  {
- auto category = IDescriptor::E_CATEGORY::EC_COUNT;
- switch (type)
- {
- case IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER: [[fallthrough]];
- case IDescriptor::E_TYPE::ET_STORAGE_IMAGE: [[fallthrough]];
- case IDescriptor::E_TYPE::ET_INPUT_ATTACHMENT:
- category = IDescriptor::E_CATEGORY::EC_IMAGE;
- break;
-
- case IDescriptor::E_TYPE::ET_UNIFORM_BUFFER: [[fallthrough]];
- case IDescriptor::E_TYPE::ET_UNIFORM_BUFFER_DYNAMIC: [[fallthrough]];
- case IDescriptor::E_TYPE::ET_STORAGE_BUFFER: [[fallthrough]];
- case IDescriptor::E_TYPE::ET_STORAGE_BUFFER_DYNAMIC:
- category = IDescriptor::E_CATEGORY::EC_BUFFER;
- break;
-
- case IDescriptor::E_TYPE::ET_UNIFORM_TEXEL_BUFFER:
- case IDescriptor::E_TYPE::ET_STORAGE_TEXEL_BUFFER:
- category = IDescriptor::E_CATEGORY::EC_BUFFER_VIEW;
- break;
-
- case IDescriptor::E_TYPE::ET_ACCELERATION_STRUCTURE:
- category = IDescriptor::E_CATEGORY::EC_ACCELERATION_STRUCTURE;
- break;
-
- default:
- assert(!"Invalid code path.");
- }
- return category;
+ return IDescriptor::GetTypeCategory(type);
  }
 
  core::smart_refctd_dynamic_array<ICPUDescriptorSet::SDescriptorInfo> m_descriptorInfos[static_cast<uint32_t>(IDescriptor::E_TYPE::ET_COUNT)];

include/nbl/asset/ICPUDescriptorSetLayout.h

@@ -34,20 +34,20 @@ class ICPUDescriptorSetLayout : public IDescriptorSetLayout<ICPUSampler>, public
  for (uint32_t t = 0; t < static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); ++t)
  cp->m_descriptorRedirects[t] = m_descriptorRedirects[t].clone();
  cp->m_immutableSamplerRedirect = m_immutableSamplerRedirect.clone();
- cp->m_mutableSamplerRedirect = m_mutableSamplerRedirect.clone();
+ cp->m_mutableCombinedSamplerRedirect = m_mutableCombinedSamplerRedirect.clone();
 
- if (m_samplers)
+ if (m_immutableSamplers)
  {
- cp->m_samplers = core::make_refctd_dynamic_array<decltype(m_samplers)>(m_samplers->size());
+ cp->m_immutableSamplers = core::make_refctd_dynamic_array<decltype(m_immutableSamplers)>(m_immutableSamplers->size());
 
  if (_depth > 0u)
  {
- for (size_t i = 0ull; i < m_samplers->size(); ++i)
- (*cp->m_samplers)[i] = core::smart_refctd_ptr_static_cast<ICPUSampler>((*m_samplers)[i]->clone(_depth - 1u));
+ for (size_t i = 0ull; i < m_immutableSamplers->size(); ++i)
+ (*cp->m_immutableSamplers)[i] = core::smart_refctd_ptr_static_cast<ICPUSampler>((*m_immutableSamplers)[i]->clone(_depth - 1u));
  }
  else
  {
- std::copy(m_samplers->begin(), m_samplers->end(), cp->m_samplers->begin());
+ std::copy(m_immutableSamplers->begin(), m_immutableSamplers->end(), cp->m_immutableSamplers->begin());
  }
  }
 
@@ -60,9 +60,9 @@ class ICPUDescriptorSetLayout : public IDescriptorSetLayout<ICPUSampler>, public
  for (uint32_t t = 0; t < static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); ++t)
  result += m_descriptorRedirects[t].conservativeSizeEstimate();
  result += m_immutableSamplerRedirect.conservativeSizeEstimate();
- result += m_mutableSamplerRedirect.conservativeSizeEstimate();
+ result += m_mutableCombinedSamplerRedirect.conservativeSizeEstimate();
 
- result += m_samplers->size() * sizeof(void*);
+ result += m_immutableSamplers->size() * sizeof(void*);
 
  return result;
  }
@@ -74,9 +74,9 @@ class ICPUDescriptorSetLayout : public IDescriptorSetLayout<ICPUSampler>, public
  if (referenceLevelsBelowToConvert)
  {
  --referenceLevelsBelowToConvert;
- if (m_samplers)
+ if (m_immutableSamplers)
  {
- for (auto it=m_samplers->begin(); it!=m_samplers->end(); it++)
+ for (auto it=m_immutableSamplers->begin(); it!=m_immutableSamplers->end(); it++)
  it->get()->convertToDummyObject(referenceLevelsBelowToConvert);
  }
  }
@@ -90,15 +90,15 @@ class ICPUDescriptorSetLayout : public IDescriptorSetLayout<ICPUSampler>, public
  auto* other = static_cast<const ICPUDescriptorSetLayout*>(_other);
  if (getTotalBindingCount() != other->getTotalBindingCount())
  return false;
- if ((!m_samplers) != (!other->m_samplers))
+ if ((!m_immutableSamplers) != (!other->m_immutableSamplers))
  return false;
- if (m_samplers && m_samplers->size() != other->m_samplers->size())
+ if (m_immutableSamplers && m_immutableSamplers->size() != other->m_immutableSamplers->size())
  return false;
- if (m_samplers)
+ if (m_immutableSamplers)
  {
- for (uint32_t i = 0u; i < m_samplers->size(); ++i)
+ for (uint32_t i = 0u; i < m_immutableSamplers->size(); ++i)
  {
- if (!(*m_samplers)[i]->canBeRestoredFrom((*other->m_samplers)[i].get()))
+ if (!(*m_immutableSamplers)[i]->canBeRestoredFrom((*other->m_immutableSamplers)[i].get()))
  return false;
  }
  }
@@ -115,21 +115,21 @@ class ICPUDescriptorSetLayout : public IDescriptorSetLayout<ICPUSampler>, public
  return;
 
  --_levelsBelow;
- if (m_samplers)
+ if (m_immutableSamplers)
  {
- for (uint32_t i = 0u; i < m_samplers->size(); ++i)
- restoreFromDummy_impl_call((*m_samplers)[i].get(), (*other->m_samplers)[i].get(), _levelsBelow);
+ for (uint32_t i = 0u; i < m_immutableSamplers->size(); ++i)
+ restoreFromDummy_impl_call((*m_immutableSamplers)[i].get(), (*other->m_immutableSamplers)[i].get(), _levelsBelow);
  }
  }
 
  bool isAnyDependencyDummy_impl(uint32_t _levelsBelow) const override
  {
  --_levelsBelow;
- if (m_samplers)
+ if (m_immutableSamplers)
  {
- for (uint32_t i = 0u; i < m_samplers->size(); ++i)
+ for (uint32_t i = 0u; i < m_immutableSamplers->size(); ++i)
  {
- if ((*m_samplers)[i]->isAnyDependencyDummy(_levelsBelow))
+ if ((*m_immutableSamplers)[i]->isAnyDependencyDummy(_levelsBelow))
  return true;
  }
  }

include/nbl/asset/ICPUSampler.h

@@ -77,7 +77,7 @@ class ICPUSampler : public ISampler, public IAsset
 
 
  _NBL_STATIC_INLINE_CONSTEXPR auto AssetType = ET_SAMPLER;
- inline E_TYPE getAssetType() const override { return AssetType; }
+ inline IAsset::E_TYPE getAssetType() const override { return AssetType; }
 
  bool canBeRestoredFrom(const IAsset* _other) const override
  {

include/nbl/asset/IDescriptor.h

@@ -14,7 +14,9 @@ class IDescriptor : public virtual core::IReferenceCounted
  public:
  enum class E_TYPE : uint8_t
  {
- ET_COMBINED_IMAGE_SAMPLER = 0,
+ ET_SAMPLER = 0,
+ ET_COMBINED_IMAGE_SAMPLER,
+ ET_SAMPLED_IMAGE,
  ET_STORAGE_IMAGE,
  ET_UNIFORM_TEXEL_BUFFER,
  ET_STORAGE_TEXEL_BUFFER,
@@ -39,6 +41,7 @@ class IDescriptor : public virtual core::IReferenceCounted
  enum E_CATEGORY : uint8_t
  {
  EC_BUFFER = 0,
+ EC_SAMPLER,
  EC_IMAGE,
  EC_BUFFER_VIEW,
  EC_ACCELERATION_STRUCTURE,
@@ -48,24 +51,23 @@ class IDescriptor : public virtual core::IReferenceCounted
  {
  switch (type)
  {
+ case E_TYPE::ET_SAMPLER:
+ return EC_SAMPLER;
  case E_TYPE::ET_COMBINED_IMAGE_SAMPLER:
+ case E_TYPE::ET_SAMPLED_IMAGE:
  case E_TYPE::ET_STORAGE_IMAGE:
  case E_TYPE::ET_INPUT_ATTACHMENT:
  return EC_IMAGE;
- break;
  case E_TYPE::ET_UNIFORM_TEXEL_BUFFER:
  case E_TYPE::ET_STORAGE_TEXEL_BUFFER:
  return EC_BUFFER_VIEW;
- break;
  case E_TYPE::ET_UNIFORM_BUFFER:
  case E_TYPE::ET_STORAGE_BUFFER:
  case E_TYPE::ET_UNIFORM_BUFFER_DYNAMIC:
  case E_TYPE::ET_STORAGE_BUFFER_DYNAMIC:
  return EC_BUFFER;
- break;
  case E_TYPE::ET_ACCELERATION_STRUCTURE:
  return EC_ACCELERATION_STRUCTURE;
- break;
  default:
  break;
  }

include/nbl/asset/IDescriptorSet.h

@@ -47,9 +47,10 @@ class IDescriptorSet : public virtual core::IReferenceCounted // TODO: try to re
  };
  struct SImageInfo
  {
- // This will be ignored if the DS layout already has an immutable sampler specified for the binding.
- core::smart_refctd_ptr<typename layout_t::sampler_type> sampler;
- IImage::LAYOUT imageLayout;
+ IImage::LAYOUT imageLayout;
+ // If the binding is COMBINED, this will be ignored if the DS layout already has an immutable sampler specified for the binding
+ // If the binding is an immutable SAMPLER, whatever's here doesn't matter because the write validation will fail
+ core::smart_refctd_ptr<typename layout_t::sampler_type> sampler;
  };
 
  core::smart_refctd_ptr<IDescriptor> desc;
@@ -92,31 +93,31 @@ class IDescriptorSet : public virtual core::IReferenceCounted // TODO: try to re
  }
  ~SDescriptorInfo()
  {
- if (desc && desc->getTypeCategory()==IDescriptor::EC_IMAGE)
+ if (desc and (desc->getTypeCategory()==IDescriptor::EC_IMAGE or desc->getTypeCategory() == IDescriptor::EC_SAMPLER))
  info.image.sampler = nullptr;
  }
 
  inline SDescriptorInfo& operator=(const SDescriptorInfo& other)
  {
- if (desc && desc->getTypeCategory()==IDescriptor::EC_IMAGE)
+ if (desc and (desc->getTypeCategory()==IDescriptor::EC_IMAGE or desc->getTypeCategory() == IDescriptor::EC_SAMPLER))
  info.image.sampler = nullptr;
  desc = other.desc;
  const auto type = desc->getTypeCategory();
- if (type!=IDescriptor::EC_IMAGE)
+ if (type!=IDescriptor::EC_IMAGE and type!=IDescriptor::EC_SAMPLER)
  info.buffer = other.info.buffer;
  else
  info.image = other.info.image;
  return *this;
  }
  inline SDescriptorInfo& operator=(SDescriptorInfo&& other)
  {
- if (desc && desc->getTypeCategory()==IDescriptor::EC_IMAGE)
+ if (desc and (desc->getTypeCategory() == IDescriptor::EC_IMAGE or desc->getTypeCategory() == IDescriptor::EC_SAMPLER))
  info.image = {nullptr,IImage::LAYOUT::UNDEFINED};
  desc = std::move(other.desc);
  if (desc)
  {
  const auto type = desc->getTypeCategory();
- if (type!=IDescriptor::EC_IMAGE)
+ if (type!=IDescriptor::EC_IMAGE and type!=IDescriptor::EC_SAMPLER)
  info.buffer = other.info.buffer;
  else
  info.image = other.info.image;

include/nbl/asset/IDescriptorSetLayout.h

@@ -317,18 +317,20 @@ class IDescriptorSetLayout : public virtual core::IReferenceCounted // TODO: tr
  if (!areRedirectsEqual(m_immutableSamplerRedirect, _other->m_immutableSamplerRedirect))
  return false;
 
- if (!areRedirectsEqual(m_mutableSamplerRedirect, _other->m_mutableSamplerRedirect))
+ if (!areRedirectsEqual(m_mutableCombinedSamplerRedirect, _other->m_mutableCombinedSamplerRedirect))
  return false;
 
- if (m_samplers && _other->m_samplers)
- return std::equal(m_samplers->begin(), m_samplers->end(), _other->m_samplers->begin(), _other->m_samplers->end());
+ if (m_immutableSamplers && _other->m_immutableSamplers)
+ return std::equal(m_immutableSamplers->begin(), m_immutableSamplers->end(), _other->m_immutableSamplers->begin(), _other->m_immutableSamplers->end());
  else
- return !m_samplers && !_other->m_samplers;
+ return !m_immutableSamplers && !_other->m_immutableSamplers;
  }
 
- inline uint32_t getTotalMutableSamplerCount() const { return m_mutableSamplerRedirect.getTotalCount(); }
+ inline uint32_t getTotalMutableCombinedSamplerCount() const { return m_mutableCombinedSamplerRedirect.getTotalCount(); }
+ // Immutable sampler descriptors are not counted here
  inline uint32_t getTotalDescriptorCount(const IDescriptor::E_TYPE type) const { return m_descriptorRedirects[static_cast<uint32_t>(type)].getTotalCount(); }
 
+ // Immutable sampler bindings are not counted here
  inline uint32_t getTotalBindingCount() const
  {
  uint32_t result = 0u;
@@ -340,14 +342,14 @@ class IDescriptorSetLayout : public virtual core::IReferenceCounted // TODO: tr
 
  inline const CBindingRedirect& getDescriptorRedirect(const IDescriptor::E_TYPE type) const { return m_descriptorRedirects[static_cast<uint32_t>(type)]; }
  inline const CBindingRedirect& getImmutableSamplerRedirect() const { return m_immutableSamplerRedirect; }
- inline const CBindingRedirect& getMutableSamplerRedirect() const { return m_mutableSamplerRedirect; }
+ inline const CBindingRedirect& getMutableCombinedSamplerRedirect() const { return m_mutableCombinedSamplerRedirect; }
 
  inline core::SRange<const core::smart_refctd_ptr<sampler_type>> getImmutableSamplers() const
  {
- if (!m_samplers)
+ if (!m_immutableSamplers)
  return { nullptr, nullptr };
 
- return { m_samplers->cbegin(), m_samplers->cend() };
+ return { m_immutableSamplers->cbegin(), m_immutableSamplers->cend() };
  }
 
 protected:
@@ -359,34 +361,42 @@ class IDescriptorSetLayout : public virtual core::IReferenceCounted // TODO: tr
 
  for (const auto& b : _bindings)
  {
- buildInfo_descriptors[static_cast<uint32_t>(b.type)].emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
-
- if (b.type == IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER)
- {
- if (b.samplers)
- buildInfo_immutableSamplers.emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
- else
- buildInfo_mutableSamplers.emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ switch (b.type) {
+ case IDescriptor::E_TYPE::ET_SAMPLER:
+ if (b.samplers)
+ buildInfo_immutableSamplers.emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ else 
+ buildInfo_descriptors[static_cast<uint32_t>(b.type)].emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ break;
+ case IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER:
+ if (b.samplers)
+ buildInfo_immutableSamplers.emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ else
+ buildInfo_mutableSamplers.emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ [[fallthrough]];
+ default:
+ buildInfo_descriptors[static_cast<uint32_t>(b.type)].emplace_back(b.binding, b.createFlags, b.stageFlags, b.count);
+ break;
  }
  }
 
  for (auto type = 0u; type < static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT); ++type)
  m_descriptorRedirects[type] = CBindingRedirect(std::move(buildInfo_descriptors[type]));
 
  m_immutableSamplerRedirect = CBindingRedirect(std::move(buildInfo_immutableSamplers));
- m_mutableSamplerRedirect = CBindingRedirect(std::move(buildInfo_mutableSamplers));
+ m_mutableCombinedSamplerRedirect = CBindingRedirect(std::move(buildInfo_mutableSamplers));
 
  const uint32_t immutableSamplerCount = m_immutableSamplerRedirect.getTotalCount();
- m_samplers = immutableSamplerCount ? core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<core::smart_refctd_ptr<sampler_type>>>(immutableSamplerCount) : nullptr;
+ m_immutableSamplers = immutableSamplerCount ? core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<core::smart_refctd_ptr<sampler_type>>>(immutableSamplerCount) : nullptr;
 
  for (const auto& b : _bindings)
  {
- if (b.type == IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER && b.samplers)
+ if ((b.type == IDescriptor::E_TYPE::ET_SAMPLER or b.type == IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER) and b.samplers)
  {
  const auto localOffset = m_immutableSamplerRedirect.getStorageOffset(typename CBindingRedirect::binding_number_t(b.binding)).data;
  assert(localOffset != m_immutableSamplerRedirect.Invalid);
 
- auto* dst = m_samplers->begin() + localOffset;
+ auto* dst = m_immutableSamplers->begin() + localOffset;
  std::copy_n(b.samplers, b.count, dst);
  }
  }
@@ -396,9 +406,9 @@ class IDescriptorSetLayout : public virtual core::IReferenceCounted // TODO: tr
 
  CBindingRedirect m_descriptorRedirects[static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT)];
  CBindingRedirect m_immutableSamplerRedirect;
- CBindingRedirect m_mutableSamplerRedirect;
+ CBindingRedirect m_mutableCombinedSamplerRedirect;
 
- core::smart_refctd_dynamic_array<core::smart_refctd_ptr<sampler_type>> m_samplers = nullptr;
+ core::smart_refctd_dynamic_array<core::smart_refctd_ptr<sampler_type>> m_immutableSamplers = nullptr;
 };
 
 }