Revert "Remove VK_DEFINE_NON_DISPATCHABLE_HANDLE magic, use explicit VkHandle wrapper"
This reverts commit 4e17d5c248
.
Reason for revert: broken on chromeos
Original change's description:
> Remove VK_DEFINE_NON_DISPATCHABLE_HANDLE magic, use explicit VkHandle wrapper
>
> Overriding VK_DEFINE_NON_DISPATCHABLE_HANDLE changes the function
> signatures of Vulkan functions, changing their ABI and making us
> incompatible with real drivers. This removes that magic, and replaces it
> with an explicit wrapper, VkHandle, which has much of the same
> functionality as the original VkNonDispatchableHandle.
>
> It adds definitions for dawn_native::vulkan::VkBuffer et al, which
> shadow the native ::VkBuffer et al. This retains type safety throughout
> the Vulkan backend without changing every single usage.
>
> Notably, the following things had to change:
> - An explicit conversion from VkBuffer* to ::VkBuffer* is needed for
> arrays. This is implemented as a reinterpret_cast, which is still
> safe as the new VkHandle still has the same memory layout properties
> as VkNonDispatchableHandle did.
> - When pointing to a VkHandle as an output pointer, it's now necessary
> to explicitly get the native ::VkBuffer (via operator*) and point to it.
>
> Bug: chromium:1046362
> Change-Id: I9c5691b6e295aca1b46d4e3d0203956e4d570285
> Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15580
> Reviewed-by: Austin Eng <enga@chromium.org>
> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
> Commit-Queue: Kai Ninomiya <kainino@chromium.org>
TBR=cwallez@chromium.org,kainino@chromium.org,enga@chromium.org
Change-Id: I500df2e34fd0f245ad04c517ff028ddd7bb5a2bf
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:1046362
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15620
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
This commit is contained in:
parent
4e17d5c248
commit
f28d0ae614
|
@ -18,9 +18,6 @@
|
|||
#if !defined(DAWN_ENABLE_BACKEND_VULKAN)
|
||||
# error "vulkan_platform.h included without the Vulkan backend enabled"
|
||||
#endif
|
||||
#if defined(VULKAN_CORE_H_)
|
||||
# error "vulkan.h included before vulkan_platform.h"
|
||||
#endif
|
||||
|
||||
#include "common/Platform.h"
|
||||
|
||||
|
@ -36,9 +33,10 @@
|
|||
// (like vulkan.h on 64 bit) but makes sure the types are different on 32 bit architectures.
|
||||
|
||||
#if defined(DAWN_PLATFORM_64_BIT)
|
||||
# define DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) using object = struct object##_T*;
|
||||
# define DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) \
|
||||
using object##Native = struct object##_T*;
|
||||
#elif defined(DAWN_PLATFORM_32_BIT)
|
||||
# define DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) using object = uint64_t;
|
||||
# define DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) using object##Native = uint64_t;
|
||||
#else
|
||||
# error "Unsupported platform"
|
||||
#endif
|
||||
|
@ -55,9 +53,6 @@ DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(VkSomeHandle)
|
|||
// One way to get the alignment inside structures of a type is to look at the alignment of it
|
||||
// wrapped in a structure. Hence VkSameHandleNativeWrappe
|
||||
|
||||
namespace dawn_native { namespace vulkan {
|
||||
|
||||
namespace detail {
|
||||
template <typename T>
|
||||
struct WrapperStruct {
|
||||
T member;
|
||||
|
@ -66,27 +61,27 @@ namespace dawn_native { namespace vulkan {
|
|||
template <typename T>
|
||||
static constexpr size_t AlignOfInStruct = alignof(WrapperStruct<T>);
|
||||
|
||||
static constexpr size_t kNativeVkHandleAlignment = AlignOfInStruct<VkSomeHandle>;
|
||||
static constexpr size_t kUint64Alignment = AlignOfInStruct<uint64_t>;
|
||||
static constexpr size_t kNativeVkHandleAlignment = AlignOfInStruct<VkSomeHandleNative>;
|
||||
static constexpr size_t kUint64Alignment = AlignOfInStruct<VkSomeHandleNative>;
|
||||
|
||||
// Simple handle types that supports "nullptr_t" as a 0 value.
|
||||
template <typename Tag, typename HandleType>
|
||||
class alignas(detail::kNativeVkHandleAlignment) VkHandle {
|
||||
class alignas(kNativeVkHandleAlignment) VkNonDispatchableHandle {
|
||||
public:
|
||||
// Default constructor and assigning of VK_NULL_HANDLE
|
||||
VkHandle() = default;
|
||||
VkHandle(std::nullptr_t) {
|
||||
VkNonDispatchableHandle() = default;
|
||||
VkNonDispatchableHandle(std::nullptr_t) : mHandle(0) {
|
||||
}
|
||||
|
||||
// Use default copy constructor/assignment
|
||||
VkHandle(const VkHandle<Tag, HandleType>& other) = default;
|
||||
VkHandle& operator=(const VkHandle<Tag, HandleType>&) = default;
|
||||
VkNonDispatchableHandle(const VkNonDispatchableHandle<Tag, HandleType>& other) = default;
|
||||
VkNonDispatchableHandle& operator=(const VkNonDispatchableHandle<Tag, HandleType>&) = default;
|
||||
|
||||
// Comparisons between handles
|
||||
bool operator==(VkHandle<Tag, HandleType> other) const {
|
||||
bool operator==(VkNonDispatchableHandle<Tag, HandleType> other) const {
|
||||
return mHandle == other.mHandle;
|
||||
}
|
||||
bool operator!=(VkHandle<Tag, HandleType> other) const {
|
||||
bool operator!=(VkNonDispatchableHandle<Tag, HandleType> other) const {
|
||||
return mHandle != other.mHandle;
|
||||
}
|
||||
|
||||
|
@ -98,63 +93,65 @@ namespace dawn_native { namespace vulkan {
|
|||
return mHandle != 0;
|
||||
}
|
||||
|
||||
// Implicit conversion to real Vulkan types.
|
||||
operator HandleType() const {
|
||||
return GetHandle();
|
||||
// The regular Vulkan handle type depends on the pointer width but is always 64 bits wide.
|
||||
// - On 64bit it is an opaque pointer type, probably to help with type safety
|
||||
// - On 32bit it is a uint64_t because pointers aren't wide enough (and non dispatchable
|
||||
// handles can be optimized to not be pointer but contain GPU virtual addresses or the
|
||||
// data in a packed form).
|
||||
// Because of this we need two types of conversions from our handle type: to uint64_t and to
|
||||
// the "native" Vulkan type that may not be an uint64_t
|
||||
|
||||
static VkNonDispatchableHandle<Tag, HandleType> CreateFromU64(uint64_t handle) {
|
||||
return {handle};
|
||||
}
|
||||
|
||||
uint64_t GetU64() const {
|
||||
return mHandle;
|
||||
}
|
||||
|
||||
#if defined(DAWN_PLATFORM_64_BIT)
|
||||
static VkNonDispatchableHandle<Tag, HandleType> CreateFromHandle(HandleType handle) {
|
||||
return CreateFromU64(static_cast<uint64_t>(reinterpret_cast<intptr_t>(handle)));
|
||||
}
|
||||
|
||||
HandleType GetHandle() const {
|
||||
return mHandle;
|
||||
}
|
||||
#elif defined(DAWN_PLATFORM_32_BIT)
|
||||
static VkNonDispatchableHandle<Tag, HandleType> CreateFromHandle(HandleType handle) {
|
||||
return {handle};
|
||||
}
|
||||
|
||||
HandleType& operator*() {
|
||||
HandleType GetHandle() const {
|
||||
return mHandle;
|
||||
}
|
||||
|
||||
static VkHandle<Tag, HandleType> CreateFromHandle(HandleType handle) {
|
||||
return VkHandle{handle};
|
||||
}
|
||||
|
||||
private:
|
||||
explicit VkHandle(HandleType handle) : mHandle(handle) {
|
||||
}
|
||||
|
||||
HandleType mHandle = 0;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
static constexpr std::nullptr_t VK_NULL_HANDLE = nullptr;
|
||||
|
||||
template <typename Tag, typename HandleType>
|
||||
HandleType* AsVkArray(detail::VkHandle<Tag, HandleType>* handle) {
|
||||
return reinterpret_cast<HandleType*>(handle);
|
||||
}
|
||||
|
||||
}} // namespace dawn_native::vulkan
|
||||
|
||||
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \
|
||||
DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) \
|
||||
namespace dawn_native { namespace vulkan { \
|
||||
using object = detail::VkHandle<struct VkTag##object, ::object>; \
|
||||
static_assert(sizeof(object) == sizeof(uint64_t), ""); \
|
||||
static_assert(alignof(object) == detail::kUint64Alignment, ""); \
|
||||
static_assert(sizeof(object) == sizeof(::object), ""); \
|
||||
static_assert(alignof(object) == detail::kNativeVkHandleAlignment, ""); \
|
||||
} \
|
||||
} // namespace dawn_native::vulkan
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
// Redefine VK_NULL_HANDLE for better type safety where possible.
|
||||
#undef VK_NULL_HANDLE
|
||||
#if defined(DAWN_PLATFORM_64_BIT)
|
||||
static constexpr nullptr_t VK_NULL_HANDLE = nullptr;
|
||||
#elif defined(DAWN_PLATFORM_32_BIT)
|
||||
static constexpr uint64_t VK_NULL_HANDLE = 0;
|
||||
#else
|
||||
# error "Unsupported platform"
|
||||
#endif
|
||||
|
||||
private:
|
||||
VkNonDispatchableHandle(uint64_t handle) : mHandle(handle) {
|
||||
}
|
||||
|
||||
uint64_t mHandle = 0;
|
||||
};
|
||||
|
||||
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \
|
||||
struct VkTag##object; \
|
||||
DAWN_DEFINE_NATIVE_NON_DISPATCHABLE_HANDLE(object) \
|
||||
using object = VkNonDispatchableHandle<VkTag##object, object##Native>; \
|
||||
static_assert(sizeof(object) == sizeof(uint64_t), ""); \
|
||||
static_assert(alignof(object) == kUint64Alignment, ""); \
|
||||
static_assert(sizeof(object) == sizeof(object##Native), ""); \
|
||||
static_assert(alignof(object) == kNativeVkHandleAlignment, "");
|
||||
|
||||
# include <vulkan/vulkan.h>
|
||||
|
||||
// VK_NULL_HANDLE is defined to 0 but we don't want our handle type to compare to arbitrary
|
||||
// integers. Redefine VK_NULL_HANDLE to nullptr that has its own type.
|
||||
# undef VK_NULL_HANDLE
|
||||
# define VK_NULL_HANDLE nullptr
|
||||
|
||||
// Remove windows.h macros after vulkan_platform's include of windows.h
|
||||
#if defined(DAWN_PLATFORM_WINDOWS)
|
||||
# include "common/windows_with_undefs.h"
|
||||
|
|
|
@ -272,7 +272,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pUserData = this;
|
||||
|
||||
return CheckVkSuccess(mFunctions.CreateDebugReportCallbackEXT(
|
||||
mInstance, &createInfo, nullptr, &*mDebugReportCallback),
|
||||
mInstance, &createInfo, nullptr, &mDebugReportCallback),
|
||||
"vkCreateDebugReportcallback");
|
||||
}
|
||||
|
||||
|
|
|
@ -105,7 +105,7 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
DAWN_TRY(CheckVkSuccess(device->fn.CreateDescriptorSetLayout(
|
||||
device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreateDescriptorSetLayout"));
|
||||
|
||||
// Compute the size of descriptor pools used for this layout.
|
||||
|
@ -171,7 +171,7 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
VkDescriptorPool descriptorPool;
|
||||
DAWN_TRY(CheckVkSuccess(device->fn.CreateDescriptorPool(device->GetVkDevice(), &createInfo,
|
||||
nullptr, &*descriptorPool),
|
||||
nullptr, &descriptorPool),
|
||||
"CreateDescriptorPool"));
|
||||
|
||||
// Allocate our single set.
|
||||
|
@ -180,12 +180,11 @@ namespace dawn_native { namespace vulkan {
|
|||
allocateInfo.pNext = nullptr;
|
||||
allocateInfo.descriptorPool = descriptorPool;
|
||||
allocateInfo.descriptorSetCount = 1;
|
||||
allocateInfo.pSetLayouts = &*mHandle;
|
||||
allocateInfo.pSetLayouts = &mHandle;
|
||||
|
||||
VkDescriptorSet descriptorSet;
|
||||
MaybeError result =
|
||||
CheckVkSuccess(device->fn.AllocateDescriptorSets(device->GetVkDevice(), &allocateInfo,
|
||||
&*descriptorSet),
|
||||
MaybeError result = CheckVkSuccess(
|
||||
device->fn.AllocateDescriptorSets(device->GetVkDevice(), &allocateInfo, &descriptorSet),
|
||||
"AllocateDescriptorSets");
|
||||
|
||||
if (result.IsError()) {
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include "dawn_native/BindGroup.h"
|
||||
|
||||
#include "common/vulkan_platform.h"
|
||||
#include "dawn_native/vulkan/BindGroupLayoutVk.h"
|
||||
|
||||
namespace dawn_native { namespace vulkan {
|
||||
|
|
|
@ -147,7 +147,7 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
device->fn.CreateBuffer(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateBuffer(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"vkCreateBuffer"));
|
||||
|
||||
VkMemoryRequirements requirements;
|
||||
|
|
|
@ -106,7 +106,7 @@ namespace dawn_native { namespace vulkan {
|
|||
? dynamicOffsets[dirtyIndex].data()
|
||||
: nullptr;
|
||||
device->fn.CmdBindDescriptorSets(commands, bindPoint, pipelineLayout, dirtyIndex, 1,
|
||||
&*set, dynamicOffsetCounts[dirtyIndex],
|
||||
&set, dynamicOffsetCounts[dirtyIndex],
|
||||
dynamicOffset);
|
||||
}
|
||||
}
|
||||
|
@ -255,14 +255,14 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.flags = 0;
|
||||
createInfo.renderPass = renderPassVK;
|
||||
createInfo.attachmentCount = attachmentCount;
|
||||
createInfo.pAttachments = AsVkArray(attachments.data());
|
||||
createInfo.pAttachments = attachments.data();
|
||||
createInfo.width = renderPass->width;
|
||||
createInfo.height = renderPass->height;
|
||||
createInfo.layers = 1;
|
||||
|
||||
DAWN_TRY(
|
||||
CheckVkSuccess(device->fn.CreateFramebuffer(device->GetVkDevice(), &createInfo,
|
||||
nullptr, &*framebuffer),
|
||||
nullptr, &framebuffer),
|
||||
"CreateFramebuffer"));
|
||||
|
||||
// We don't reuse VkFramebuffers so mark the framebuffer for deletion as soon as the
|
||||
|
@ -827,7 +827,7 @@ namespace dawn_native { namespace vulkan {
|
|||
VkBuffer buffer = ToBackend(cmd->buffer)->GetHandle();
|
||||
VkDeviceSize offset = static_cast<VkDeviceSize>(cmd->offset);
|
||||
|
||||
device->fn.CmdBindVertexBuffers(commands, cmd->slot, 1, &*buffer, &offset);
|
||||
device->fn.CmdBindVertexBuffers(commands, cmd->slot, 1, &buffer, &offset);
|
||||
} break;
|
||||
|
||||
default:
|
||||
|
|
|
@ -38,7 +38,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pNext = nullptr;
|
||||
createInfo.flags = 0;
|
||||
createInfo.layout = ToBackend(descriptor->layout)->GetHandle();
|
||||
createInfo.basePipelineHandle = ::VK_NULL_HANDLE;
|
||||
createInfo.basePipelineHandle = VK_NULL_HANDLE;
|
||||
createInfo.basePipelineIndex = -1;
|
||||
|
||||
createInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||||
|
@ -51,8 +51,8 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreateComputePipelines(device->GetVkDevice(), ::VK_NULL_HANDLE, 1,
|
||||
&createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateComputePipelines(device->GetVkDevice(), VK_NULL_HANDLE, 1, &createInfo,
|
||||
nullptr, &mHandle),
|
||||
"CreateComputePipeline");
|
||||
}
|
||||
|
||||
|
|
|
@ -272,13 +272,13 @@ namespace dawn_native { namespace vulkan {
|
|||
submitInfo.pNext = nullptr;
|
||||
submitInfo.waitSemaphoreCount =
|
||||
static_cast<uint32_t>(mRecordingContext.waitSemaphores.size());
|
||||
submitInfo.pWaitSemaphores = AsVkArray(mRecordingContext.waitSemaphores.data());
|
||||
submitInfo.pWaitSemaphores = mRecordingContext.waitSemaphores.data();
|
||||
submitInfo.pWaitDstStageMask = dstStageMasks.data();
|
||||
submitInfo.commandBufferCount = 1;
|
||||
submitInfo.pCommandBuffers = &mRecordingContext.commandBuffer;
|
||||
submitInfo.signalSemaphoreCount =
|
||||
static_cast<uint32_t>(mRecordingContext.signalSemaphores.size());
|
||||
submitInfo.pSignalSemaphores = AsVkArray(mRecordingContext.signalSemaphores.data());
|
||||
submitInfo.pSignalSemaphores = mRecordingContext.signalSemaphores.data();
|
||||
|
||||
VkFence fence = VK_NULL_HANDLE;
|
||||
DAWN_TRY_ASSIGN(fence, GetUnusedFence());
|
||||
|
@ -474,7 +474,7 @@ namespace dawn_native { namespace vulkan {
|
|||
ResultOrError<VkFence> Device::GetUnusedFence() {
|
||||
if (!mUnusedFences.empty()) {
|
||||
VkFence fence = mUnusedFences.back();
|
||||
DAWN_TRY(CheckVkSuccess(fn.ResetFences(mVkDevice, 1, &*fence), "vkResetFences"));
|
||||
DAWN_TRY(CheckVkSuccess(fn.ResetFences(mVkDevice, 1, &fence), "vkResetFences"));
|
||||
|
||||
mUnusedFences.pop_back();
|
||||
return fence;
|
||||
|
@ -486,7 +486,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.flags = 0;
|
||||
|
||||
VkFence fence = VK_NULL_HANDLE;
|
||||
DAWN_TRY(CheckVkSuccess(fn.CreateFence(mVkDevice, &createInfo, nullptr, &*fence),
|
||||
DAWN_TRY(CheckVkSuccess(fn.CreateFence(mVkDevice, &createInfo, nullptr, &fence),
|
||||
"vkCreateFence"));
|
||||
|
||||
return fence;
|
||||
|
@ -539,7 +539,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.queueFamilyIndex = mQueueFamily;
|
||||
|
||||
DAWN_TRY(CheckVkSuccess(fn.CreateCommandPool(mVkDevice, &createInfo, nullptr,
|
||||
&*mRecordingContext.commandPool),
|
||||
&mRecordingContext.commandPool),
|
||||
"vkCreateCommandPool"));
|
||||
|
||||
VkCommandBufferAllocateInfo allocateInfo;
|
||||
|
@ -756,7 +756,7 @@ namespace dawn_native { namespace vulkan {
|
|||
VkResult result = VkResult::WrapUnsafe(VK_TIMEOUT);
|
||||
do {
|
||||
result = VkResult::WrapUnsafe(
|
||||
INJECT_ERROR_OR_RUN(fn.WaitForFences(mVkDevice, 1, &*fence, true, UINT64_MAX),
|
||||
INJECT_ERROR_OR_RUN(fn.WaitForFences(mVkDevice, 1, &fence, true, UINT64_MAX),
|
||||
VK_ERROR_DEVICE_LOST));
|
||||
} while (result == VK_TIMEOUT);
|
||||
|
||||
|
|
|
@ -136,7 +136,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.oldSwapchain = oldSwapchain;
|
||||
|
||||
if (mDevice->fn.CreateSwapchainKHR(mDevice->GetVkDevice(), &createInfo, nullptr,
|
||||
&*mSwapChain) != VK_SUCCESS) {
|
||||
&mSwapChain) != VK_SUCCESS) {
|
||||
ASSERT(false);
|
||||
}
|
||||
|
||||
|
@ -151,7 +151,7 @@ namespace dawn_native { namespace vulkan {
|
|||
ASSERT(count >= mConfig.minImageCount);
|
||||
mSwapChainImages.resize(count);
|
||||
if (mDevice->fn.GetSwapchainImagesKHR(mDevice->GetVkDevice(), mSwapChain, &count,
|
||||
AsVkArray(mSwapChainImages.data())) != VK_SUCCESS) {
|
||||
mSwapChainImages.data()) != VK_SUCCESS) {
|
||||
ASSERT(false);
|
||||
}
|
||||
|
||||
|
@ -168,7 +168,7 @@ namespace dawn_native { namespace vulkan {
|
|||
barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
||||
barrier.srcQueueFamilyIndex = 0;
|
||||
barrier.dstQueueFamilyIndex = 0;
|
||||
barrier.image = *image;
|
||||
barrier.image = image;
|
||||
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
barrier.subresourceRange.baseMipLevel = 0;
|
||||
barrier.subresourceRange.levelCount = 1;
|
||||
|
@ -197,22 +197,18 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pNext = nullptr;
|
||||
createInfo.flags = 0;
|
||||
if (mDevice->fn.CreateSemaphore(mDevice->GetVkDevice(), &createInfo, nullptr,
|
||||
&*semaphore) != VK_SUCCESS) {
|
||||
&semaphore) != VK_SUCCESS) {
|
||||
ASSERT(false);
|
||||
}
|
||||
}
|
||||
|
||||
if (mDevice->fn.AcquireNextImageKHR(mDevice->GetVkDevice(), mSwapChain,
|
||||
std::numeric_limits<uint64_t>::max(), semaphore,
|
||||
VkFence{}, &mLastImageIndex) != VK_SUCCESS) {
|
||||
VK_NULL_HANDLE, &mLastImageIndex) != VK_SUCCESS) {
|
||||
ASSERT(false);
|
||||
}
|
||||
|
||||
nextTexture->texture.u64 =
|
||||
#if defined(DAWN_PLATFORM_64_BIT)
|
||||
reinterpret_cast<uint64_t>
|
||||
#endif
|
||||
(*mSwapChainImages[mLastImageIndex]);
|
||||
nextTexture->texture.u64 = mSwapChainImages[mLastImageIndex].GetU64();
|
||||
mDevice->GetPendingRecordingContext()->waitSemaphores.push_back(semaphore);
|
||||
|
||||
return DAWN_SWAP_CHAIN_NO_ERROR;
|
||||
|
@ -231,7 +227,7 @@ namespace dawn_native { namespace vulkan {
|
|||
presentInfo.waitSemaphoreCount = 0;
|
||||
presentInfo.pWaitSemaphores = nullptr;
|
||||
presentInfo.swapchainCount = 1;
|
||||
presentInfo.pSwapchains = &*mSwapChain;
|
||||
presentInfo.pSwapchains = &mSwapChain;
|
||||
presentInfo.pImageIndices = &mLastImageIndex;
|
||||
presentInfo.pResults = nullptr;
|
||||
|
||||
|
|
|
@ -48,13 +48,13 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pNext = nullptr;
|
||||
createInfo.flags = 0;
|
||||
createInfo.setLayoutCount = numSetLayouts;
|
||||
createInfo.pSetLayouts = AsVkArray(setLayouts.data());
|
||||
createInfo.pSetLayouts = setLayouts.data();
|
||||
createInfo.pushConstantRangeCount = 0;
|
||||
createInfo.pPushConstantRanges = nullptr;
|
||||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreatePipelineLayout(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreatePipelineLayout(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreatePipelineLayout");
|
||||
}
|
||||
|
||||
|
|
|
@ -191,8 +191,8 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
// Create the render pass from the zillion parameters
|
||||
VkRenderPass renderPass;
|
||||
DAWN_TRY(CheckVkSuccess(mDevice->fn.CreateRenderPass(mDevice->GetVkDevice(), &createInfo,
|
||||
nullptr, &*renderPass),
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
mDevice->fn.CreateRenderPass(mDevice->GetVkDevice(), &createInfo, nullptr, &renderPass),
|
||||
"CreateRenderPass"));
|
||||
return renderPass;
|
||||
}
|
||||
|
|
|
@ -495,12 +495,12 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.layout = ToBackend(GetLayout())->GetHandle();
|
||||
createInfo.renderPass = renderPass;
|
||||
createInfo.subpass = 0;
|
||||
createInfo.basePipelineHandle = VkPipeline{};
|
||||
createInfo.basePipelineHandle = VK_NULL_HANDLE;
|
||||
createInfo.basePipelineIndex = -1;
|
||||
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreateGraphicsPipelines(device->GetVkDevice(), VkPipelineCache{}, 1,
|
||||
&createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateGraphicsPipelines(device->GetVkDevice(), VK_NULL_HANDLE, 1,
|
||||
&createInfo, nullptr, &mHandle),
|
||||
"CreateGraphicsPipeline");
|
||||
}
|
||||
|
||||
|
|
|
@ -73,7 +73,7 @@ namespace dawn_native { namespace vulkan {
|
|||
// First check OOM that we want to surface to the application.
|
||||
DAWN_TRY(CheckVkOOMThenSuccess(
|
||||
mDevice->fn.AllocateMemory(mDevice->GetVkDevice(), &allocateInfo, nullptr,
|
||||
&*allocatedMemory),
|
||||
&allocatedMemory),
|
||||
"vkAllocateMemory"));
|
||||
|
||||
ASSERT(allocatedMemory != VK_NULL_HANDLE);
|
||||
|
|
|
@ -87,7 +87,7 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreateSampler(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateSampler(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreateSampler");
|
||||
}
|
||||
|
||||
|
|
|
@ -74,7 +74,7 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
Device* device = ToBackend(GetDevice());
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreateShaderModule(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateShaderModule(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreateShaderModule");
|
||||
}
|
||||
|
||||
|
|
|
@ -36,7 +36,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pQueueFamilyIndices = 0;
|
||||
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
mDevice->fn.CreateBuffer(mDevice->GetVkDevice(), &createInfo, nullptr, &*mBuffer),
|
||||
mDevice->fn.CreateBuffer(mDevice->GetVkDevice(), &createInfo, nullptr, &mBuffer),
|
||||
"vkCreateBuffer"));
|
||||
|
||||
VkMemoryRequirements requirements;
|
||||
|
|
|
@ -47,8 +47,7 @@ namespace dawn_native { namespace vulkan {
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
VkImage nativeTexture =
|
||||
VkImage::CreateFromHandle(reinterpret_cast<::VkImage>(next.texture.u64));
|
||||
VkImage nativeTexture = VkImage::CreateFromU64(next.texture.u64);
|
||||
return new Texture(ToBackend(GetDevice()), descriptor, nativeTexture);
|
||||
}
|
||||
|
||||
|
|
|
@ -460,7 +460,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
device->fn.CreateImage(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateImage(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreateImage"));
|
||||
|
||||
// Create the image memory and associate it with the container
|
||||
|
@ -806,7 +806,7 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.subresourceRange.layerCount = descriptor->arrayLayerCount;
|
||||
|
||||
return CheckVkSuccess(
|
||||
device->fn.CreateImageView(device->GetVkDevice(), &createInfo, nullptr, &*mHandle),
|
||||
device->fn.CreateImageView(device->GetVkDevice(), &createInfo, nullptr, &mHandle),
|
||||
"CreateImageView");
|
||||
}
|
||||
|
||||
|
|
|
@ -42,7 +42,7 @@ namespace dawn_native { namespace vulkan {
|
|||
// Explicitly export this function because it uses the "native" type for surfaces while the
|
||||
// header as seen in this file uses the wrapped type.
|
||||
DAWN_NATIVE_EXPORT DawnSwapChainImplementation
|
||||
CreateNativeSwapChainImpl(WGPUDevice device, ::VkSurfaceKHR surfaceNative) {
|
||||
CreateNativeSwapChainImpl(WGPUDevice device, VkSurfaceKHRNative surfaceNative) {
|
||||
Device* backendDevice = reinterpret_cast<Device*>(device);
|
||||
VkSurfaceKHR surface = VkSurfaceKHR::CreateFromHandle(surfaceNative);
|
||||
|
||||
|
|
|
@ -130,7 +130,7 @@ namespace dawn_native { namespace vulkan { namespace external_memory {
|
|||
|
||||
VkDeviceMemory allocatedMemory = VK_NULL_HANDLE;
|
||||
DAWN_TRY(CheckVkSuccess(mDevice->fn.AllocateMemory(mDevice->GetVkDevice(), &allocateInfo,
|
||||
nullptr, &*allocatedMemory),
|
||||
nullptr, &allocatedMemory),
|
||||
"vkAllocateMemory"));
|
||||
return allocatedMemory;
|
||||
}
|
||||
|
@ -146,7 +146,7 @@ namespace dawn_native { namespace vulkan { namespace external_memory {
|
|||
|
||||
VkImage image;
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
mDevice->fn.CreateImage(mDevice->GetVkDevice(), &createInfo, nullptr, &*image),
|
||||
mDevice->fn.CreateImage(mDevice->GetVkDevice(), &createInfo, nullptr, &image),
|
||||
"CreateImage"));
|
||||
return image;
|
||||
}
|
||||
|
|
|
@ -72,7 +72,7 @@ namespace dawn_native { namespace vulkan { namespace external_semaphore {
|
|||
info.flags = 0;
|
||||
|
||||
DAWN_TRY(CheckVkSuccess(
|
||||
mDevice->fn.CreateSemaphore(mDevice->GetVkDevice(), &info, nullptr, &*semaphore),
|
||||
mDevice->fn.CreateSemaphore(mDevice->GetVkDevice(), &info, nullptr, &semaphore),
|
||||
"vkCreateSemaphore"));
|
||||
|
||||
VkImportSemaphoreFdInfoKHR importSemaphoreFdInfo;
|
||||
|
@ -109,7 +109,7 @@ namespace dawn_native { namespace vulkan { namespace external_semaphore {
|
|||
VkSemaphore signalSemaphore;
|
||||
DAWN_TRY(
|
||||
CheckVkSuccess(mDevice->fn.CreateSemaphore(mDevice->GetVkDevice(), &semaphoreCreateInfo,
|
||||
nullptr, &*signalSemaphore),
|
||||
nullptr, &signalSemaphore),
|
||||
"vkCreateSemaphore"));
|
||||
return signalSemaphore;
|
||||
}
|
||||
|
|
|
@ -47,8 +47,8 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
DAWN_NATIVE_EXPORT PFN_vkVoidFunction GetInstanceProcAddr(WGPUDevice device, const char* pName);
|
||||
|
||||
DAWN_NATIVE_EXPORT DawnSwapChainImplementation
|
||||
CreateNativeSwapChainImpl(WGPUDevice device, ::VkSurfaceKHR surface);
|
||||
DAWN_NATIVE_EXPORT DawnSwapChainImplementation CreateNativeSwapChainImpl(WGPUDevice device,
|
||||
VkSurfaceKHR surface);
|
||||
DAWN_NATIVE_EXPORT WGPUTextureFormat
|
||||
GetNativeSwapChainPreferredFormat(const DawnSwapChainImplementation* swapChain);
|
||||
|
||||
|
|
|
@ -32,30 +32,30 @@
|
|||
// them.
|
||||
#define EXPECT_BUFFER_U32_EQ(expected, buffer, offset) \
|
||||
AddBufferExpectation(__FILE__, __LINE__, buffer, offset, sizeof(uint32_t), \
|
||||
new ::detail::ExpectEq<uint32_t>(expected))
|
||||
new detail::ExpectEq<uint32_t>(expected))
|
||||
|
||||
#define EXPECT_BUFFER_U32_RANGE_EQ(expected, buffer, offset, count) \
|
||||
AddBufferExpectation(__FILE__, __LINE__, buffer, offset, sizeof(uint32_t) * count, \
|
||||
new ::detail::ExpectEq<uint32_t>(expected, count))
|
||||
new detail::ExpectEq<uint32_t>(expected, count))
|
||||
|
||||
// Test a pixel of the mip level 0 of a 2D texture.
|
||||
#define EXPECT_PIXEL_RGBA8_EQ(expected, texture, x, y) \
|
||||
AddTextureExpectation(__FILE__, __LINE__, texture, x, y, 1, 1, 0, 0, sizeof(RGBA8), \
|
||||
new ::detail::ExpectEq<RGBA8>(expected))
|
||||
new detail::ExpectEq<RGBA8>(expected))
|
||||
|
||||
#define EXPECT_TEXTURE_RGBA8_EQ(expected, texture, x, y, width, height, level, slice) \
|
||||
AddTextureExpectation(__FILE__, __LINE__, texture, x, y, width, height, level, slice, \
|
||||
sizeof(RGBA8), \
|
||||
new ::detail::ExpectEq<RGBA8>(expected, (width) * (height)))
|
||||
new detail::ExpectEq<RGBA8>(expected, (width) * (height)))
|
||||
|
||||
#define EXPECT_PIXEL_FLOAT_EQ(expected, texture, x, y) \
|
||||
AddTextureExpectation(__FILE__, __LINE__, texture, x, y, 1, 1, 0, 0, sizeof(float), \
|
||||
new ::detail::ExpectEq<float>(expected))
|
||||
new detail::ExpectEq<float>(expected))
|
||||
|
||||
#define EXPECT_TEXTURE_FLOAT_EQ(expected, texture, x, y, width, height, level, slice) \
|
||||
AddTextureExpectation(__FILE__, __LINE__, texture, x, y, width, height, level, slice, \
|
||||
sizeof(float), \
|
||||
new ::detail::ExpectEq<float>(expected, (width) * (height)))
|
||||
new detail::ExpectEq<float>(expected, (width) * (height)))
|
||||
|
||||
// Should only be used to test validation of function that can't be tested by regular validation
|
||||
// tests;
|
||||
|
|
|
@ -25,8 +25,6 @@
|
|||
#include "utils/SystemUtils.h"
|
||||
#include "utils/WGPUHelpers.h"
|
||||
|
||||
namespace dawn_native { namespace vulkan {
|
||||
|
||||
namespace {
|
||||
|
||||
class VulkanImageWrappingTestBase : public DawnTest {
|
||||
|
@ -40,7 +38,7 @@ namespace dawn_native { namespace vulkan {
|
|||
}
|
||||
|
||||
// Creates a VkImage with external memory
|
||||
::VkResult CreateImage(dawn_native::vulkan::Device* deviceVk,
|
||||
VkResult CreateImage(dawn_native::vulkan::Device* deviceVk,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
VkFormat format,
|
||||
|
@ -70,20 +68,18 @@ namespace dawn_native { namespace vulkan {
|
|||
createInfo.pQueueFamilyIndices = nullptr;
|
||||
createInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
|
||||
return deviceVk->fn.CreateImage(deviceVk->GetVkDevice(), &createInfo, nullptr,
|
||||
&**image);
|
||||
return deviceVk->fn.CreateImage(deviceVk->GetVkDevice(), &createInfo, nullptr, image);
|
||||
}
|
||||
|
||||
// Allocates memory for an image
|
||||
::VkResult AllocateMemory(dawn_native::vulkan::Device* deviceVk,
|
||||
VkResult AllocateMemory(dawn_native::vulkan::Device* deviceVk,
|
||||
VkImage handle,
|
||||
VkDeviceMemory* allocation,
|
||||
VkDeviceSize* allocationSize,
|
||||
uint32_t* memoryTypeIndex) {
|
||||
// Create the image memory and associate it with the container
|
||||
VkMemoryRequirements requirements;
|
||||
deviceVk->fn.GetImageMemoryRequirements(deviceVk->GetVkDevice(), handle,
|
||||
&requirements);
|
||||
deviceVk->fn.GetImageMemoryRequirements(deviceVk->GetVkDevice(), handle, &requirements);
|
||||
|
||||
// Import memory from file descriptor
|
||||
VkExportMemoryAllocateInfoKHR externalInfo;
|
||||
|
@ -103,11 +99,11 @@ namespace dawn_native { namespace vulkan {
|
|||
*memoryTypeIndex = allocateInfo.memoryTypeIndex;
|
||||
|
||||
return deviceVk->fn.AllocateMemory(deviceVk->GetVkDevice(), &allocateInfo, nullptr,
|
||||
&**allocation);
|
||||
allocation);
|
||||
}
|
||||
|
||||
// Binds memory to an image
|
||||
::VkResult BindMemory(dawn_native::vulkan::Device* deviceVk,
|
||||
VkResult BindMemory(dawn_native::vulkan::Device* deviceVk,
|
||||
VkImage handle,
|
||||
VkDeviceMemory* memory) {
|
||||
return deviceVk->fn.BindImageMemory(deviceVk->GetVkDevice(), handle, *memory, 0);
|
||||
|
@ -138,10 +134,10 @@ namespace dawn_native { namespace vulkan {
|
|||
VkDeviceSize* allocationSize,
|
||||
uint32_t* memoryTypeIndex,
|
||||
int* memoryFd) {
|
||||
::VkResult result = CreateImage(deviceVk, width, height, format, handle);
|
||||
VkResult result = CreateImage(deviceVk, width, height, format, handle);
|
||||
EXPECT_EQ(result, VK_SUCCESS) << "Failed to create external image";
|
||||
|
||||
::VkResult resultBool =
|
||||
VkResult resultBool =
|
||||
AllocateMemory(deviceVk, *handle, allocation, allocationSize, memoryTypeIndex);
|
||||
EXPECT_EQ(resultBool, VK_SUCCESS) << "Failed to allocate external memory";
|
||||
|
||||
|
@ -169,8 +165,7 @@ namespace dawn_native { namespace vulkan {
|
|||
descriptor.memoryFD = memoryFd;
|
||||
descriptor.waitFDs = waitFDs;
|
||||
|
||||
WGPUTexture texture =
|
||||
dawn_native::vulkan::WrapVulkanImage(device.Get(), &descriptor);
|
||||
WGPUTexture texture = dawn_native::vulkan::WrapVulkanImage(device.Get(), &descriptor);
|
||||
|
||||
if (expectValid) {
|
||||
EXPECT_NE(texture, nullptr) << "Failed to wrap image, are external memory / "
|
||||
|
@ -183,8 +178,8 @@ namespace dawn_native { namespace vulkan {
|
|||
}
|
||||
|
||||
// Exports the signal from a wrapped texture and ignores it
|
||||
// We have to export the signal before destroying the wrapped texture else it's an
|
||||
// assertion failure
|
||||
// We have to export the signal before destroying the wrapped texture else it's an assertion
|
||||
// failure
|
||||
void IgnoreSignalSemaphore(wgpu::Device device, wgpu::Texture wrappedTexture) {
|
||||
int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(device.Get(),
|
||||
wrappedTexture.Get());
|
||||
|
@ -207,8 +202,8 @@ namespace dawn_native { namespace vulkan {
|
|||
}
|
||||
|
||||
CreateBindExportImage(deviceVk, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, &defaultImage,
|
||||
&defaultAllocation, &defaultAllocationSize,
|
||||
&defaultMemoryTypeIndex, &defaultFd);
|
||||
&defaultAllocation, &defaultAllocationSize, &defaultMemoryTypeIndex,
|
||||
&defaultFd);
|
||||
defaultDescriptor.dimension = wgpu::TextureDimension::e2D;
|
||||
defaultDescriptor.format = wgpu::TextureFormat::RGBA8Unorm;
|
||||
defaultDescriptor.size = {1, 1, 1};
|
||||
|
@ -322,8 +317,8 @@ namespace dawn_native { namespace vulkan {
|
|||
defaultMemoryTypeIndex, {}, true, true);
|
||||
ASSERT_NE(texture.Get(), nullptr);
|
||||
IgnoreSignalSemaphore(device, texture);
|
||||
ASSERT_DEVICE_ERROR(int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(
|
||||
device.Get(), texture.Get()));
|
||||
ASSERT_DEVICE_ERROR(
|
||||
int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(device.Get(), texture.Get()));
|
||||
ASSERT_EQ(fd, -1);
|
||||
}
|
||||
|
||||
|
@ -332,8 +327,8 @@ namespace dawn_native { namespace vulkan {
|
|||
DAWN_SKIP_TEST_IF(UsesWire());
|
||||
wgpu::Texture texture = device.CreateTexture(&defaultDescriptor);
|
||||
ASSERT_NE(texture.Get(), nullptr);
|
||||
ASSERT_DEVICE_ERROR(int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(
|
||||
device.Get(), texture.Get()));
|
||||
ASSERT_DEVICE_ERROR(
|
||||
int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(device.Get(), texture.Get()));
|
||||
ASSERT_EQ(fd, -1);
|
||||
}
|
||||
|
||||
|
@ -343,8 +338,8 @@ namespace dawn_native { namespace vulkan {
|
|||
wgpu::Texture texture = device.CreateTexture(&defaultDescriptor);
|
||||
ASSERT_NE(texture.Get(), nullptr);
|
||||
texture.Destroy();
|
||||
ASSERT_DEVICE_ERROR(int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(
|
||||
device.Get(), texture.Get()));
|
||||
ASSERT_DEVICE_ERROR(
|
||||
int fd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(device.Get(), texture.Get()));
|
||||
ASSERT_EQ(fd, -1);
|
||||
}
|
||||
|
||||
|
@ -359,8 +354,7 @@ namespace dawn_native { namespace vulkan {
|
|||
}
|
||||
|
||||
// Create another device based on the original
|
||||
backendAdapter =
|
||||
reinterpret_cast<dawn_native::vulkan::Adapter*>(deviceVk->GetAdapter());
|
||||
backendAdapter = reinterpret_cast<dawn_native::vulkan::Adapter*>(deviceVk->GetAdapter());
|
||||
deviceDescriptor.forceEnabledToggles = GetParam().forceEnabledWorkarounds;
|
||||
deviceDescriptor.forceDisabledToggles = GetParam().forceDisabledWorkarounds;
|
||||
|
||||
|
@ -369,8 +363,8 @@ namespace dawn_native { namespace vulkan {
|
|||
secondDevice = wgpu::Device::Acquire(reinterpret_cast<WGPUDevice>(secondDeviceVk));
|
||||
|
||||
CreateBindExportImage(deviceVk, 1, 1, VK_FORMAT_R8G8B8A8_UNORM, &defaultImage,
|
||||
&defaultAllocation, &defaultAllocationSize,
|
||||
&defaultMemoryTypeIndex, &defaultFd);
|
||||
&defaultAllocation, &defaultAllocationSize, &defaultMemoryTypeIndex,
|
||||
&defaultFd);
|
||||
defaultDescriptor.dimension = wgpu::TextureDimension::e2D;
|
||||
defaultDescriptor.format = wgpu::TextureFormat::RGBA8Unorm;
|
||||
defaultDescriptor.size = {1, 1, 1};
|
||||
|
@ -487,9 +481,8 @@ namespace dawn_native { namespace vulkan {
|
|||
TEST_P(VulkanImageWrappingUsageTests, ClearImageAcrossDevicesAliased) {
|
||||
DAWN_SKIP_TEST_IF(UsesWire());
|
||||
// Import the image on |device
|
||||
wgpu::Texture wrappedTextureAlias =
|
||||
WrapVulkanImage(device, &defaultDescriptor, defaultFd, defaultAllocationSize,
|
||||
defaultMemoryTypeIndex, {});
|
||||
wgpu::Texture wrappedTextureAlias = WrapVulkanImage(
|
||||
device, &defaultDescriptor, defaultFd, defaultAllocationSize, defaultMemoryTypeIndex, {});
|
||||
|
||||
int memoryFd = GetMemoryFd(deviceVk, defaultAllocation);
|
||||
|
||||
|
@ -595,9 +588,8 @@ namespace dawn_native { namespace vulkan {
|
|||
DAWN_SKIP_TEST_IF(UsesWire());
|
||||
|
||||
// Import the image on |device|
|
||||
wgpu::Texture wrappedTexture =
|
||||
WrapVulkanImage(device, &defaultDescriptor, defaultFd, defaultAllocationSize,
|
||||
defaultMemoryTypeIndex, {});
|
||||
wgpu::Texture wrappedTexture = WrapVulkanImage(
|
||||
device, &defaultDescriptor, defaultFd, defaultAllocationSize, defaultMemoryTypeIndex, {});
|
||||
|
||||
// Clear |wrappedTexture| on |device|
|
||||
ClearImage(device, wrappedTexture, {5 / 255.0f, 6 / 255.0f, 7 / 255.0f, 8 / 255.0f});
|
||||
|
@ -621,8 +613,8 @@ namespace dawn_native { namespace vulkan {
|
|||
secondDeviceWrappedTexture);
|
||||
|
||||
// Re-import back into |device|, waiting on |secondDevice|'s signal
|
||||
signalFd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(
|
||||
secondDevice.Get(), secondDeviceWrappedTexture.Get());
|
||||
signalFd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(secondDevice.Get(),
|
||||
secondDeviceWrappedTexture.Get());
|
||||
memoryFd = GetMemoryFd(deviceVk, defaultAllocation);
|
||||
|
||||
wgpu::Texture nextWrappedTexture =
|
||||
|
@ -703,9 +695,8 @@ namespace dawn_native { namespace vulkan {
|
|||
DAWN_SKIP_TEST_IF(UsesWire());
|
||||
|
||||
// Import the image on |device|
|
||||
wgpu::Texture wrappedTexture =
|
||||
WrapVulkanImage(device, &defaultDescriptor, defaultFd, defaultAllocationSize,
|
||||
defaultMemoryTypeIndex, {});
|
||||
wgpu::Texture wrappedTexture = WrapVulkanImage(
|
||||
device, &defaultDescriptor, defaultFd, defaultAllocationSize, defaultMemoryTypeIndex, {});
|
||||
|
||||
// Clear |wrappedTexture| on |device|
|
||||
ClearImage(device, wrappedTexture, {5 / 255.0f, 6 / 255.0f, 7 / 255.0f, 8 / 255.0f});
|
||||
|
@ -747,8 +738,8 @@ namespace dawn_native { namespace vulkan {
|
|||
secondDeviceQueue.Submit(1, &commands);
|
||||
|
||||
// Re-import back into |device|, waiting on |secondDevice|'s signal
|
||||
signalFd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(
|
||||
secondDevice.Get(), secondDeviceWrappedTexture.Get());
|
||||
signalFd = dawn_native::vulkan::ExportSignalSemaphoreOpaqueFD(secondDevice.Get(),
|
||||
secondDeviceWrappedTexture.Get());
|
||||
memoryFd = GetMemoryFd(deviceVk, defaultAllocation);
|
||||
|
||||
wgpu::Texture nextWrappedTexture =
|
||||
|
@ -825,8 +816,7 @@ namespace dawn_native { namespace vulkan {
|
|||
// Create device 3
|
||||
dawn_native::vulkan::Device* thirdDeviceVk = reinterpret_cast<dawn_native::vulkan::Device*>(
|
||||
backendAdapter->CreateDevice(&deviceDescriptor));
|
||||
wgpu::Device thirdDevice =
|
||||
wgpu::Device::Acquire(reinterpret_cast<WGPUDevice>(thirdDeviceVk));
|
||||
wgpu::Device thirdDevice = wgpu::Device::Acquire(reinterpret_cast<WGPUDevice>(thirdDeviceVk));
|
||||
|
||||
// Make queue for device 2 and 3
|
||||
wgpu::Queue secondDeviceQueue = secondDevice.CreateQueue();
|
||||
|
@ -858,15 +848,14 @@ namespace dawn_native { namespace vulkan {
|
|||
&allocationSizeC, &memoryTypeIndexC, &memoryFdC);
|
||||
|
||||
// Import TexA, TexB on device 3
|
||||
wgpu::Texture wrappedTexADevice3 = WrapVulkanImage(
|
||||
thirdDevice, &defaultDescriptor, memoryFdA, allocationSizeA, memoryTypeIndexA, {});
|
||||
wgpu::Texture wrappedTexADevice3 = WrapVulkanImage(thirdDevice, &defaultDescriptor, memoryFdA,
|
||||
allocationSizeA, memoryTypeIndexA, {});
|
||||
|
||||
wgpu::Texture wrappedTexBDevice3 = WrapVulkanImage(
|
||||
thirdDevice, &defaultDescriptor, memoryFdB, allocationSizeB, memoryTypeIndexB, {});
|
||||
wgpu::Texture wrappedTexBDevice3 = WrapVulkanImage(thirdDevice, &defaultDescriptor, memoryFdB,
|
||||
allocationSizeB, memoryTypeIndexB, {});
|
||||
|
||||
// Clear TexA
|
||||
ClearImage(thirdDevice, wrappedTexADevice3,
|
||||
{1 / 255.0f, 2 / 255.0f, 3 / 255.0f, 4 / 255.0f});
|
||||
ClearImage(thirdDevice, wrappedTexADevice3, {1 / 255.0f, 2 / 255.0f, 3 / 255.0f, 4 / 255.0f});
|
||||
|
||||
// Copy A->B
|
||||
SimpleCopyTextureToTexture(thirdDevice, thirdDeviceQueue, wrappedTexADevice3,
|
||||
|
@ -882,8 +871,8 @@ namespace dawn_native { namespace vulkan {
|
|||
WrapVulkanImage(secondDevice, &defaultDescriptor, memoryFdB, allocationSizeB,
|
||||
memoryTypeIndexB, {signalFdTexBDevice3});
|
||||
|
||||
wgpu::Texture wrappedTexCDevice2 = WrapVulkanImage(
|
||||
secondDevice, &defaultDescriptor, memoryFdC, allocationSizeC, memoryTypeIndexC, {});
|
||||
wgpu::Texture wrappedTexCDevice2 = WrapVulkanImage(secondDevice, &defaultDescriptor, memoryFdC,
|
||||
allocationSizeC, memoryTypeIndexC, {});
|
||||
|
||||
// Copy B->C on device 2
|
||||
SimpleCopyTextureToTexture(secondDevice, secondDeviceQueue, wrappedTexBDevice2,
|
||||
|
@ -896,8 +885,8 @@ namespace dawn_native { namespace vulkan {
|
|||
// Import TexC on device 1
|
||||
memoryFdC = GetMemoryFd(deviceVk, allocationC);
|
||||
wgpu::Texture wrappedTexCDevice1 =
|
||||
WrapVulkanImage(device, &defaultDescriptor, memoryFdC, allocationSizeC,
|
||||
memoryTypeIndexC, {signalFdTexCDevice2});
|
||||
WrapVulkanImage(device, &defaultDescriptor, memoryFdC, allocationSizeC, memoryTypeIndexC,
|
||||
{signalFdTexCDevice2});
|
||||
|
||||
// Create TexD on device 1
|
||||
wgpu::Texture texD = device.CreateTexture(&defaultDescriptor);
|
||||
|
@ -950,8 +939,8 @@ namespace dawn_native { namespace vulkan {
|
|||
int memoryFdA;
|
||||
VkDeviceSize allocationSizeA;
|
||||
uint32_t memoryTypeIndexA;
|
||||
CreateBindExportImage(secondDeviceVk, 640, 480, VK_FORMAT_R8G8B8A8_UNORM, &imageA,
|
||||
&allocationA, &allocationSizeA, &memoryTypeIndexA, &memoryFdA);
|
||||
CreateBindExportImage(secondDeviceVk, 640, 480, VK_FORMAT_R8G8B8A8_UNORM, &imageA, &allocationA,
|
||||
&allocationSizeA, &memoryTypeIndexA, &memoryFdA);
|
||||
|
||||
// Import the image on |secondDevice|
|
||||
wgpu::Texture wrappedTexture = WrapVulkanImage(secondDevice, &descriptor, memoryFdA,
|
||||
|
@ -979,8 +968,7 @@ namespace dawn_native { namespace vulkan {
|
|||
{
|
||||
wgpu::Buffer copySrcBuffer =
|
||||
utils::CreateBufferFromData(secondDevice, data, size, wgpu::BufferUsage::CopySrc);
|
||||
wgpu::BufferCopyView copySrc =
|
||||
utils::CreateBufferCopyView(copySrcBuffer, 0, rowPitch, 0);
|
||||
wgpu::BufferCopyView copySrc = utils::CreateBufferCopyView(copySrcBuffer, 0, rowPitch, 0);
|
||||
wgpu::TextureCopyView copyDst =
|
||||
utils::CreateTextureCopyView(wrappedTexture, 0, 0, {0, 0, 0});
|
||||
wgpu::Extent3D copySize = {width, height, 1};
|
||||
|
@ -1007,8 +995,7 @@ namespace dawn_native { namespace vulkan {
|
|||
{
|
||||
wgpu::TextureCopyView copySrc =
|
||||
utils::CreateTextureCopyView(nextWrappedTexture, 0, 0, {0, 0, 0});
|
||||
wgpu::BufferCopyView copyDst =
|
||||
utils::CreateBufferCopyView(copyDstBuffer, 0, rowPitch, 0);
|
||||
wgpu::BufferCopyView copyDst = utils::CreateBufferCopyView(copyDstBuffer, 0, rowPitch, 0);
|
||||
|
||||
wgpu::Extent3D copySize = {width, height, 1};
|
||||
|
||||
|
@ -1028,5 +1015,3 @@ namespace dawn_native { namespace vulkan {
|
|||
|
||||
DAWN_INSTANTIATE_TEST(VulkanImageWrappingValidationTests, VulkanBackend);
|
||||
DAWN_INSTANTIATE_TEST(VulkanImageWrappingUsageTests, VulkanBackend);
|
||||
|
||||
}} // namespace dawn_native::vulkan
|
||||
|
|
Loading…
Reference in New Issue