ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Vk: fix compilation on 32-bit targets.

pull/539/head
Vladimír Vondruš 4 years ago
parent
9d7e90b950
commit
1111b58ce7
12 changed files with 153 additions and 92 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/Magnum/Vk/Memory.cpp
  2. 6
      src/Magnum/Vk/Test/BufferTest.cpp
  3. 32
      src/Magnum/Vk/Test/DescriptorSetLayoutTest.cpp
  4. 50
      src/Magnum/Vk/Test/FramebufferTest.cpp
  5. 18
      src/Magnum/Vk/Test/ImageTest.cpp
  6. 4
      src/Magnum/Vk/Test/ImageViewTest.cpp
  7. 32
      src/Magnum/Vk/Test/MeshTest.cpp
  8. 16
      src/Magnum/Vk/Test/PipelineLayoutTest.cpp
  9. 36
      src/Magnum/Vk/Test/PipelineTest.cpp
  10. 18
      src/Magnum/Vk/Test/QueueTest.cpp
  11. 12
      src/Magnum/Vk/Test/RenderPassTest.cpp
  12. 17
      src/Magnum/Vk/Test/ShaderSetTest.cpp

4
src/Magnum/Vk/Memory.cpp
Unescape View File

@ -102,7 +102,7 @@ Memory& Memory::operator=(Memory&& other) noexcept {
Containers::Array<char, MemoryMapDeleter> Memory::map(const UnsignedLong offset, const UnsignedLong size) {
void* data;
MAGNUM_VK_INTERNAL_ASSERT_SUCCESS((**_device).MapMemory(*_device, _handle, offset, size, {}, &data));
return Containers::Array<char, MemoryMapDeleter>{static_cast<char*>(data), size, MemoryMapDeleter{(**_device).UnmapMemory, *_device, _handle}};
return Containers::Array<char, MemoryMapDeleter>{static_cast<char*>(data), std::size_t(size), MemoryMapDeleter{(**_device).UnmapMemory, *_device, _handle}};
}
Containers::Array<char, MemoryMapDeleter> Memory::map() {
@ -117,7 +117,7 @@ Containers::Array<const char, MemoryMapDeleter> Memory::mapRead(const UnsignedLo
the order of operations is unspecified and the deleter could be queried
after release() got called */
const MemoryMapDeleter deleter = out.deleter();
return Containers::Array<const char, MemoryMapDeleter>{out.release(), size, deleter};
return Containers::Array<const char, MemoryMapDeleter>{out.release(), std::size_t(size), deleter};
}
Containers::Array<const char, MemoryMapDeleter> Memory::mapRead() {

6
src/Magnum/Vk/Test/BufferTest.cpp
Unescape View File

@ -221,8 +221,10 @@ void BufferTest::bufferCopyConvertDisallowed() {
}
void BufferTest::copyBufferInfoConstruct() {
auto a = reinterpret_cast<VkBuffer>(0xdead);
auto b = reinterpret_cast<VkBuffer>(0xcafe);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xcafe));
CopyBufferInfo info{a, b, {
{3, 0, 0},

32
src/Magnum/Vk/Test/DescriptorSetLayoutTest.cpp
Unescape View File

@ -109,14 +109,16 @@ void DescriptorSetLayoutTest::bindingConstructFlags() {
}
void DescriptorSetLayoutTest::bindingConstructImmutableSamplers() {
DescriptorSetLayoutBinding binding{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(0xdead), reinterpret_cast<VkSampler>(0xbeef), reinterpret_cast<VkSampler>(0xcafe)}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding binding{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
CORRADE_COMPARE(binding->binding, 15);
CORRADE_COMPARE(binding->descriptorType, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
CORRADE_COMPARE(binding->descriptorCount, 3);
CORRADE_VERIFY(binding->pImmutableSamplers);
CORRADE_COMPARE(binding->pImmutableSamplers[0], reinterpret_cast<VkSampler>(0xdead));
CORRADE_COMPARE(binding->pImmutableSamplers[1], reinterpret_cast<VkSampler>(0xbeef));
CORRADE_COMPARE(binding->pImmutableSamplers[2], reinterpret_cast<VkSampler>(0xcafe));
CORRADE_COMPARE(binding->pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(binding->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(binding->pImmutableSamplers[2], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe)));
CORRADE_COMPARE(binding->stageFlags, VK_SHADER_STAGE_FRAGMENT_BIT);
CORRADE_COMPARE(binding.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
}
@ -150,16 +152,18 @@ void DescriptorSetLayoutTest::bindingConstructCopy() {
}
void DescriptorSetLayoutTest::bindingConstructMove() {
DescriptorSetLayoutBinding a{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(0xdead), reinterpret_cast<VkSampler>(0xbeef), reinterpret_cast<VkSampler>(0xcafe)}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding a{15, DescriptorType::SampledImage, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}, ShaderStage::Fragment, DescriptorSetLayoutBinding::Flag::UpdateAfterBind};
CORRADE_COMPARE(a->descriptorCount, 3);
CORRADE_VERIFY(a->pImmutableSamplers);
CORRADE_COMPARE(a->pImmutableSamplers[1], reinterpret_cast<VkSampler>(0xbeef));
CORRADE_COMPARE(a->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
DescriptorSetLayoutBinding b = std::move(a);
CORRADE_VERIFY(!a->pImmutableSamplers);
CORRADE_COMPARE(b->descriptorCount, 3);
CORRADE_VERIFY(b->pImmutableSamplers);
CORRADE_COMPARE(b->pImmutableSamplers[1], reinterpret_cast<VkSampler>(0xbeef));
CORRADE_COMPARE(b->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(b.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
DescriptorSetLayoutBinding c{3, {}};
@ -167,7 +171,7 @@ void DescriptorSetLayoutTest::bindingConstructMove() {
CORRADE_VERIFY(!b->pImmutableSamplers);
CORRADE_COMPARE(c->descriptorCount, 3);
CORRADE_VERIFY(c->pImmutableSamplers);
CORRADE_COMPARE(c->pImmutableSamplers[1], reinterpret_cast<VkSampler>(0xbeef));
CORRADE_COMPARE(c->pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(c.flags(), VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT);
}
@ -212,12 +216,14 @@ void DescriptorSetLayoutTest::createInfoConstructBindingFlags() {
}
void DescriptorSetLayoutTest::createInfoConstructBindingImmutableSamplers() {
DescriptorSetLayoutBinding binding{3, DescriptorType::Sampler, {reinterpret_cast<VkSampler>(0xdead), reinterpret_cast<VkSampler>(0xbeef)}};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
DescriptorSetLayoutBinding binding{3, DescriptorType::Sampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef))}};
DescriptorSetLayoutCreateInfo info{{
{{7, DescriptorType::UniformBuffer}},
binding,
{{12, DescriptorType::CombinedImageSampler, {reinterpret_cast<VkSampler>(0xcafe)}}},
{{12, DescriptorType::CombinedImageSampler, {reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe))}}},
}};
CORRADE_COMPARE(info->bindingCount, 3);
CORRADE_VERIFY(info->pBindings);
@ -233,14 +239,14 @@ void DescriptorSetLayoutTest::createInfoConstructBindingImmutableSamplers() {
CORRADE_VERIFY(info->pBindings[1].pImmutableSamplers);
/* The samplers should get copied, not referenced */
CORRADE_VERIFY(info->pBindings[1].pImmutableSamplers != binding->pImmutableSamplers);
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[0], reinterpret_cast<VkSampler>(0xdead));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[1], reinterpret_cast<VkSampler>(0xbeef));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->pBindings[1].pImmutableSamplers[1], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->pBindings[2].binding, 12);
CORRADE_COMPARE(info->pBindings[2].descriptorType, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
CORRADE_COMPARE(info->pBindings[2].descriptorCount, 1);
CORRADE_VERIFY(info->pBindings[2].pImmutableSamplers);
CORRADE_COMPARE(info->pBindings[2].pImmutableSamplers[0], reinterpret_cast<VkSampler>(0xcafe));
CORRADE_COMPARE(info->pBindings[2].pImmutableSamplers[0], reinterpret_cast<VkSampler>(reinterpret_cast<void*>(0xcafe)));
CORRADE_VERIFY(!info->pNext);
}

50
src/Magnum/Vk/Test/FramebufferTest.cpp
Unescape View File

@ -61,42 +61,46 @@ FramebufferTest::FramebufferTest() {
}
void FramebufferTest::createInfoConstruct() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(0xdeadbeef);
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe1), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe2), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe3), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)), {});
/** @todo use a real flag once it exists */
FramebufferCreateInfo info{renderPass, {a, b, c}, {256, 512}, FramebufferCreateInfo::Flag(0xbadda9)};
CORRADE_COMPARE(info->flags, 0xbadda9);
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(0xdeadbeef));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(info->attachmentCount, 3);
CORRADE_VERIFY(info->pAttachments);
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(0xcafe1));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(0xcafe2));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(0xcafe3));
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)));
CORRADE_COMPARE(info->width, 256);
CORRADE_COMPARE(info->height, 512);
CORRADE_COMPARE(info->layers, 1);
}
void FramebufferTest::createInfoConstructLayered() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(0xdeadbeef);
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe1), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe2), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe3), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto a = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)), {});
auto b = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)), {});
auto c = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)), {});
/** @todo use a real flag once it exists */
FramebufferCreateInfo info{renderPass, {a, b, c}, {256, 512, 5}, FramebufferCreateInfo::Flag(0xbadda9)};
CORRADE_COMPARE(info->flags, 0xbadda9);
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(0xdeadbeef));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(info->attachmentCount, 3);
CORRADE_VERIFY(info->pAttachments);
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(0xcafe1));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(0xcafe2));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(0xcafe3));
CORRADE_COMPARE(info->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe1)));
CORRADE_COMPARE(info->pAttachments[1], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe2)));
CORRADE_COMPARE(info->pAttachments[2], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe3)));
CORRADE_COMPARE(info->width, 256);
CORRADE_COMPARE(info->height, 512);
CORRADE_COMPARE(info->layers, 5);
@ -128,28 +132,30 @@ void FramebufferTest::createInfoConstructCopy() {
}
void FramebufferTest::createInfoConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
auto renderPass = reinterpret_cast<VkRenderPass>(0xdeadbeef);
auto view = ImageView::wrap(device, reinterpret_cast<VkImageView>(0xcafe), {});
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef));
auto view = ImageView::wrap(device, reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)), {});
FramebufferCreateInfo a{renderPass, {view}, {256, 512}};
FramebufferCreateInfo b = std::move(a);
CORRADE_COMPARE(a->attachmentCount, 0);
CORRADE_VERIFY(!a->pAttachments);
CORRADE_COMPARE(b->renderPass, reinterpret_cast<VkRenderPass>(0xdeadbeef));
CORRADE_COMPARE(b->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(b->attachmentCount, 1);
CORRADE_VERIFY(b->pAttachments);
CORRADE_COMPARE(b->pAttachments[0], reinterpret_cast<VkImageView>(0xcafe));
CORRADE_COMPARE(b->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)));
FramebufferCreateInfo c{VkFramebufferCreateInfo{}};
c = std::move(b);
CORRADE_COMPARE(b->attachmentCount, 0);
CORRADE_VERIFY(!b->pAttachments);
CORRADE_COMPARE(c->renderPass, reinterpret_cast<VkRenderPass>(0xdeadbeef));
CORRADE_COMPARE(c->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_COMPARE(c->attachmentCount, 1);
CORRADE_VERIFY(c->pAttachments);
CORRADE_COMPARE(c->pAttachments[0], reinterpret_cast<VkImageView>(0xcafe));
CORRADE_COMPARE(c->pAttachments[0], reinterpret_cast<VkImageView>(reinterpret_cast<void*>(0xcafe)));
CORRADE_VERIFY(std::is_nothrow_move_constructible<FramebufferCreateInfo>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<FramebufferCreateInfo>::value);

18
src/Magnum/Vk/Test/ImageTest.cpp
Unescape View File

@ -485,8 +485,10 @@ void ImageTest::imageCopyConvertDisallowed() {
}
void ImageTest::copyImageInfoConstruct() {
auto a = reinterpret_cast<VkImage>(0xdead);
auto b = reinterpret_cast<VkImage>(0xcafe);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
CopyImageInfo info{a, ImageLayout::Preinitialized, b, ImageLayout::General, {
{ImageAspect::Color, 3, 0, 0, {}, 0, 0, 0, {}, {}},
@ -720,8 +722,10 @@ void ImageTest::bufferImageCopyConvertDisallowed() {
}
void ImageTest::copyBufferToImageInfoConstruct() {
auto a = reinterpret_cast<VkBuffer>(0xdead);
auto b = reinterpret_cast<VkImage>(0xcafe);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
auto b = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
CopyBufferToImageInfo info{a, b, ImageLayout::TransferDestination, {
BufferImageCopy1D{5, ImageAspect::Color, 0, {}},
@ -773,8 +777,10 @@ void ImageTest::copyBufferToImageInfoConvertToVk() {
}
void ImageTest::copyImageToBufferInfoConstruct() {
auto a = reinterpret_cast<VkImage>(0xcafe);
auto b = reinterpret_cast<VkBuffer>(0xdead);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto a = reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xcafe));
auto b = reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead));
CopyImageToBufferInfo info{a, ImageLayout::TransferSource, b, {
BufferImageCopy1D{5, ImageAspect::Color, 0, {}},

4
src/Magnum/Vk/Test/ImageViewTest.cpp
Unescape View File

@ -107,7 +107,9 @@ ImageViewTest::ImageViewTest() {
&ImageViewTest::constructCopy});
}
const VkImage imageHandle{reinterpret_cast<VkImage>(0xdeadbeef)};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
const VkImage imageHandle{reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdeadbeef))};
template<class T> void ImageViewTest::createInfoConstruct() {
/** @todo use a real flag once it exists */

32
src/Magnum/Vk/Test/MeshTest.cpp
Unescape View File

@ -184,9 +184,11 @@ void MeshTest::addVertexBuffer() {
0, 0
}), TestSuite::Compare::Container);
mesh.addVertexBuffer(5, reinterpret_cast<VkBuffer>(0xdead), 15);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
mesh.addVertexBuffer(5, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 15);
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
VkBuffer{}, reinterpret_cast<VkBuffer>(0xdead)
VkBuffer{}, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
0, 15
@ -195,9 +197,10 @@ void MeshTest::addVertexBuffer() {
0, 3
}), TestSuite::Compare::Container);
mesh.addVertexBuffer(1, reinterpret_cast<VkBuffer>(0xbeef), 37);
mesh.addVertexBuffer(1, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)), 37);
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
reinterpret_cast<VkBuffer>(0xbeef), reinterpret_cast<VkBuffer>(0xdead)
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
37, 15
@ -213,16 +216,19 @@ void MeshTest::addVertexBufferOwned() {
.addInstancedBinding(5, 3)
};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(0xdead));
Buffer b = Buffer::wrap(device, reinterpret_cast<VkBuffer>(0xbeef));
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
Buffer b = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)));
mesh.addVertexBuffer(5, std::move(a), 15)
.addVertexBuffer(1, std::move(b), 37);
CORRADE_VERIFY(!a.handle());
CORRADE_VERIFY(!b.handle());
CORRADE_COMPARE_AS(mesh.vertexBuffers(), Containers::arrayView({
reinterpret_cast<VkBuffer>(0xbeef), reinterpret_cast<VkBuffer>(0xdead)
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xbeef)),
reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead))
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.vertexBufferOffsets(), Containers::arrayView<UnsignedLong>({
37, 15
@ -257,9 +263,11 @@ template<class T> void MeshTest::setIndexBuffer() {
Mesh mesh{MeshLayout{MeshPrimitive::Triangles}};
CORRADE_VERIFY(!mesh.isIndexed());
mesh.setIndexBuffer(reinterpret_cast<VkBuffer>(0xdead), 15, T::UnsignedByte);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
mesh.setIndexBuffer(reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 15, T::UnsignedByte);
CORRADE_VERIFY(mesh.isIndexed());
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(0xdead));
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(mesh.indexBufferOffset(), 15);
CORRADE_COMPARE(mesh.indexType(), MeshIndexType::UnsignedByte);
}
@ -267,14 +275,16 @@ template<class T> void MeshTest::setIndexBuffer() {
template<class T> void MeshTest::setIndexBufferOwned() {
setTestCaseTemplateName(IndexTypeTraits<T>::name());
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(0xdead));
Buffer a = Buffer::wrap(device, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
Mesh mesh{MeshLayout{MeshPrimitive::Triangles}};
mesh.setIndexBuffer(std::move(a), 15, T::UnsignedByte);
CORRADE_VERIFY(!a.handle());
CORRADE_VERIFY(mesh.isIndexed());
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(0xdead));
CORRADE_COMPARE(mesh.indexBuffer(), reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(mesh.indexBufferOffset(), 15);
CORRADE_COMPARE(mesh.indexType(), MeshIndexType::UnsignedByte);
}

16
src/Magnum/Vk/Test/PipelineLayoutTest.cpp
Unescape View File

@ -64,15 +64,17 @@ void PipelineLayoutTest::createInfoConstruct() {
}
void PipelineLayoutTest::createInfoConstructDescriptorSetLayouts() {
VkDescriptorSetLayout layouts[]{reinterpret_cast<VkDescriptorSetLayout>(0xdead), reinterpret_cast<VkDescriptorSetLayout>(0xbeef)};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
VkDescriptorSetLayout layouts[]{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef))};
PipelineLayoutCreateInfo info{layouts};
CORRADE_COMPARE(info->setLayoutCount, 2);
CORRADE_VERIFY(info->pSetLayouts);
/* The contents should be copied */
CORRADE_VERIFY(info->pSetLayouts != layouts);
CORRADE_COMPARE(info->pSetLayouts[0], reinterpret_cast<VkDescriptorSetLayout>(0xdead));
CORRADE_COMPARE(info->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(0xbeef));
CORRADE_COMPARE(info->pSetLayouts[0], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
}
void PipelineLayoutTest::createInfoConstructNoInit() {
@ -101,7 +103,9 @@ void PipelineLayoutTest::createInfoConstructCopy() {
}
void PipelineLayoutTest::createInfoConstructMove() {
PipelineLayoutCreateInfo a{reinterpret_cast<VkDescriptorSetLayout>(0xdead), reinterpret_cast<VkDescriptorSetLayout>(0xbeef)};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
PipelineLayoutCreateInfo a{reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef))};
CORRADE_COMPARE(a->setLayoutCount, 2);
CORRADE_VERIFY(a->pSetLayouts);
@ -110,7 +114,7 @@ void PipelineLayoutTest::createInfoConstructMove() {
CORRADE_VERIFY(!a->pSetLayouts);
CORRADE_COMPARE(b->setLayoutCount, 2);
CORRADE_VERIFY(b->pSetLayouts);
CORRADE_COMPARE(b->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(0xbeef));
CORRADE_COMPARE(b->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
PipelineLayoutCreateInfo c;
c = std::move(b);
@ -118,7 +122,7 @@ void PipelineLayoutTest::createInfoConstructMove() {
CORRADE_VERIFY(!b->pSetLayouts);
CORRADE_COMPARE(c->setLayoutCount, 2);
CORRADE_VERIFY(c->pSetLayouts);
CORRADE_COMPARE(c->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(0xbeef));
CORRADE_COMPARE(c->pSetLayouts[1], reinterpret_cast<VkDescriptorSetLayout>(reinterpret_cast<void*>(0xbeef)));
}
void PipelineLayoutTest::constructNoCreate() {

36
src/Magnum/Vk/Test/PipelineTest.cpp
Unescape View File

@ -189,7 +189,9 @@ void PipelineTest::rasterizationCreateInfoConstruct() {
MeshLayout meshLayout{MeshPrimitive::Triangles};
RasterizationPipelineCreateInfo info{shaderSet, meshLayout, reinterpret_cast<VkPipelineLayout>(0xdead), reinterpret_cast<VkRenderPass>(0xbeef), 15, 3, RasterizationPipelineCreateInfo::Flag::DisableOptimization|RasterizationPipelineCreateInfo::Flag::AllowDerivatives};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
RasterizationPipelineCreateInfo info{shaderSet, meshLayout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)), reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbeef)), 15, 3, RasterizationPipelineCreateInfo::Flag::DisableOptimization|RasterizationPipelineCreateInfo::Flag::AllowDerivatives};
CORRADE_COMPARE(info->flags, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
CORRADE_COMPARE(info->stageCount, 2);
CORRADE_COMPARE(info->pStages, shaderSet.stages());
@ -213,8 +215,8 @@ void PipelineTest::rasterizationCreateInfoConstruct() {
CORRADE_COMPARE(info->pColorBlendState->pAttachments[i].colorWriteMask, VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT);
}
CORRADE_VERIFY(!info->pDynamicState);
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(0xdead));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(0xbeef));
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(info->renderPass, reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->subpass, 15);
}
@ -540,14 +542,16 @@ void PipelineTest::computeCreateInfoConstruct() {
ShaderSet shaderSet;
Containers::StringView name = "dead"_s;
/* Yes, I know Fragment is wrong, it's just for testing */
shaderSet.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(0xbeef), name);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
shaderSet.addShader(ShaderStage::Fragment, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xbeef)), name);
ComputePipelineCreateInfo info{shaderSet, reinterpret_cast<VkPipelineLayout>(0xdead), ComputePipelineCreateInfo::Flag::DisableOptimization|ComputePipelineCreateInfo::Flag::AllowDerivatives};
ComputePipelineCreateInfo info{shaderSet, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)), ComputePipelineCreateInfo::Flag::DisableOptimization|ComputePipelineCreateInfo::Flag::AllowDerivatives};
CORRADE_COMPARE(info->flags, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT);
CORRADE_COMPARE(info->stage.stage, VK_SHADER_STAGE_FRAGMENT_BIT);
CORRADE_COMPARE(info->stage.module, reinterpret_cast<VkShaderModule>(0xbeef));
CORRADE_COMPARE(info->stage.module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xbeef)));
CORRADE_COMPARE(info->stage.pName, name.data());
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(0xdead));
CORRADE_COMPARE(info->layout, reinterpret_cast<VkPipelineLayout>(reinterpret_cast<void*>(0xdead)));
}
void PipelineTest::computeCreateInfoConstructOwnedEntrypoint() {
@ -637,10 +641,12 @@ void PipelineTest::memoryBarrierConstructFromVk() {
}
void PipelineTest::bufferMemoryBarrierConstruct() {
BufferMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, reinterpret_cast<VkBuffer>(0xdead), 3, 5};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
BufferMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)), 3, 5};
CORRADE_COMPARE(barrier->srcAccessMask, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_READ_BIT);
CORRADE_COMPARE(barrier->buffer, reinterpret_cast<VkBuffer>(0xdead));
CORRADE_COMPARE(barrier->buffer, reinterpret_cast<VkBuffer>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->offset, 3);
CORRADE_COMPARE(barrier->size, 5);
}
@ -666,12 +672,14 @@ void PipelineTest::bufferMemoryBarrierConstructFromVk() {
}
void PipelineTest::imageMemoryBarrierConstruct() {
ImageMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, ImageLayout::Preinitialized, ImageLayout::TransferSource, reinterpret_cast<VkImage>(0xdead), ImageAspect::Color|ImageAspect::Depth, 3, 5, 7, 9};
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
ImageMemoryBarrier barrier{Access::ColorAttachmentWrite|Access::DepthStencilAttachmentWrite, Access::TransferRead, ImageLayout::Preinitialized, ImageLayout::TransferSource, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)), ImageAspect::Color|ImageAspect::Depth, 3, 5, 7, 9};
CORRADE_COMPARE(barrier->srcAccessMask, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_READ_BIT);
CORRADE_COMPARE(barrier->oldLayout, VK_IMAGE_LAYOUT_PREINITIALIZED);
CORRADE_COMPARE(barrier->newLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(0xdead));
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->subresourceRange.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT);
CORRADE_COMPARE(barrier->subresourceRange.baseMipLevel, 7);
CORRADE_COMPARE(barrier->subresourceRange.levelCount, 9);
@ -680,8 +688,10 @@ void PipelineTest::imageMemoryBarrierConstruct() {
}
void PipelineTest::imageMemoryBarrierConstructImplicitAspect() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
Device device{NoCreate};
Image image = Image::wrap(device, reinterpret_cast<VkImage>(0xdead), PixelFormat::Depth24UnormStencil8UI);
Image image = Image::wrap(device, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)), PixelFormat::Depth24UnormStencil8UI);
ImageMemoryBarrier barrier{
Access::ColorAttachmentRead, Access::TransferWrite,
@ -691,7 +701,7 @@ void PipelineTest::imageMemoryBarrierConstructImplicitAspect() {
CORRADE_COMPARE(barrier->dstAccessMask, VK_ACCESS_TRANSFER_WRITE_BIT);
CORRADE_COMPARE(barrier->oldLayout, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
CORRADE_COMPARE(barrier->newLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(0xdead));
CORRADE_COMPARE(barrier->image, reinterpret_cast<VkImage>(reinterpret_cast<void*>(0xdead)));
CORRADE_COMPARE(barrier->subresourceRange.aspectMask, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT);
CORRADE_COMPARE(barrier->subresourceRange.baseMipLevel, 7);
CORRADE_COMPARE(barrier->subresourceRange.levelCount, 9);

18
src/Magnum/Vk/Test/QueueTest.cpp
Unescape View File

@ -128,15 +128,17 @@ void QueueTest::submitInfoConstructNoInit() {
void QueueTest::submitInfoConstructCommandBuffers() {
SubmitInfo info;
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
info.setCommandBuffers({
reinterpret_cast<VkCommandBuffer>(0xbadbeef),
reinterpret_cast<VkCommandBuffer>(0xcafecafe)
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xbadbeef)),
reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe))
});
CORRADE_COMPARE(info->commandBufferCount, 2);
CORRADE_VERIFY(info->pCommandBuffers);
CORRADE_COMPARE(info->pCommandBuffers[0], reinterpret_cast<VkCommandBuffer>(0xbadbeef));
CORRADE_COMPARE(info->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(0xcafecafe));
CORRADE_COMPARE(info->pCommandBuffers[0], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xbadbeef)));
CORRADE_COMPARE(info->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
}
void QueueTest::submitInfoConstructFromVk() {
@ -153,15 +155,17 @@ void QueueTest::submitInfoConstructCopy() {
}
void QueueTest::submitInfoConstructMove() {
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
SubmitInfo a;
a.setCommandBuffers({{}, reinterpret_cast<VkCommandBuffer>(0xcafecafe)});
a.setCommandBuffers({{}, reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe))});
SubmitInfo b = std::move(a);
CORRADE_COMPARE(a->commandBufferCount, 0);
CORRADE_VERIFY(!a->pCommandBuffers);
CORRADE_COMPARE(b->commandBufferCount, 2);
CORRADE_VERIFY(b->pCommandBuffers);
CORRADE_COMPARE(b->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(0xcafecafe));
CORRADE_COMPARE(b->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
SubmitInfo c{VkSubmitInfo{}};
c = std::move(b);
@ -169,7 +173,7 @@ void QueueTest::submitInfoConstructMove() {
CORRADE_VERIFY(!b->pCommandBuffers);
CORRADE_COMPARE(c->commandBufferCount, 2);
CORRADE_VERIFY(c->pCommandBuffers);
CORRADE_COMPARE(c->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(0xcafecafe));
CORRADE_COMPARE(c->pCommandBuffers[1], reinterpret_cast<VkCommandBuffer>(reinterpret_cast<void*>(0xcafecafe)));
}
}}}}

12
src/Magnum/Vk/Test/RenderPassTest.cpp
Unescape View File

@ -1130,8 +1130,10 @@ void RenderPassTest::constructCopy() {
}
void RenderPassTest::beginInfoConstruct() {
auto renderPass = reinterpret_cast<VkRenderPass>(0xbadbeef);
auto framebuffer = reinterpret_cast<VkFramebuffer>(0xdeadcafe);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbadbeef));
auto framebuffer = reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(0xdeadcafe));
RenderPassBeginInfo info{renderPass, framebuffer, Range2Di{{3, 7}, {15, 78}}};
CORRADE_COMPARE(info->renderPass, renderPass);
@ -1142,9 +1144,11 @@ void RenderPassTest::beginInfoConstruct() {
}
void RenderPassTest::beginInfoConstructImplicitSize() {
auto renderPass = reinterpret_cast<VkRenderPass>(0xbadbeef);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto renderPass = reinterpret_cast<VkRenderPass>(reinterpret_cast<void*>(0xbadbeef));
Device device{NoCreate};
auto framebuffer = Framebuffer::wrap(device, reinterpret_cast<VkFramebuffer>(0xdeadcafe), {256, 384, 16});
auto framebuffer = Framebuffer::wrap(device, reinterpret_cast<VkFramebuffer>(reinterpret_cast<void*>(0xdeadcafe)), {256, 384, 16});
RenderPassBeginInfo info{renderPass, framebuffer};
CORRADE_COMPARE(info->renderPass, renderPass);

17
src/Magnum/Vk/Test/ShaderSetTest.cpp
Unescape View File

@ -111,7 +111,10 @@ void ShaderSetTest::constructMove() {
{
ShaderSet a;
a.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(0xdeadbeef), "main!"_s.except(1), {
/* The double reinterpret_cast is needed because the handle is an
uint64_t instead of a pointer on 32-bit builds and only this works
on both */
a.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)), "main!"_s.except(1), {
{42, 1.15f}
});
CORRADE_COMPARE(a.stages().size(), 1);
@ -153,10 +156,12 @@ void ShaderSetTest::constructMove() {
void ShaderSetTest::addShader() {
ShaderSet set;
Containers::StringView entrypoint = "enterHere"_s;
set.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(0xdeadbeef), entrypoint);
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
set.addShader(ShaderStage::Geometry, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)), entrypoint);
CORRADE_COMPARE(set.stages().size(), 1);
CORRADE_COMPARE(set.stages()[0].stage, VK_SHADER_STAGE_GEOMETRY_BIT);
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(0xdeadbeef));
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
/* The name should not be copied if it's null-terminated and global */
CORRADE_COMPARE(set.stages()[0].pName, entrypoint.data());
CORRADE_VERIFY(!set.stages()[0].pSpecializationInfo);
@ -272,7 +277,9 @@ void ShaderSetTest::addShaderSpecializationsReallocation() {
void ShaderSetTest::addShaderOwnershipTransfer() {
Device device{NoCreate};
auto shader = Shader::wrap(device, reinterpret_cast<VkShaderModule>(0xdeadbeef));
/* The double reinterpret_cast is needed because the handle is an uint64_t
instead of a pointer on 32-bit builds and only this works on both */
auto shader = Shader::wrap(device, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
ShaderSet set;
set.addShader(ShaderStage::RayAnyHit, std::move(shader), "main"_s, {
@ -281,7 +288,7 @@ void ShaderSetTest::addShaderOwnershipTransfer() {
CORRADE_COMPARE(set.stages()[0].stage, VK_SHADER_STAGE_ANY_HIT_BIT_KHR);
CORRADE_COMPARE(set.stages()[0].pName, "main"_s);
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(0xdeadbeef));
CORRADE_COMPARE(set.stages()[0].module, reinterpret_cast<VkShaderModule>(reinterpret_cast<void*>(0xdeadbeef)));
CORRADE_VERIFY(set.stages()[0].pSpecializationInfo);
CORRADE_COMPARE(set.stages()[0].pSpecializationInfo->mapEntryCount, 1);
CORRADE_VERIFY(set.stages()[0].pSpecializationInfo->pMapEntries);

Write Preview
Loading…
Cancel
Save