Skip to content

Commit

Permalink
tests: Temporarily remove shader test
Browse files Browse the repository at this point in the history
  • Loading branch information
@ziga-lunarg @jeremyg-lunarg
ziga-lunarg authored and jeremyg-lunarg committed Jun 23, 2023
1 parent 5338933 commit 9b07a9a
Showing 1 changed file with 0 additions and 181 deletions.
181 changes: 0 additions & 181 deletions tests/shader_object_tests.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -159,184 +159,3 @@ void ShaderObjectTest::BindDefaultDynamicStates(VkBuffer buffer) {
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
vkCmdSetColorWriteMaskEXT(cmdBuffer, 0u, 1u, &colorWriteMask);
}

TEST_F(ShaderObjectTest, VertFragShader) {
TEST_DESCRIPTION("Test drawing with a vertex and fragment shader");
SetTargetApiVersion(VK_API_VERSION_1_1);
if (!CheckShaderObjectSupportAndInitState()) {
GTEST_SKIP() << kSkipPrefix << " shader object not supported, skipping test";
}
if (DeviceValidationVersion() < VK_API_VERSION_1_1) {
GTEST_SKIP() << "At least Vulkan version 1.1 is required";
}

m_errorMonitor->ExpectSuccess();

static const char vertSource[] = R"glsl(
#version 460
void main() {
vec2 pos = vec2(float(gl_VertexIndex & 1), float((gl_VertexIndex >> 1) & 1));
gl_Position = vec4(pos - 0.5f, 0.0f, 1.0f);;
}
)glsl";

static const char fragSource[] = R"glsl(
#version 460
layout(location = 0) out vec4 uFragColor;
void main(){
uFragColor = vec4(0.2f, 0.4f, 0.6f, 0.8f);
}
)glsl";

VkShaderStageFlagBits shaderStages[] = {VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT};

std::vector<unsigned int> spv[2];
GLSLtoSPV(&m_device->props.limits, VK_SHADER_STAGE_VERTEX_BIT, vertSource, spv[0], false, 0);
GLSLtoSPV(&m_device->props.limits, VK_SHADER_STAGE_FRAGMENT_BIT, fragSource, spv[1], false, 0);

VkShaderStageFlagBits unusedShaderStages[] = {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT};
VkShaderEXT shaders[2];
VkShaderCreateInfoEXT createInfos[2];
for (uint32_t i = 0; i < 2; ++i) {
createInfos[i] = LvlInitStruct<VkShaderCreateInfoEXT>();
createInfos[i].stage = shaderStages[i];
createInfos[i].codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT;
createInfos[i].codeSize = spv[i].size() * sizeof(unsigned int);
createInfos[i].pCode = spv[i].data();
createInfos[i].pName = "main";
}

vk::CreateShadersEXT(m_device->handle(), 2u, createInfos, nullptr, shaders);

VkBufferObj buffer;
buffer.init(*m_device, sizeof(float) * 4u, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
VK_BUFFER_USAGE_TRANSFER_DST_BIT);

VkBufferObj vertexBuffer;
vertexBuffer.init(*m_device, sizeof(float), VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);

VkImageCreateInfo imageInfo = LvlInitStruct<VkImageCreateInfo>();
imageInfo.flags = 0;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.format = VK_FORMAT_R32G32B32A32_SFLOAT;
imageInfo.extent = {static_cast<uint32_t>(m_width), static_cast<uint32_t>(m_height), 1};
imageInfo.mipLevels = 1u;
imageInfo.arrayLayers = 1u;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageInfo.queueFamilyIndexCount = 0u;
imageInfo.pQueueFamilyIndices = nullptr;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImageObj image(m_device);
image.init(&imageInfo);
VkImageView view = image.targetView(imageInfo.format);

VkRenderingAttachmentInfo color_attachment = LvlInitStruct<VkRenderingAttachmentInfo>();
color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
color_attachment.imageView = view;

VkRenderingInfo begin_rendering_info = LvlInitStruct<VkRenderingInfo>();
begin_rendering_info.flags = 0u;
begin_rendering_info.renderArea.offset.x = 0;
begin_rendering_info.renderArea.offset.y = 0;
begin_rendering_info.renderArea.extent.width = static_cast<uint32_t>(m_width);
begin_rendering_info.renderArea.extent.height = static_cast<uint32_t>(m_height);
begin_rendering_info.layerCount = 1u;
begin_rendering_info.viewMask = 0x0;
begin_rendering_info.colorAttachmentCount = 1u;
begin_rendering_info.pColorAttachments = &color_attachment;

PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR =
(PFN_vkCmdBeginRenderingKHR)vk::GetDeviceProcAddr(device(), "vkCmdBeginRenderingKHR");
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR =
(PFN_vkCmdEndRenderingKHR)vk::GetDeviceProcAddr(device(), "vkCmdEndRenderingKHR");

m_commandBuffer->begin();

{
VkImageMemoryBarrier imageMemoryBarrier = LvlInitStruct<VkImageMemoryBarrier>();
imageMemoryBarrier.srcAccessMask = VK_ACCESS_NONE;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.image = image.handle();
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0u;
imageMemoryBarrier.subresourceRange.levelCount = 1u;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0u;
imageMemoryBarrier.subresourceRange.layerCount = 1u;
vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u,
&imageMemoryBarrier);
}
vkCmdBeginRenderingKHR(m_commandBuffer->handle(), &begin_rendering_info);
vk::CmdBindShadersEXT(m_commandBuffer->handle(), 2u, shaderStages, shaders);
for (const auto& unusedShader : unusedShaderStages) {
VkShaderEXT null_shader = VK_NULL_HANDLE;
vk::CmdBindShadersEXT(m_commandBuffer->handle(), 1u, &unusedShader, &null_shader);
}
BindDefaultDynamicStates(vertexBuffer.handle());
vk::CmdDraw(m_commandBuffer->handle(), 4, 1, 0, 0);
vkCmdEndRenderingKHR(m_commandBuffer->handle());

{
VkImageMemoryBarrier imageMemoryBarrier = LvlInitStruct<VkImageMemoryBarrier>();
imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
imageMemoryBarrier.image = image.handle();
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0u;
imageMemoryBarrier.subresourceRange.levelCount = 1u;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0u;
imageMemoryBarrier.subresourceRange.layerCount = 1u;
vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u, &imageMemoryBarrier);
}

VkBufferImageCopy copyRegion = {};
copyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copyRegion.imageSubresource.mipLevel = 0u;
copyRegion.imageSubresource.baseArrayLayer = 0u;
copyRegion.imageSubresource.layerCount = 1u;
copyRegion.imageOffset.x = static_cast<int32_t>(m_width / 2) + 1;
copyRegion.imageOffset.y = static_cast<int32_t>(m_height / 2) + 1;
copyRegion.imageExtent.width = 1u;
copyRegion.imageExtent.height = 1u;
copyRegion.imageExtent.depth = 1u;

vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer.handle(), 1u, &copyRegion);

m_commandBuffer->end();

VkCommandBuffer commandBufferHandle = m_commandBuffer->handle();
VkSubmitInfo submitInfo = LvlInitStruct<VkSubmitInfo>();
submitInfo.commandBufferCount = 1u;
submitInfo.pCommandBuffers = &commandBufferHandle;
vk::QueueSubmit(m_device->m_queue, 1, &submitInfo, VK_NULL_HANDLE);
vk::QueueWaitIdle(m_device->m_queue);

float* data;
vk::MapMemory(m_device->handle(), buffer.memory().handle(), 0u, sizeof(float) * 4u, 0u, (void**)&data);
for (uint32_t i = 0; i < 4; ++i) {
if (data[i] != 0.2f + i * 0.2f) {
m_errorMonitor->SetError("Wrong pixel value");
}
}

vk::UnmapMemory(m_device->handle(), buffer.memory().handle());

vk::DestroyShaderEXT(m_device->handle(), shaders[0], nullptr);
vk::DestroyShaderEXT(m_device->handle(), shaders[1], nullptr);

m_errorMonitor->VerifyNotFound();
}

0 comments on commit 9b07a9a

Please sign in to comment.