VulkanSharedContext.h

Go to the documentation of this file.

/*
 * Copyright 2022 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef skgpu_graphite_VulkanSharedContext_DEFINED
#define skgpu_graphite_VulkanSharedContext_DEFINED
 
#include "include/private/base/SkMutex.h"
#include "src/gpu/graphite/SharedContext.h"
 
#include "include/gpu/vk/VulkanTypes.h"
#include "src/gpu/graphite/vk/VulkanCaps.h"
 
namespace skgpu {
struct VulkanBackendContext;
struct VulkanInterface;
class VulkanMemoryAllocator;
}
 
namespace skgpu::graphite {
 
struct ContextOptions;
class VulkanCaps;
 
class VulkanSharedContext final : public SharedContext {
public:
    static sk_sp<SharedContext> Make(const VulkanBackendContext&, const ContextOptions&);
    ~VulkanSharedContext() override;
 
    const VulkanCaps& vulkanCaps() const { return static_cast<const VulkanCaps&>(*this->caps()); }
 
    const skgpu::VulkanInterface* interface() const { return fInterface.get(); }
 
    skgpu::VulkanMemoryAllocator* memoryAllocator() const { return fMemoryAllocator.get(); }
 
    VkDevice device() const { return fDevice; }
    uint32_t  queueIndex() const { return fQueueIndex; }
 
    std::unique_ptr<ResourceProvider> makeResourceProvider(SingleOwner*,
                                                           uint32_t recorderID,
                                                           size_t resourceBudget) override;
 
    bool checkVkResult(VkResult result) const;
 
    bool isDeviceLost() const override {
        SkAutoMutexExclusive lock(fDeviceIsLostMutex);
        return fDeviceIsLost;
    }
 
private:
    VulkanSharedContext(const VulkanBackendContext&,
                        sk_sp<const skgpu::VulkanInterface> interface,
                        sk_sp<skgpu::VulkanMemoryAllocator> memoryAllocator,
                        std::unique_ptr<const VulkanCaps> caps);
 
    sk_sp<const skgpu::VulkanInterface> fInterface;
    sk_sp<skgpu::VulkanMemoryAllocator> fMemoryAllocator;
 
    VkDevice fDevice;
    uint32_t fQueueIndex;
 
    mutable SkMutex fDeviceIsLostMutex;
    // TODO(b/322207523): consider refactoring to remove the mutable keyword from fDeviceIsLost.
    mutable bool fDeviceIsLost SK_GUARDED_BY(fDeviceIsLostMutex) = false;
    skgpu::VulkanDeviceLostContext fDeviceLostContext;
    skgpu::VulkanDeviceLostProc fDeviceLostProc;
};
 
} // namespace skgpu::graphite
 
#endif // skgpu_graphite_VulkanSharedContext_DEFINED