kc3-lang/angle/src/libANGLE/renderer/vulkan/RendererVk.h

• Show log

  Commit

• Hash : 3c424b48
  Author :
  Date : 2018-01-19T12:35:09
  

  Vulkan: Add vk_cache_utils.h.
  
  This file contains the Pipeline and RenderPass cache utils.
  
  Also renames renderervk_utils.h to vk_utils.h and the format utils
  file.
  
  Refactoring change only.
  
  Bug: angleproject:2163
  Change-Id: I5113a9a2c6f0b0960d38e6c2d8e391fa2d9f5f6a
  Reviewed-on: https://chromium-review.googlesource.com/876505
  Reviewed-by: Frank Henigman <fjhenigman@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/RendererVk.h

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // RendererVk.h:
  //    Defines the class interface for RendererVk.
  //
  
  #ifndef LIBANGLE_RENDERER_VULKAN_RENDERERVK_H_
  #define LIBANGLE_RENDERER_VULKAN_RENDERERVK_H_
  
  #include <memory>
  #include <vulkan/vulkan.h>
  
  #include "common/angleutils.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
  #include "libANGLE/renderer/vulkan/vk_format_utils.h"
  
  namespace egl
  {
  class AttributeMap;
  }
  
  namespace rx
  {
  class FramebufferVk;
  class GlslangWrapper;
  
  namespace vk
  {
  struct Format;
  }
  
  class RendererVk : angle::NonCopyable
  {
    public:
      RendererVk();
      ~RendererVk();
  
      vk::Error initialize(const egl::AttributeMap &attribs, const char *wsiName);
  
      std::string getVendorString() const;
      std::string getRendererDescription() const;
  
      VkInstance getInstance() const { return mInstance; }
      VkPhysicalDevice getPhysicalDevice() const { return mPhysicalDevice; }
      VkQueue getQueue() const { return mQueue; }
      VkDevice getDevice() const { return mDevice; }
  
      vk::ErrorOrResult<uint32_t> selectPresentQueueForSurface(VkSurfaceKHR surface);
  
      vk::Error finish(const gl::Context *context);
      vk::Error flush(const gl::Context *context,
                      const vk::Semaphore &waitSemaphore,
                      const vk::Semaphore &signalSemaphore);
  
      const vk::CommandPool &getCommandPool() const;
  
      const gl::Caps &getNativeCaps() const;
      const gl::TextureCapsMap &getNativeTextureCaps() const;
      const gl::Extensions &getNativeExtensions() const;
      const gl::Limitations &getNativeLimitations() const;
  
      vk::Error createStagingImage(TextureDimension dimension,
                                   const vk::Format &format,
                                   const gl::Extents &extent,
                                   vk::StagingUsage usage,
                                   vk::StagingImage *imageOut);
  
      GlslangWrapper *getGlslangWrapper();
  
      Serial getCurrentQueueSerial() const;
  
      bool isResourceInUse(const ResourceVk &resource);
      bool isSerialInUse(Serial serial);
  
      template <typename T>
      void releaseResource(const ResourceVk &resource, T *object)
      {
          Serial resourceSerial = resource.getQueueSerial();
          releaseObject(resourceSerial, object);
      }
  
      template <typename T>
      void releaseObject(Serial resourceSerial, T *object)
      {
          if (!isSerialInUse(resourceSerial))
          {
              object->destroy(mDevice);
          }
          else
          {
              object->dumpResources(resourceSerial, &mGarbage);
          }
      }
  
      uint32_t getQueueFamilyIndex() const { return mCurrentQueueFamilyIndex; }
  
      const vk::MemoryProperties &getMemoryProperties() const { return mMemoryProperties; }
  
      // TODO(jmadill): We could pass angle::Format::ID here.
      const vk::Format &getFormat(GLenum internalFormat) const
      {
          return mFormatTable[internalFormat];
      }
  
      vk::Error getCompatibleRenderPass(const vk::RenderPassDesc &desc,
                                        vk::RenderPass **renderPassOut);
      vk::Error getRenderPassWithOps(const vk::RenderPassDesc &desc,
                                     const vk::AttachmentOpsArray &ops,
                                     vk::RenderPass **renderPassOut);
  
      // This should only be called from ResourceVk.
      // TODO(jmadill): Keep in ContextVk to enable threaded rendering.
      vk::CommandBufferNode *allocateCommandNode();
  
      const vk::PipelineLayout &getGraphicsPipelineLayout() const;
      const std::vector<vk::DescriptorSetLayout> &getGraphicsDescriptorSetLayouts() const;
  
      // Issues a new serial for linked shader modules. Used in the pipeline cache.
      Serial issueProgramSerial();
  
    private:
      vk::Error initializeDevice(uint32_t queueFamilyIndex);
      void ensureCapsInitialized() const;
      void generateCaps(gl::Caps *outCaps,
                        gl::TextureCapsMap *outTextureCaps,
                        gl::Extensions *outExtensions,
                        gl::Limitations *outLimitations) const;
      vk::Error submitFrame(const VkSubmitInfo &submitInfo, vk::CommandBuffer &&commandBatch);
      vk::Error checkInFlightCommands();
      void freeAllInFlightResources();
      vk::Error flushCommandGraph(const gl::Context *context, vk::CommandBuffer *commandBatch);
      void resetCommandGraph();
      vk::Error initGraphicsPipelineLayout();
  
      mutable bool mCapsInitialized;
      mutable gl::Caps mNativeCaps;
      mutable gl::TextureCapsMap mNativeTextureCaps;
      mutable gl::Extensions mNativeExtensions;
      mutable gl::Limitations mNativeLimitations;
  
      VkInstance mInstance;
      bool mEnableValidationLayers;
      VkDebugReportCallbackEXT mDebugReportCallback;
      VkPhysicalDevice mPhysicalDevice;
      VkPhysicalDeviceProperties mPhysicalDeviceProperties;
      std::vector<VkQueueFamilyProperties> mQueueFamilyProperties;
      VkQueue mQueue;
      uint32_t mCurrentQueueFamilyIndex;
      VkDevice mDevice;
      vk::CommandPool mCommandPool;
      GlslangWrapper *mGlslangWrapper;
      SerialFactory mQueueSerialFactory;
      SerialFactory mProgramSerialFactory;
      Serial mLastCompletedQueueSerial;
      Serial mCurrentQueueSerial;
  
      struct CommandBatch final : angle::NonCopyable
      {
          CommandBatch();
          ~CommandBatch();
          CommandBatch(CommandBatch &&other);
          CommandBatch &operator=(CommandBatch &&other);
  
          vk::CommandPool commandPool;
          vk::Fence fence;
          Serial serial;
      };
  
      std::vector<CommandBatch> mInFlightCommands;
      std::vector<vk::GarbageObject> mGarbage;
      vk::MemoryProperties mMemoryProperties;
      vk::FormatTable mFormatTable;
  
      RenderPassCache mRenderPassCache;
      std::vector<vk::CommandBufferNode *> mOpenCommandGraph;
  
      // ANGLE uses a single pipeline layout for all GL programs. It is owned here in the Renderer.
      // See the design doc for an overview of the pipeline layout structure.
      vk::PipelineLayout mGraphicsPipelineLayout;
      std::vector<vk::DescriptorSetLayout> mGraphicsDescriptorSetLayouts;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_VULKAN_RENDERERVK_H_
  

Download