external/vulkancts/framework/vulkan/vkRefUtil.hpp

   1 #ifndef _VKREFUTIL_HPP
   2 #define _VKREFUTIL_HPP
   3 /*-------------------------------------------------------------------------
   4  * Vulkan CTS Framework
   5  * --------------------
   6  *
   7  * Copyright (c) 2015 Google Inc.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Vulkan object reference holder utilities.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "vkDefs.hpp"
  27 #include "vkRef.hpp"
  28
  29 namespace vk
  30 {
  31
  32 #include "vkRefUtil.inl"
  33
  34 Move<VkPipeline>                createGraphicsPipeline  (const DeviceInterface&                                 vk,
  35                                                                                                  VkDevice                                                               device,
  36                                                                                                  VkPipelineCache                                                pipelineCache,
  37                                                                                                  const VkGraphicsPipelineCreateInfo*    pCreateInfo,
  38                                                                                                  const VkAllocationCallbacks*                   pAllocator = DE_NULL);
  39 Move<VkPipeline>                createComputePipeline   (const DeviceInterface&                                 vk,
  40                                                                                                  VkDevice                                                               device,
  41                                                                                                  VkPipelineCache                                                pipelineCache,
  42                                                                                                  const VkComputePipelineCreateInfo*             pCreateInfo,
  43                                                                                                  const VkAllocationCallbacks*                   pAllocator = DE_NULL);
  44 Move<VkCommandBuffer>   allocateCommandBuffer   (const DeviceInterface& vk, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo);
  45 Move<VkDescriptorSet>   allocateDescriptorSet   (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo);
  46
  47 Move<VkSemaphore>               createSemaphore                 (const DeviceInterface&                 vk,
  48                                                                                                  VkDevice                                               device,
  49                                                                                                  VkSemaphoreCreateFlags                 flags           = (VkSemaphoreCreateFlags)0,
  50                                                                                                  const VkAllocationCallbacks*   pAllocator      = DE_NULL);
  51
  52 Move<VkFence>                   createFence                             (const DeviceInterface&                 vk,
  53                                                                                                  VkDevice                                               device,
  54                                                                                                  VkFenceCreateFlags                             flags           = (VkFenceCreateFlags)0,
  55                                                                                                  const VkAllocationCallbacks*   pAllocator      = DE_NULL);
  56
  57 Move<VkCommandPool>             createCommandPool               (const DeviceInterface&                 vk,
  58                                                                                                  VkDevice                                               device,
  59                                                                                                  VkCommandPoolCreateFlags               flags,
  60                                                                                                  deUint32                                               queueFamilyIndex,
  61                                                                                                  const VkAllocationCallbacks*   pAllocator      = DE_NULL);
  62
  63 Move<VkCommandBuffer>   allocateCommandBuffer   (const DeviceInterface&                 vk,
  64                                                                                                  VkDevice                                               device,
  65                                                                                                  VkCommandPool                                  commandPool,
  66                                                                                                  VkCommandBufferLevel                   level);
  67
  68 Move<VkEvent>                   createEvent                             (const DeviceInterface&                 vk,
  69                                                                                                  VkDevice                                               device,
  70                                                                                                  VkEventCreateFlags                             flags = (VkEventCreateFlags)0u,
  71                                                                                                  const VkAllocationCallbacks*   pAllocateInfo = DE_NULL);
  72
  73 } // vk
  74
  75 #endif // _VKREFUTIL_HPP