| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2019 The Khronos Group Inc. |
| * Copyright (c) 2019 Valve Corporation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Max Varying Tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vktPipelineMaxVaryingsTests.hpp" |
| #include "vktTestGroupUtil.hpp" |
| #include "vktTestCaseUtil.hpp" |
| #include "vkTypeUtil.hpp" |
| #include "vkImageUtil.hpp" |
| #include "vkObjUtil.hpp" |
| #include "vktPipelineMakeUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| #include "vkCmdUtil.hpp" |
| #include "vkRefUtil.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkBarrierUtil.hpp" |
| #include "vktPipelineSpecConstantUtil.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuTextureUtil.hpp" |
| |
| #include <string.h> |
| |
| namespace vkt |
| { |
| namespace pipeline |
| { |
| namespace |
| { |
| using namespace vk; |
| using de::UniquePtr; |
| using de::MovePtr; |
| |
| struct MaxVaryingsParam |
| { |
| VkShaderStageFlags outputStage; |
| VkShaderStageFlags inputStage; |
| VkShaderStageFlags stageToStressIO; |
| MaxVaryingsParam(VkShaderStageFlags out, VkShaderStageFlags in, VkShaderStageFlags stageToTest) |
| : outputStage(out), inputStage(in), stageToStressIO(stageToTest) {} |
| }; |
| |
| struct SelectedShaders |
| { |
| VkShaderStageFlagBits stage; |
| std::string shaderName; |
| SelectedShaders(VkShaderStageFlagBits shaderStage, std::string name) |
| : stage(shaderStage), shaderName(name) {} |
| }; |
| |
| // Helper functions |
| std::string getShaderStageName(VkShaderStageFlags stage) |
| { |
| switch (stage) |
| { |
| default: |
| DE_FATAL("Unhandled stage!"); |
| return ""; |
| case VK_SHADER_STAGE_COMPUTE_BIT: |
| return "compute"; |
| case VK_SHADER_STAGE_FRAGMENT_BIT: |
| return "fragment"; |
| case VK_SHADER_STAGE_VERTEX_BIT: |
| return "vertex"; |
| case VK_SHADER_STAGE_GEOMETRY_BIT: |
| return "geometry"; |
| case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: |
| return "tess_control"; |
| case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: |
| return "tess_eval"; |
| } |
| } |
| |
| const std::string generateTestName (struct MaxVaryingsParam param) |
| { |
| std::ostringstream result; |
| |
| result << "test_" << getShaderStageName(param.stageToStressIO) << "_io_between_"; |
| result << getShaderStageName(param.outputStage) << "_"; |
| result << getShaderStageName(param.inputStage); |
| return result.str(); |
| } |
| |
| const std::string generateTestDescription () |
| { |
| std::string result("Tests to check max varyings per stage"); |
| return result; |
| } |
| |
| void initPrograms (SourceCollections& programCollection, MaxVaryingsParam param) |
| { |
| const vk::ShaderBuildOptions buildOptions (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_3, 0u); |
| |
| // Vertex shader. SPIR-V generated from: |
| // #version 450 |
| // layout(location = 0) in highp vec4 pos; |
| // layout(constant_id = 0) const int arraySize = 1; |
| // layout(location = 0) out ivec4 outputData[arraySize]; |
| // out gl_PerVertex { |
| // vec4 gl_Position; |
| // }; |
| // |
| // void main() |
| // { |
| // gl_Position = pos; |
| // int i; |
| // for (i = 0; i < arraySize; i++) |
| // { |
| // outputData[i] = ivec4(i); |
| // } |
| // } |
| std::ostringstream vertex_out; |
| vertex_out << "OpCapability Shader\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint Vertex %4 \"main\" %10 %14 %32\n" |
| << "OpMemberDecorate %8 0 BuiltIn Position\n" |
| << "OpDecorate %8 Block\n" |
| << "OpDecorate %14 Location 0\n" |
| << "OpDecorate %26 SpecId 0\n" |
| << "OpDecorate %32 Location 0\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeFloat 32\n" |
| << "%7 = OpTypeVector %6 4\n" |
| << "%8 = OpTypeStruct %7\n" |
| << "%9 = OpTypePointer Output %8\n" |
| << "%10 = OpVariable %9 Output\n" |
| << "%11 = OpTypeInt 32 1\n" |
| << "%12 = OpConstant %11 0\n" |
| << "%13 = OpTypePointer Input %7\n" |
| << "%14 = OpVariable %13 Input\n" |
| << "%16 = OpTypePointer Output %7\n" |
| << "%18 = OpTypePointer Function %11\n" |
| << "%26 = OpSpecConstant %11 1\n" |
| << "%27 = OpTypeBool\n" |
| << "%29 = OpTypeVector %11 4\n" |
| << "%30 = OpTypeArray %29 %26\n" |
| << "%31 = OpTypePointer Output %30\n" |
| << "%32 = OpVariable %31 Output\n" |
| << "%36 = OpTypePointer Output %29\n" |
| << "%39 = OpConstant %11 1\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%19 = OpVariable %18 Function\n" |
| << "%15 = OpLoad %7 %14\n" |
| << "%17 = OpAccessChain %16 %10 %12\n" |
| << "OpStore %17 %15\n" |
| << "OpStore %19 %12\n" |
| << "OpBranch %20\n" |
| << "%20 = OpLabel\n" |
| << "OpLoopMerge %22 %23 None\n" |
| << "OpBranch %24\n" |
| << "%24 = OpLabel\n" |
| << "%25 = OpLoad %11 %19\n" |
| << "%28 = OpSLessThan %27 %25 %26\n" |
| << "OpBranchConditional %28 %21 %22\n" |
| << "%21 = OpLabel\n" |
| << "%33 = OpLoad %11 %19\n" |
| << "%34 = OpLoad %11 %19\n" |
| << "%35 = OpCompositeConstruct %29 %34 %34 %34 %34\n" |
| << "%37 = OpAccessChain %36 %32 %33\n" |
| << "OpStore %37 %35\n" |
| << "OpBranch %23\n" |
| << "%23 = OpLabel\n" |
| << "%38 = OpLoad %11 %19\n" |
| << "%40 = OpIAdd %11 %38 %39\n" |
| << "OpStore %19 %40\n" |
| << "OpBranch %20\n" |
| << "%22 = OpLabel\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| // Vertex shader passthrough. SPIR-V generated from: |
| // #version 450 |
| // layout(location = 0) in highp vec4 pos; |
| // out gl_PerVertex { |
| // vec4 gl_Position; |
| // }; |
| // void main() |
| // { |
| // gl_Position = pos; |
| // } |
| std::ostringstream vertex_passthrough; |
| vertex_passthrough << "OpCapability Shader\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint Vertex %4 \"main\" %10 %14\n" |
| << "OpMemberDecorate %8 0 BuiltIn Position\n" |
| << "OpDecorate %8 Block\n" |
| << "OpDecorate %14 Location 0\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeFloat 32\n" |
| << "%7 = OpTypeVector %6 4\n" |
| << "%8 = OpTypeStruct %7\n" |
| << "%9 = OpTypePointer Output %8\n" |
| << "%10 = OpVariable %9 Output\n" |
| << "%11 = OpTypeInt 32 1\n" |
| << "%12 = OpConstant %11 0\n" |
| << "%13 = OpTypePointer Input %7\n" |
| << "%14 = OpVariable %13 Input\n" |
| << "%16 = OpTypePointer Output %7\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%15 = OpLoad %7 %14\n" |
| << "%17 = OpAccessChain %16 %10 %12\n" |
| << "OpStore %17 %15\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| // Tesselation Control shader. SPIR-V generated from: |
| // #version 450 |
| // layout(vertices = 3) out; |
| // in gl_PerVertex |
| // { |
| // vec4 gl_Position; |
| // } gl_in[]; |
| // out gl_PerVertex |
| // { |
| // vec4 gl_Position; |
| // } gl_out[]; |
| // void main(void) |
| // { |
| // if (gl_InvocationID == 0) { |
| // gl_TessLevelInner[0] = 1.0; |
| // gl_TessLevelInner[1] = 1.0; |
| // gl_TessLevelOuter[0] = 1.0; |
| // gl_TessLevelOuter[1] = 1.0; |
| // gl_TessLevelOuter[2] = 1.0; |
| // gl_TessLevelOuter[3] = 1.0; |
| // } |
| // gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; |
| // } |
| std::ostringstream tcs_passthrough; |
| tcs_passthrough << "OpCapability Tessellation\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint TessellationControl %4 \"main\" %8 %20 %29 %41 %47\n" |
| << "OpExecutionMode %4 OutputVertices 3\n" |
| << "OpDecorate %8 BuiltIn InvocationId\n" |
| << "OpDecorate %20 Patch\n" |
| << "OpDecorate %20 BuiltIn TessLevelInner\n" |
| << "OpDecorate %29 Patch\n" |
| << "OpDecorate %29 BuiltIn TessLevelOuter\n" |
| << "OpMemberDecorate %37 0 BuiltIn Position\n" |
| << "OpDecorate %37 Block\n" |
| << "OpMemberDecorate %43 0 BuiltIn Position\n" |
| << "OpDecorate %43 Block\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeInt 32 1\n" |
| << "%7 = OpTypePointer Input %6\n" |
| << "%8 = OpVariable %7 Input\n" |
| << "%10 = OpConstant %6 0\n" |
| << "%11 = OpTypeBool\n" |
| << "%15 = OpTypeFloat 32\n" |
| << "%16 = OpTypeInt 32 0\n" |
| << "%17 = OpConstant %16 2\n" |
| << "%18 = OpTypeArray %15 %17\n" |
| << "%19 = OpTypePointer Output %18\n" |
| << "%20 = OpVariable %19 Output\n" |
| << "%21 = OpConstant %15 1\n" |
| << "%22 = OpTypePointer Output %15\n" |
| << "%24 = OpConstant %6 1\n" |
| << "%26 = OpConstant %16 4\n" |
| << "%27 = OpTypeArray %15 %26\n" |
| << "%28 = OpTypePointer Output %27\n" |
| << "%29 = OpVariable %28 Output\n" |
| << "%32 = OpConstant %6 2\n" |
| << "%34 = OpConstant %6 3\n" |
| << "%36 = OpTypeVector %15 4\n" |
| << "%37 = OpTypeStruct %36\n" |
| << "%38 = OpConstant %16 3\n" |
| << "%39 = OpTypeArray %37 %38\n" |
| << "%40 = OpTypePointer Output %39\n" |
| << "%41 = OpVariable %40 Output\n" |
| << "%43 = OpTypeStruct %36\n" |
| << "%44 = OpConstant %16 32\n" |
| << "%45 = OpTypeArray %43 %44\n" |
| << "%46 = OpTypePointer Input %45\n" |
| << "%47 = OpVariable %46 Input\n" |
| << "%49 = OpTypePointer Input %36\n" |
| << "%52 = OpTypePointer Output %36\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%9 = OpLoad %6 %8\n" |
| << "%12 = OpIEqual %11 %9 %10\n" |
| << "OpSelectionMerge %14 None\n" |
| << "OpBranchConditional %12 %13 %14\n" |
| << "%13 = OpLabel\n" |
| << "%23 = OpAccessChain %22 %20 %10\n" |
| << "OpStore %23 %21\n" |
| << "%25 = OpAccessChain %22 %20 %24\n" |
| << "OpStore %25 %21\n" |
| << "%30 = OpAccessChain %22 %29 %10\n" |
| << "OpStore %30 %21\n" |
| << "%31 = OpAccessChain %22 %29 %24\n" |
| << "OpStore %31 %21\n" |
| << "%33 = OpAccessChain %22 %29 %32\n" |
| << "OpStore %33 %21\n" |
| << "%35 = OpAccessChain %22 %29 %34\n" |
| << "OpStore %35 %21\n" |
| << "OpBranch %14\n" |
| << "%14 = OpLabel\n" |
| << "%42 = OpLoad %6 %8\n" |
| << "%48 = OpLoad %6 %8\n" |
| << "%50 = OpAccessChain %49 %47 %48 %10\n" |
| << "%51 = OpLoad %36 %50\n" |
| << "%53 = OpAccessChain %52 %41 %42 %10\n" |
| << "OpStore %53 %51\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| // Tessellation Evaluation shader. SPIR-V generated from: |
| // #version 450 |
| // layout(triangles, equal_spacing, cw) in; |
| // layout(constant_id = 0) const int arraySize = 1; |
| // layout(location = 0) out ivec4 outputData[arraySize]; |
| // in gl_PerVertex { |
| // vec4 gl_Position; |
| // } gl_in[]; |
| // out gl_PerVertex { |
| // vec4 gl_Position; |
| // }; |
| // void main(void) |
| // { |
| // gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position + |
| // gl_TessCoord.y * gl_in[1].gl_Position + |
| // gl_TessCoord.z * gl_in[2].gl_Position); |
| // int j; |
| // for (j = 0; j < arraySize; j++) |
| // { |
| // outputData[j] = ivec4(j); |
| // } |
| // } |
| std::ostringstream tes_out; |
| tes_out << "OpCapability Tessellation\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint TessellationEvaluation %4 \"main\" %10 %15 %25 %62\n" |
| << "OpExecutionMode %4 Triangles\n" |
| << "OpExecutionMode %4 SpacingEqual\n" |
| << "OpExecutionMode %4 VertexOrderCw\n" |
| << "OpMemberDecorate %8 0 BuiltIn Position\n" |
| << "OpDecorate %8 Block\n" |
| << "OpDecorate %15 BuiltIn TessCoord\n" |
| << "OpMemberDecorate %21 0 BuiltIn Position\n" |
| << "OpDecorate %21 Block\n" |
| << "OpDecorate %56 SpecId 0\n" |
| << "OpDecorate %62 Location 0\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeFloat 32\n" |
| << "%7 = OpTypeVector %6 4\n" |
| << "%8 = OpTypeStruct %7\n" |
| << "%9 = OpTypePointer Output %8\n" |
| << "%10 = OpVariable %9 Output\n" |
| << "%11 = OpTypeInt 32 1\n" |
| << "%12 = OpConstant %11 0\n" |
| << "%13 = OpTypeVector %6 3\n" |
| << "%14 = OpTypePointer Input %13\n" |
| << "%15 = OpVariable %14 Input\n" |
| << "%16 = OpTypeInt 32 0\n" |
| << "%17 = OpConstant %16 0\n" |
| << "%18 = OpTypePointer Input %6\n" |
| << "%21 = OpTypeStruct %7\n" |
| << "%22 = OpConstant %16 32\n" |
| << "%23 = OpTypeArray %21 %22\n" |
| << "%24 = OpTypePointer Input %23\n" |
| << "%25 = OpVariable %24 Input\n" |
| << "%26 = OpTypePointer Input %7\n" |
| << "%30 = OpConstant %16 1\n" |
| << "%33 = OpConstant %11 1\n" |
| << "%38 = OpConstant %16 2\n" |
| << "%41 = OpConstant %11 2\n" |
| << "%46 = OpTypePointer Output %7\n" |
| << "%48 = OpTypePointer Function %11\n" |
| << "%56 = OpSpecConstant %11 1\n" |
| << "%57 = OpTypeBool\n" |
| << "%59 = OpTypeVector %11 4\n" |
| << "%60 = OpTypeArray %59 %56\n" |
| << "%61 = OpTypePointer Output %60\n" |
| << "%62 = OpVariable %61 Output\n" |
| << "%66 = OpTypePointer Output %59\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%49 = OpVariable %48 Function\n" |
| << "%19 = OpAccessChain %18 %15 %17\n" |
| << "%20 = OpLoad %6 %19\n" |
| << "%27 = OpAccessChain %26 %25 %12 %12\n" |
| << "%28 = OpLoad %7 %27\n" |
| << "%29 = OpVectorTimesScalar %7 %28 %20\n" |
| << "%31 = OpAccessChain %18 %15 %30\n" |
| << "%32 = OpLoad %6 %31\n" |
| << "%34 = OpAccessChain %26 %25 %33 %12\n" |
| << "%35 = OpLoad %7 %34\n" |
| << "%36 = OpVectorTimesScalar %7 %35 %32\n" |
| << "%37 = OpFAdd %7 %29 %36\n" |
| << "%39 = OpAccessChain %18 %15 %38\n" |
| << "%40 = OpLoad %6 %39\n" |
| << "%42 = OpAccessChain %26 %25 %41 %12\n" |
| << "%43 = OpLoad %7 %42\n" |
| << "%44 = OpVectorTimesScalar %7 %43 %40\n" |
| << "%45 = OpFAdd %7 %37 %44\n" |
| << "%47 = OpAccessChain %46 %10 %12\n" |
| << "OpStore %47 %45\n" |
| << "OpStore %49 %12\n" |
| << "OpBranch %50\n" |
| << "%50 = OpLabel\n" |
| << "OpLoopMerge %52 %53 None\n" |
| << "OpBranch %54\n" |
| << "%54 = OpLabel\n" |
| << "%55 = OpLoad %11 %49\n" |
| << "%58 = OpSLessThan %57 %55 %56\n" |
| << "OpBranchConditional %58 %51 %52\n" |
| << "%51 = OpLabel\n" |
| << "%63 = OpLoad %11 %49\n" |
| << "%64 = OpLoad %11 %49\n" |
| << "%65 = OpCompositeConstruct %59 %64 %64 %64 %64\n" |
| << "%67 = OpAccessChain %66 %62 %63\n" |
| << "OpStore %67 %65\n" |
| << "OpBranch %53\n" |
| << "%53 = OpLabel\n" |
| << "%68 = OpLoad %11 %49\n" |
| << "%69 = OpIAdd %11 %68 %33\n" |
| << "OpStore %49 %69\n" |
| << "OpBranch %50\n" |
| << "%52 = OpLabel\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| // Geometry shader. SPIR-V generated from: |
| // #version 450 |
| // layout (triangles) in; |
| // layout (triangle_strip, max_vertices = 3) out; |
| // layout(constant_id = 0) const int arraySize = 1; |
| // layout(location = 0) out ivec4 outputData[arraySize]; |
| // in gl_PerVertex { |
| // vec4 gl_Position; |
| // } gl_in[]; |
| // void main() |
| // { |
| // int i; |
| // int j; |
| // for(i = 0; i < gl_in.length(); i++) |
| // { |
| // gl_Position = gl_in[i].gl_Position; |
| // for (j = 0; j < arraySize; j++) |
| // { |
| // outputData[j] = ivec4(j); |
| // } |
| // EmitVertex(); |
| // } |
| // EndPrimitive(); |
| // } |
| std::ostringstream geom_out; |
| geom_out << "OpCapability Geometry\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint Geometry %4 \"main\" %26 %31 %50\n" |
| << "OpExecutionMode %4 Triangles\n" |
| << "OpExecutionMode %4 Invocations 1\n" |
| << "OpExecutionMode %4 OutputTriangleStrip\n" |
| << "OpExecutionMode %4 OutputVertices 3\n" |
| << "OpMemberDecorate %24 0 BuiltIn Position\n" |
| << "OpDecorate %24 Block\n" |
| << "OpMemberDecorate %27 0 BuiltIn Position\n" |
| << "OpDecorate %27 Block\n" |
| << "OpDecorate %45 SpecId 0\n" |
| << "OpDecorate %50 Location 0\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeInt 32 1\n" |
| << "%7 = OpTypePointer Function %6\n" |
| << "%9 = OpConstant %6 0\n" |
| << "%16 = OpConstant %6 3\n" |
| << "%17 = OpTypeBool\n" |
| << "%19 = OpTypeFloat 32\n" |
| << "%20 = OpTypeVector %19 4\n" |
| << "%21 = OpTypeInt 32 0\n" |
| << "%22 = OpConstant %21 1\n" |
| << "%23 = OpTypeArray %19 %22\n" |
| << "%24 = OpTypeStruct %20\n" |
| << "%25 = OpTypePointer Output %24\n" |
| << "%26 = OpVariable %25 Output\n" |
| << "%27 = OpTypeStruct %20\n" |
| << "%28 = OpConstant %21 3\n" |
| << "%29 = OpTypeArray %27 %28\n" |
| << "%30 = OpTypePointer Input %29\n" |
| << "%31 = OpVariable %30 Input\n" |
| << "%33 = OpTypePointer Input %20\n" |
| << "%36 = OpTypePointer Output %20\n" |
| << "%45 = OpSpecConstant %6 1\n" |
| << "%47 = OpTypeVector %6 4\n" |
| << "%48 = OpTypeArray %47 %45\n" |
| << "%49 = OpTypePointer Output %48\n" |
| << "%50 = OpVariable %49 Output\n" |
| << "%54 = OpTypePointer Output %47\n" |
| << "%57 = OpConstant %6 1\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%8 = OpVariable %7 Function\n" |
| << "%38 = OpVariable %7 Function\n" |
| << "OpStore %8 %9\n" |
| << "OpBranch %10\n" |
| << "%10 = OpLabel\n" |
| << "OpLoopMerge %12 %13 None\n" |
| << "OpBranch %14\n" |
| << "%14 = OpLabel\n" |
| << "%15 = OpLoad %6 %8\n" |
| << "%18 = OpSLessThan %17 %15 %16\n" |
| << "OpBranchConditional %18 %11 %12\n" |
| << "%11 = OpLabel\n" |
| << "%32 = OpLoad %6 %8\n" |
| << "%34 = OpAccessChain %33 %31 %32 %9\n" |
| << "%35 = OpLoad %20 %34\n" |
| << "%37 = OpAccessChain %36 %26 %9\n" |
| << "OpStore %37 %35\n" |
| << "OpStore %38 %9\n" |
| << "OpBranch %39\n" |
| << "%39 = OpLabel\n" |
| << "OpLoopMerge %41 %42 None\n" |
| << "OpBranch %43\n" |
| << "%43 = OpLabel\n" |
| << "%44 = OpLoad %6 %38\n" |
| << "%46 = OpSLessThan %17 %44 %45\n" |
| << "OpBranchConditional %46 %40 %41\n" |
| << "%40 = OpLabel\n" |
| << "%51 = OpLoad %6 %38\n" |
| << "%52 = OpLoad %6 %38\n" |
| << "%53 = OpCompositeConstruct %47 %52 %52 %52 %52\n" |
| << "%55 = OpAccessChain %54 %50 %51\n" |
| << "OpStore %55 %53\n" |
| << "OpBranch %42\n" |
| << "%42 = OpLabel\n" |
| << "%56 = OpLoad %6 %38\n" |
| << "%58 = OpIAdd %6 %56 %57\n" |
| << "OpStore %38 %58\n" |
| << "OpBranch %39\n" |
| << "%41 = OpLabel\n" |
| << "OpEmitVertex\n" |
| << "OpBranch %13\n" |
| << "%13 = OpLabel\n" |
| << "%59 = OpLoad %6 %8\n" |
| << "%60 = OpIAdd %6 %59 %57\n" |
| << "OpStore %8 %60\n" |
| << "OpBranch %10\n" |
| << "%12 = OpLabel\n" |
| << "OpEndPrimitive\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| // Fragment shader. SPIR-V code generated from: |
| // |
| // #version 450 |
| // layout(constant_id = 0) const int arraySize = 1; |
| // layout(location = 0) flat in ivec4 inputData[arraySize]; |
| // layout(location = 0) out vec4 color; |
| // void main() |
| // { |
| // color = vec4(1.0, 0.0, 0.0, 1.0); |
| // int i; |
| // bool result = true; |
| // for (i = 0; i < arraySize; i++) |
| // { |
| // if (result && inputData[i] != ivec4(i)) |
| // result = false; |
| // } |
| // if (result) |
| // color = vec4(0.0, 1.0, 0.0, 1.0); |
| // } |
| std::ostringstream fragment_in; |
| fragment_in << "OpCapability Shader\n" |
| << "%1 = OpExtInstImport \"GLSL.std.450\"\n" |
| << "OpMemoryModel Logical GLSL450\n" |
| << "OpEntryPoint Fragment %4 \"main\" %9 %35\n" |
| << "OpExecutionMode %4 OriginUpperLeft\n" |
| << "OpDecorate %9 Location 0\n" |
| << "OpDecorate %27 SpecId 0\n" |
| << "OpDecorate %35 Flat\n" |
| << "OpDecorate %35 Location 0\n" |
| << "%2 = OpTypeVoid\n" |
| << "%3 = OpTypeFunction %2\n" |
| << "%6 = OpTypeFloat 32\n" |
| << "%7 = OpTypeVector %6 4\n" |
| << "%8 = OpTypePointer Output %7\n" |
| << "%9 = OpVariable %8 Output\n" |
| << "%10 = OpConstant %6 1\n" |
| << "%11 = OpConstant %6 0\n" |
| << "%12 = OpConstantComposite %7 %10 %11 %11 %10\n" |
| << "%13 = OpTypeBool\n" |
| << "%14 = OpTypePointer Function %13\n" |
| << "%16 = OpConstantTrue %13\n" |
| << "%17 = OpTypeInt 32 1\n" |
| << "%18 = OpTypePointer Function %17\n" |
| << "%20 = OpConstant %17 0\n" |
| << "%27 = OpSpecConstant %17 1\n" |
| << "%32 = OpTypeVector %17 4\n" |
| << "%33 = OpTypeArray %32 %27\n" |
| << "%34 = OpTypePointer Input %33\n" |
| << "%35 = OpVariable %34 Input\n" |
| << "%37 = OpTypePointer Input %32\n" |
| << "%42 = OpTypeVector %13 4\n" |
| << "%48 = OpConstantFalse %13\n" |
| << "%50 = OpConstant %17 1\n" |
| << "%55 = OpConstantComposite %7 %11 %10 %11 %10\n" |
| << "%4 = OpFunction %2 None %3\n" |
| << "%5 = OpLabel\n" |
| << "%15 = OpVariable %14 Function\n" |
| << "%19 = OpVariable %18 Function\n" |
| << "OpStore %9 %12\n" |
| << "OpStore %15 %16\n" |
| << "OpStore %19 %20\n" |
| << "OpBranch %21\n" |
| << "%21 = OpLabel\n" |
| << "OpLoopMerge %23 %24 None\n" |
| << "OpBranch %25\n" |
| << "%25 = OpLabel\n" |
| << "%26 = OpLoad %17 %19\n" |
| << "%28 = OpSLessThan %13 %26 %27\n" |
| << "OpBranchConditional %28 %22 %23\n" |
| << "%22 = OpLabel\n" |
| << "%29 = OpLoad %13 %15\n" |
| << "OpSelectionMerge %31 None\n" |
| << "OpBranchConditional %29 %30 %31\n" |
| << "%30 = OpLabel\n" |
| << "%36 = OpLoad %17 %19\n" |
| << "%38 = OpAccessChain %37 %35 %36\n" |
| << "%39 = OpLoad %32 %38\n" |
| << "%40 = OpLoad %17 %19\n" |
| << "%41 = OpCompositeConstruct %32 %40 %40 %40 %40\n" |
| << "%43 = OpINotEqual %42 %39 %41\n" |
| << "%44 = OpAny %13 %43\n" |
| << "OpBranch %31\n" |
| << "%31 = OpLabel\n" |
| << "%45 = OpPhi %13 %29 %22 %44 %30\n" |
| << "OpSelectionMerge %47 None\n" |
| << "OpBranchConditional %45 %46 %47\n" |
| << "%46 = OpLabel\n" |
| << "OpStore %15 %48\n" |
| << "OpBranch %47\n" |
| << "%47 = OpLabel\n" |
| << "OpBranch %24\n" |
| << "%24 = OpLabel\n" |
| << "%49 = OpLoad %17 %19\n" |
| << "%51 = OpIAdd %17 %49 %50\n" |
| << "OpStore %19 %51\n" |
| << "OpBranch %21\n" |
| << "%23 = OpLabel\n" |
| << "%52 = OpLoad %13 %15\n" |
| << "OpSelectionMerge %54 None\n" |
| << "OpBranchConditional %52 %53 %54\n" |
| << "%53 = OpLabel\n" |
| << "OpStore %9 %55\n" |
| << "OpBranch %54\n" |
| << "%54 = OpLabel\n" |
| << "OpReturn\n" |
| << "OpFunctionEnd\n"; |
| |
| if (param.outputStage == VK_SHADER_STAGE_VERTEX_BIT) |
| { |
| programCollection.spirvAsmSources.add("vert") |
| << vertex_out.str().c_str(); |
| |
| if (param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT) |
| { |
| programCollection.spirvAsmSources.add("frag") |
| << fragment_in.str().c_str(); |
| return; |
| } |
| } |
| |
| programCollection.spirvAsmSources.add("vert") |
| << vertex_passthrough.str().c_str(); |
| |
| if (param.outputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) |
| { |
| programCollection.spirvAsmSources.add("tcs") |
| << tcs_passthrough.str().c_str(); |
| programCollection.spirvAsmSources.add("tes") |
| << tes_out.str().c_str(); |
| |
| if (param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT) |
| { |
| programCollection.spirvAsmSources.add("frag") |
| << fragment_in.str().c_str(); |
| return; |
| } |
| } |
| |
| if (param.outputStage == VK_SHADER_STAGE_GEOMETRY_BIT) |
| { |
| programCollection.spirvAsmSources.add("geom") |
| << geom_out.str().c_str(); |
| programCollection.spirvAsmSources.add("frag") |
| << fragment_in.str().c_str(); |
| return; |
| } |
| |
| DE_FATAL("Unsupported combination"); |
| } |
| |
| void supportedCheck (Context& context, MaxVaryingsParam param) |
| { |
| |
| const vk::InstanceInterface& vki = context.getInstanceInterface(); |
| VkPhysicalDeviceFeatures features; |
| vki.getPhysicalDeviceFeatures(context.getPhysicalDevice(), &features); |
| |
| // Check support for the tessellation and geometry shaders on the device |
| if ((param.inputStage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || |
| param.inputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT || |
| param.outputStage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || |
| param.outputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) |
| && !features.tessellationShader) |
| { |
| TCU_THROW(NotSupportedError, "Device does not support tessellation shaders"); |
| } |
| |
| if ((param.inputStage == VK_SHADER_STAGE_GEOMETRY_BIT || param.outputStage == VK_SHADER_STAGE_GEOMETRY_BIT) && !features.geometryShader) |
| { |
| TCU_THROW(NotSupportedError, "Device does not support geometry shaders"); |
| } |
| |
| // Check data sizes, throw unsupported if the case cannot be tested. |
| VkPhysicalDeviceProperties properties; |
| vki.getPhysicalDeviceProperties(context.getPhysicalDevice(), &properties); |
| std::ostringstream error; |
| if (param.stageToStressIO == VK_SHADER_STAGE_VERTEX_BIT) |
| { |
| DE_ASSERT(param.outputStage == VK_SHADER_STAGE_VERTEX_BIT); |
| if (param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT && properties.limits.maxFragmentInputComponents < (properties.limits.maxVertexOutputComponents - 4)) |
| { |
| error << "Device supports smaller number of FS inputs (" << properties.limits.maxFragmentInputComponents << ") than VS outputs (" << properties.limits.maxVertexOutputComponents << " - 4 built-ins)"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| } |
| |
| if (param.stageToStressIO == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) |
| { |
| if (param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT && properties.limits.maxFragmentInputComponents < (properties.limits.maxTessellationEvaluationOutputComponents - 4)) |
| { |
| error << "Device supports smaller number of FS inputs (" << properties.limits.maxFragmentInputComponents << ") than TES outputs (" << properties.limits.maxTessellationEvaluationOutputComponents << " - 4 builtins)"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| } |
| |
| if (param.stageToStressIO == VK_SHADER_STAGE_GEOMETRY_BIT) |
| { |
| if (param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT && properties.limits.maxFragmentInputComponents < (properties.limits.maxGeometryOutputComponents - 4)) |
| { |
| error << "Device supports smaller number of FS inputs (" << properties.limits.maxFragmentInputComponents << ") than GS outputs (" << properties.limits.maxGeometryOutputComponents << " - 4 built-ins)"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| } |
| |
| if (param.stageToStressIO == VK_SHADER_STAGE_FRAGMENT_BIT) |
| { |
| DE_ASSERT(param.inputStage == VK_SHADER_STAGE_FRAGMENT_BIT); |
| |
| if (param.outputStage == VK_SHADER_STAGE_VERTEX_BIT && (properties.limits.maxVertexOutputComponents - 4) < properties.limits.maxFragmentInputComponents) |
| { |
| error << "Device supports smaller number of VS outputs (" << properties.limits.maxVertexOutputComponents << " - 4 built-ins) than FS inputs (" << properties.limits.maxFragmentInputComponents << ")"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| if (param.outputStage == VK_SHADER_STAGE_GEOMETRY_BIT && (properties.limits.maxGeometryOutputComponents - 4) < properties.limits.maxFragmentInputComponents) |
| { |
| error << "Device supports smaller number of GS outputs (" << properties.limits.maxGeometryOutputComponents << " - 4 built-ins) than FS inputs (" << properties.limits.maxFragmentInputComponents << ")"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| if (param.outputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT && (properties.limits.maxTessellationEvaluationOutputComponents - 4) < properties.limits.maxFragmentInputComponents) |
| { |
| error << "Device supports smaller number of TES outputs (" << properties.limits.maxTessellationEvaluationOutputComponents << " - 4 built-ins) than FS inputs (" << properties.limits.maxFragmentInputComponents << ")"; |
| TCU_THROW(NotSupportedError, error.str().c_str()); |
| } |
| } |
| } |
| |
| VkImageCreateInfo makeImageCreateInfo (const tcu::IVec2& size, const VkFormat format, const VkImageUsageFlags usage) |
| { |
| const VkImageCreateInfo imageInfo = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| (VkImageCreateFlags)0, // VkImageCreateFlags flags; |
| VK_IMAGE_TYPE_2D, // VkImageType imageType; |
| format, // VkFormat format; |
| makeExtent3D(size.x(), size.y(), 1), // VkExtent3D extent; |
| 1u, // uint32_t mipLevels; |
| 1u, // uint32_t arrayLayers; |
| VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; |
| VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling; |
| usage, // VkImageUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 0u, // uint32_t queueFamilyIndexCount; |
| DE_NULL, // const uint32_t* pQueueFamilyIndices; |
| VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout; |
| }; |
| return imageInfo; |
| } |
| |
| Move<VkBuffer> makeBuffer (const DeviceInterface& vk, const VkDevice device, const VkDeviceSize bufferSize, const VkBufferUsageFlags usage) |
| { |
| const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(bufferSize, usage); |
| return createBuffer(vk, device, &bufferCreateInfo); |
| } |
| |
| void recordImageBarrier (const DeviceInterface& vk, |
| const VkCommandBuffer cmdBuffer, |
| const VkImage image, |
| const VkImageAspectFlags aspect, |
| const VkPipelineStageFlags srcStageMask, |
| const VkPipelineStageFlags dstStageMask, |
| const VkAccessFlags srcAccessMask, |
| const VkAccessFlags dstAccessMask, |
| const VkImageLayout oldLayout, |
| const VkImageLayout newLayout, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo = DE_NULL) |
| { |
| const VkImageMemoryBarrier barrier = |
| { |
| VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType; |
| pSampleLocationsInfo, // const void* pNext; |
| srcAccessMask, // VkAccessFlags srcAccessMask; |
| dstAccessMask, // VkAccessFlags dstAccessMask; |
| oldLayout, // VkImageLayout oldLayout; |
| newLayout, // VkImageLayout newLayout; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex; |
| image, // VkImage image; |
| makeImageSubresourceRange(aspect, 0u, 1u, 0u, 1u), // VkImageSubresourceRange subresourceRange; |
| }; |
| |
| vk.cmdPipelineBarrier(cmdBuffer, srcStageMask, dstStageMask, (VkDependencyFlags)0, 0u, DE_NULL, 0u, DE_NULL, 1u, &barrier); |
| } |
| |
| void recordCopyImageToBuffer (const DeviceInterface& vk, |
| const VkCommandBuffer cmdBuffer, |
| const tcu::IVec2& imageSize, |
| const VkImage srcImage, |
| const VkBuffer dstBuffer) |
| { |
| // Resolve image -> host buffer |
| { |
| const VkBufferImageCopy region = |
| { |
| 0ull, // VkDeviceSize bufferOffset; |
| 0u, // uint32_t bufferRowLength; |
| 0u, // uint32_t bufferImageHeight; |
| makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u), // VkImageSubresourceLayers imageSubresource; |
| makeOffset3D(0, 0, 0), // VkOffset3D imageOffset; |
| makeExtent3D(imageSize.x(), imageSize.y(), 1u), // VkExtent3D imageExtent; |
| }; |
| |
| vk.cmdCopyImageToBuffer(cmdBuffer, srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstBuffer, 1u, ®ion); |
| } |
| // Buffer write barrier |
| { |
| const VkBufferMemoryBarrier barrier = |
| { |
| VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask; |
| VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex; |
| VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex; |
| dstBuffer, // VkBuffer buffer; |
| 0ull, // VkDeviceSize offset; |
| VK_WHOLE_SIZE, // VkDeviceSize size; |
| }; |
| |
| vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, |
| 0u, DE_NULL, 1u, &barrier, DE_NULL, 0u); |
| } |
| } |
| |
| Move<VkBuffer> createBufferAndBindMemory (Context& context, VkDeviceSize size, VkBufferUsageFlags usage, de::MovePtr<Allocation>* pAlloc) |
| { |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice vkDevice = context.getDevice(); |
| const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); |
| |
| const VkBufferCreateInfo vertexBufferParams = |
| { |
| VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType; |
| DE_NULL, // const void* pNext; |
| 0u, // VkBufferCreateFlags flags; |
| size, // VkDeviceSize size; |
| usage, // VkBufferUsageFlags usage; |
| VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode; |
| 1u, // deUint32 queueFamilyCount; |
| &queueFamilyIndex // const deUint32* pQueueFamilyIndices; |
| }; |
| |
| Move<VkBuffer> vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams); |
| |
| *pAlloc = context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible); |
| VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, (*pAlloc)->getMemory(), (*pAlloc)->getOffset())); |
| |
| return vertexBuffer; |
| } |
| |
| deInt32 getMaxIOComponents(deBool input, VkShaderStageFlags stage, VkPhysicalDeviceProperties properties) |
| { |
| deInt32 data = 0u; |
| switch (stage) |
| { |
| case VK_SHADER_STAGE_VERTEX_BIT: |
| DE_ASSERT(!input); |
| data = (properties.limits.maxVertexOutputComponents / 4) - 1; // outputData + gl_Position |
| break; |
| |
| case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: |
| if (input) |
| data = properties.limits.maxTessellationEvaluationInputComponents / 4; |
| else |
| data = (properties.limits.maxTessellationEvaluationOutputComponents / 4) - 1; // outputData + gl_Position |
| break; |
| |
| case VK_SHADER_STAGE_GEOMETRY_BIT: |
| if (input) |
| data = properties.limits.maxGeometryInputComponents / 4; |
| else |
| data = (properties.limits.maxGeometryOutputComponents / 4) - 1; // outputData + gl_Position |
| break; |
| |
| case VK_SHADER_STAGE_FRAGMENT_BIT: |
| DE_ASSERT(input); |
| data = (properties.limits.maxFragmentInputComponents / 4); // inputData |
| break; |
| default: |
| DE_FATAL("Unsupported shader"); |
| }; |
| |
| return data; |
| } |
| |
| tcu::TestStatus test(Context& context, const MaxVaryingsParam param) |
| { |
| const InstanceInterface& vki = context.getInstanceInterface(); |
| const DeviceInterface& vk = context.getDeviceInterface(); |
| const VkDevice device = context.getDevice(); |
| const VkQueue queue = context.getUniversalQueue(); |
| const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); |
| Allocator& allocator = context.getDefaultAllocator(); |
| tcu::TestLog &log = context.getTestContext().getLog(); |
| |
| |
| // Color attachment |
| const tcu::IVec2 renderSize = tcu::IVec2(32, 32); |
| const VkFormat imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| const Image colorImage (vk, device, allocator, makeImageCreateInfo(renderSize, imageFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT), MemoryRequirement::Any); |
| const Unique<VkImageView> colorImageView (makeImageView(vk, device, *colorImage, VK_IMAGE_VIEW_TYPE_2D, imageFormat, makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u))); |
| const VkDeviceSize colorBufferSize = renderSize.x() * renderSize.y() * tcu::getPixelSize(mapVkFormat(imageFormat)); |
| Move<VkBuffer> colorBuffer = vkt::pipeline::makeBuffer(vk, device, colorBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT); |
| MovePtr<Allocation> colorBufferAlloc = bindBuffer(vk, device, allocator, *colorBuffer, MemoryRequirement::HostVisible); |
| |
| |
| // Create vertex buffer |
| de::MovePtr<Allocation> vertexBufferMemory; |
| Move<VkBuffer> vertexBuffer = createBufferAndBindMemory(context, sizeof(tcu::Vec4) * 6u, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, &vertexBufferMemory); |
| std::vector<tcu::Vec4> vertices; |
| { |
| vertices.push_back(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f)); |
| vertices.push_back(tcu::Vec4(-1.0f, 1.0f, 0.0f, 1.0f)); |
| vertices.push_back(tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f)); |
| vertices.push_back(tcu::Vec4(-1.0f, -1.0f, 0.0f, 1.0f)); |
| vertices.push_back(tcu::Vec4( 1.0f, -1.0f, 0.0f, 1.0f)); |
| vertices.push_back(tcu::Vec4( 1.0f, 1.0f, 0.0f, 1.0f)); |
| // Load vertices into vertex buffer |
| deMemcpy(vertexBufferMemory->getHostPtr(), vertices.data(), vertices.size() * sizeof(tcu::Vec4)); |
| flushAlloc(vk, device, *vertexBufferMemory); |
| } |
| |
| // Specialization |
| VkPhysicalDeviceProperties properties; |
| vki.getPhysicalDeviceProperties(context.getPhysicalDevice(), &properties); |
| VkPhysicalDeviceFeatures features; |
| vki.getPhysicalDeviceFeatures(context.getPhysicalDevice(), &features); |
| |
| deInt32 data = 0u; |
| size_t dataSize = sizeof(data); |
| deInt32 maxOutput = getMaxIOComponents(false, param.outputStage, properties); |
| deInt32 maxInput = getMaxIOComponents(true, param.inputStage, properties); |
| |
| data = deMin32(maxOutput, maxInput); |
| |
| DE_ASSERT(data != 0u); |
| |
| log << tcu::TestLog::Message << "Testing " << data * 4 << " input components for stage " << getShaderStageName(param.stageToStressIO).c_str() << tcu::TestLog::EndMessage; |
| |
| VkSpecializationMapEntry mapEntries = |
| { |
| 0u, // deUint32 constantID; |
| 0u, // deUint32 offset; |
| dataSize // size_t size; |
| }; |
| |
| VkSpecializationInfo pSpecInfo = |
| { |
| 1u, // deUint32 mapEntryCount; |
| &mapEntries, // const VkSpecializationMapEntry* pMapEntries; |
| dataSize, // size_t dataSize; |
| &data // const void* pData; |
| }; |
| |
| // Pipeline |
| |
| const Unique<VkRenderPass> renderPass (makeRenderPass (vk, device, imageFormat)); |
| const Unique<VkFramebuffer> framebuffer (makeFramebuffer (vk, device, *renderPass, 1u, &colorImageView.get(), static_cast<deUint32>(renderSize.x()), static_cast<deUint32>(renderSize.y()))); |
| const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device)); |
| const Unique<VkCommandPool> cmdPool (createCommandPool (vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex)); |
| const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer (vk, device, *cmdPool)); |
| |
| GraphicsPipelineBuilder pipelineBuilder; |
| pipelineBuilder |
| .setRenderSize(renderSize); |
| |
| // Get the shaders to run |
| std::vector<SelectedShaders> shaders; |
| shaders.push_back(SelectedShaders(VK_SHADER_STAGE_VERTEX_BIT, "vert")); |
| shaders.push_back(SelectedShaders(VK_SHADER_STAGE_FRAGMENT_BIT, "frag")); |
| |
| if (param.inputStage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || param.outputStage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || |
| param.inputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT || param.outputStage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) |
| { |
| shaders.push_back(SelectedShaders(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "tcs")); |
| shaders.push_back(SelectedShaders(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "tes")); |
| } |
| if (param.inputStage == VK_SHADER_STAGE_GEOMETRY_BIT || param.outputStage == VK_SHADER_STAGE_GEOMETRY_BIT) |
| { |
| shaders.push_back(SelectedShaders(VK_SHADER_STAGE_GEOMETRY_BIT, "geom")); |
| } |
| |
| for (deUint32 i = 0; i < (deUint32)shaders.size(); i++) |
| { |
| pipelineBuilder.setShader(vk, device, shaders[i].stage, context.getBinaryCollection().get(shaders[i].shaderName.c_str()), &pSpecInfo); |
| } |
| |
| const Unique<VkPipeline> pipeline (pipelineBuilder.build(vk, device, *pipelineLayout, *renderPass)); |
| |
| // Draw commands |
| |
| const VkRect2D renderArea = makeRect2D(renderSize); |
| const tcu::Vec4 clearColor (0.0f, 0.0f, 0.0f, 1.0f); |
| |
| beginCommandBuffer(vk, *cmdBuffer); |
| |
| { |
| const VkImageSubresourceRange imageFullSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); |
| const VkImageMemoryBarrier barrierColorAttachmentSetInitialLayout = makeImageMemoryBarrier( |
| 0u, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, |
| VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, |
| *colorImage, imageFullSubresourceRange); |
| |
| vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u, |
| 0u, DE_NULL, 0u, DE_NULL, 1u, &barrierColorAttachmentSetInitialLayout); |
| } |
| |
| beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderArea, clearColor); |
| |
| vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); |
| const VkDeviceSize vertexBufferOffset = 0ull; |
| vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset); |
| |
| // Draw one vertex |
| vk.cmdDraw(*cmdBuffer, (deUint32)vertices.size(), 1u, 0u, 0u); |
| endRenderPass(vk, *cmdBuffer); |
| // Resolve image -> host buffer |
| recordImageBarrier(vk, *cmdBuffer, *colorImage, |
| VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspect, |
| VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VkPipelineStageFlags srcStageMask, |
| VK_PIPELINE_STAGE_TRANSFER_BIT, // VkPipelineStageFlags dstStageMask, |
| VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask, |
| VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask, |
| VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout, |
| VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); // VkImageLayout newLayout) |
| |
| recordCopyImageToBuffer(vk, *cmdBuffer, renderSize, *colorImage, *colorBuffer); |
| endCommandBuffer(vk, *cmdBuffer); |
| submitCommandsAndWait(vk, device, queue, *cmdBuffer); |
| |
| // Verify results |
| { |
| invalidateAlloc(vk, device, *colorBufferAlloc); |
| |
| const tcu::ConstPixelBufferAccess resultImage (mapVkFormat(imageFormat), renderSize.x(), renderSize.y(), 1u, colorBufferAlloc->getHostPtr()); |
| tcu::TextureLevel referenceImage (mapVkFormat(imageFormat), renderSize.x(), renderSize.y()); |
| tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f)); |
| |
| if (!tcu::floatThresholdCompare(log, "Compare", "Result comparison", referenceImage.getAccess(), resultImage, tcu::Vec4(0.02f), tcu::COMPARE_LOG_RESULT)) |
| TCU_FAIL("Rendered image is not correct"); |
| } |
| return tcu::TestStatus::pass("OK"); |
| } |
| } // anonymous |
| |
| tcu::TestCaseGroup* createMaxVaryingsTests (tcu::TestContext& testCtx) |
| { |
| std::vector<MaxVaryingsParam> tests; |
| |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_VERTEX_BIT)); // Test max vertex outputs: VS-FS |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_FRAGMENT_BIT)); // Test max FS inputs: VS-FS |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); // Test max tess evaluation outputs: VS-TCS-TES-FS |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_FRAGMENT_BIT)); // Test fragment inputs: VS-TCS-TES-FS |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_GEOMETRY_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_GEOMETRY_BIT)); // Test geometry outputs: VS-GS-FS |
| tests.push_back(MaxVaryingsParam(VK_SHADER_STAGE_GEOMETRY_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_FRAGMENT_BIT)); // Test fragment inputs: VS-GS-FS |
| |
| de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "max_varyings", "Max Varyings tests")); |
| |
| for (deUint32 testIndex = 0; testIndex < (deUint32)tests.size(); ++testIndex) |
| { |
| MaxVaryingsParam testParams = tests[testIndex]; |
| addFunctionCaseWithPrograms(group.get(), generateTestName(testParams), generateTestDescription(), |
| supportedCheck, initPrograms, test, testParams); |
| } |
| |
| return group.release(); |
| } |
| |
| } // pipeline |
| } // vkt |
