// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef SRC_UI_LIB_ESCHER_IMPL_DESCRIPTOR_SET_POOL_H_
#define SRC_UI_LIB_ESCHER_IMPL_DESCRIPTOR_SET_POOL_H_

#include <vector>

#include "src/ui/lib/escher/resources/resource.h"
#include "src/ui/lib/escher/resources/resource_recycler.h"

#include <vulkan/vulkan.hpp>

namespace escher {
namespace impl {

class CommandBuffer;
class DescriptorSetPool;

// Contains a vector of vk::DescriptorSets that were obtained from a
// DescriptorSetPool (see below).  When this object is destroyed, the sets are
// returned to the pool.  The primary use-case is for allocations to be retained
// by a CommandBuffer; by obtaining a new allocation from the DescriptorSetPool
// each frame, the application can guarantee that no descriptor set is written
// nor destroyed while it is still in use by the device.
class DescriptorSetAllocation : public Resource {
 public:
  static const ResourceTypeInfo kTypeInfo;
  const ResourceTypeInfo& type_info() const override { return kTypeInfo; }

  ~DescriptorSetAllocation() override;

  const vk::DescriptorSet& get(size_t index) const { return sets_[index]; }
  vk::DescriptorSet* data() { return sets_.data(); }
  uint32_t size() { return static_cast<uint32_t>(sets_.size()); }

 private:
  friend class DescriptorSetPool;
  DescriptorSetAllocation(DescriptorSetPool* pool, std::vector<vk::DescriptorSet> descriptor_sets);

  std::vector<vk::DescriptorSet> sets_;
};

typedef fxl::RefPtr<DescriptorSetAllocation> DescriptorSetAllocationPtr;

// Interface that allows acquisition of DescriptorSets for a single use within
// a particular CommandBuffer.  When that CommandBuffer is retired, all such
// DescriptorSets are returned to the pool from which they originated, so that
// they can be reused.
class DescriptorSetPool : public ResourceRecycler {
 public:
  DescriptorSetPool(EscherWeakPtr escher, const vk::DescriptorSetLayoutCreateInfo& layout_info,
                    uint32_t initial_capacity = 10);
  ~DescriptorSetPool();

  // Allocate the requested number of descriptor sets, returning them in the
  // form of a DescriptorSetAllocation.  All such allocations must be destroyed
  // before this DescriptorSetPool is destroyed.  If command_buffer is not null,
  // it will retain the new allocation until it is retired.
  DescriptorSetAllocationPtr Allocate(uint32_t count, impl::CommandBuffer* command_buffer);

  vk::DescriptorSetLayout layout() const { return layout_; }

 private:
  // |ResourceRecycler|
  void RecycleResource(std::unique_ptr<Resource> resource) override;

  // Create a new vk::DescriptorPool, and use it to allocate the specified
  // number of vk::DescriptorSets, which are then added to free_sets_.
  void InternalAllocate(uint32_t descriptor_set_count);

  // These are used each time that more descriptor sets must be allocated.
  vk::DescriptorSetLayout layout_;
  std::vector<vk::DescriptorPoolSize> descriptor_counts_;

  // Sets that are free to be used in a new allocation.
  std::vector<vk::DescriptorSet> free_sets_;
  std::vector<vk::DescriptorPool> pools_;

  FXL_DISALLOW_COPY_AND_ASSIGN(DescriptorSetPool);
};

}  // namespace impl
}  // namespace escher

#endif  // SRC_UI_LIB_ESCHER_IMPL_DESCRIPTOR_SET_POOL_H_