Test that null acceleration structure handles treated as miss.
Affected tests:
* dEQP-VK.ray_tracing.null_as.*
* dEQP-VK.ray_query.advanced.null_as.*
Components: Vulkan
VK-GL-CTS issue: 2367
Change-Id: If35d5763dda93cf47eb3c03ab95de6320b23e64d
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingBuiltinTests.cpp \
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingCallableShadersTests.cpp \
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingMemGuaranteeTests.cpp \
+ external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingNullASTests.cpp \
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingPipelineLibraryTests.cpp \
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingShaderBindingTableTests.cpp \
external/vulkancts/modules/vulkan/ray_tracing/vktRayTracingTests.cpp \
dEQP-VK.ray_tracing.memguarantee.between.sect
dEQP-VK.ray_tracing.memguarantee.between.miss
dEQP-VK.ray_tracing.memguarantee.between.call
+dEQP-VK.ray_tracing.null_as.test
dEQP-VK.ray_query.builtin.flow.vert.triangles
dEQP-VK.ray_query.builtin.flow.vert.aabbs
dEQP-VK.ray_query.builtin.flow.tesc.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.top_acceleration_structure.aabbs
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.aabbs
+dEQP-VK.ray_query.advanced.null_as.vert.triangles
+dEQP-VK.ray_query.advanced.null_as.vert.aabbs
+dEQP-VK.ray_query.advanced.null_as.tesc.triangles
+dEQP-VK.ray_query.advanced.null_as.tesc.aabbs
+dEQP-VK.ray_query.advanced.null_as.tese.triangles
+dEQP-VK.ray_query.advanced.null_as.tese.aabbs
+dEQP-VK.ray_query.advanced.null_as.geom.triangles
+dEQP-VK.ray_query.advanced.null_as.geom.aabbs
+dEQP-VK.ray_query.advanced.null_as.frag.triangles
+dEQP-VK.ray_query.advanced.null_as.frag.aabbs
+dEQP-VK.ray_query.advanced.null_as.comp.triangles
+dEQP-VK.ray_query.advanced.null_as.comp.aabbs
+dEQP-VK.ray_query.advanced.null_as.rgen.triangles
+dEQP-VK.ray_query.advanced.null_as.rgen.aabbs
+dEQP-VK.ray_query.advanced.null_as.ahit.triangles
+dEQP-VK.ray_query.advanced.null_as.ahit.aabbs
+dEQP-VK.ray_query.advanced.null_as.chit.triangles
+dEQP-VK.ray_query.advanced.null_as.chit.aabbs
+dEQP-VK.ray_query.advanced.null_as.miss.triangles
+dEQP-VK.ray_query.advanced.null_as.miss.aabbs
+dEQP-VK.ray_query.advanced.null_as.sect.triangles
+dEQP-VK.ray_query.advanced.null_as.sect.aabbs
+dEQP-VK.ray_query.advanced.null_as.call.triangles
+dEQP-VK.ray_query.advanced.null_as.call.aabbs
dEQP-VK.ray_tracing.memguarantee.between.sect
dEQP-VK.ray_tracing.memguarantee.between.miss
dEQP-VK.ray_tracing.memguarantee.between.call
+dEQP-VK.ray_tracing.null_as.test
dEQP-VK.ray_query.builtin.flow.vert.triangles
dEQP-VK.ray_query.builtin.flow.vert.aabbs
dEQP-VK.ray_query.builtin.flow.tesc.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.top_acceleration_structure.aabbs
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.aabbs
+dEQP-VK.ray_query.advanced.null_as.vert.triangles
+dEQP-VK.ray_query.advanced.null_as.vert.aabbs
+dEQP-VK.ray_query.advanced.null_as.tesc.triangles
+dEQP-VK.ray_query.advanced.null_as.tesc.aabbs
+dEQP-VK.ray_query.advanced.null_as.tese.triangles
+dEQP-VK.ray_query.advanced.null_as.tese.aabbs
+dEQP-VK.ray_query.advanced.null_as.geom.triangles
+dEQP-VK.ray_query.advanced.null_as.geom.aabbs
+dEQP-VK.ray_query.advanced.null_as.frag.triangles
+dEQP-VK.ray_query.advanced.null_as.frag.aabbs
+dEQP-VK.ray_query.advanced.null_as.comp.triangles
+dEQP-VK.ray_query.advanced.null_as.comp.aabbs
+dEQP-VK.ray_query.advanced.null_as.rgen.triangles
+dEQP-VK.ray_query.advanced.null_as.rgen.aabbs
+dEQP-VK.ray_query.advanced.null_as.ahit.triangles
+dEQP-VK.ray_query.advanced.null_as.ahit.aabbs
+dEQP-VK.ray_query.advanced.null_as.chit.triangles
+dEQP-VK.ray_query.advanced.null_as.chit.aabbs
+dEQP-VK.ray_query.advanced.null_as.miss.triangles
+dEQP-VK.ray_query.advanced.null_as.miss.aabbs
+dEQP-VK.ray_query.advanced.null_as.sect.triangles
+dEQP-VK.ray_query.advanced.null_as.sect.aabbs
+dEQP-VK.ray_query.advanced.null_as.call.triangles
+dEQP-VK.ray_query.advanced.null_as.call.aabbs
enum TestType
{
- TEST_TYPE_FLOW = 0,
+ TEST_TYPE_FLOW = 0,
TEST_TYPE_PRIMITIVE_ID,
TEST_TYPE_INSTANCE_ID,
TEST_TYPE_INSTANCE_CUSTOM_INDEX,
TEST_TYPE_OBJECT_RAY_DIRECTION_KHR,
TEST_TYPE_OBJECT_TO_WORLD_KHR,
TEST_TYPE_WORLD_TO_OBJECT_KHR,
+ TEST_TYPE_NULL_ACCELERATION_STRUCTURE,
+ TEST_TYPE_LAST
};
enum GeomType
CheckSupportFunc pipelineCheckSupport;
InitProgramsFunc pipelineInitPrograms;
ShaderBodyTextFunc testConfigShaderBodyText;
+ CheckSupportFunc testConfigCheckSupport;
};
deUint32 getShaderGroupHandleSize (const InstanceInterface& vki,
}
}
+class TestConfigurationNullASStruct : public TestConfiguration
+{
+public:
+ TestConfigurationNullASStruct ();
+ ~TestConfigurationNullASStruct ();
+
+ static const std::string getShaderBodyText (const TestParams& testParams);
+ static void checkSupport (Context& context,
+ const TestParams& testParams);
+
+ virtual const VkAccelerationStructureKHR* initAccelerationStructures (Context& context,
+ TestParams& testParams,
+ VkCommandBuffer cmdBuffer) override;
+protected:
+ Move<VkAccelerationStructureKHR> m_emptyAccelerationStructure;
+};
+
+TestConfigurationNullASStruct::TestConfigurationNullASStruct ()
+ : TestConfiguration ()
+ , m_emptyAccelerationStructure ()
+{
+}
+
+TestConfigurationNullASStruct::~TestConfigurationNullASStruct ()
+{
+}
+
+const VkAccelerationStructureKHR* TestConfigurationNullASStruct::initAccelerationStructures (Context& context,
+ TestParams& testParams,
+ VkCommandBuffer cmdBuffer)
+{
+ DE_UNREF(context);
+ DE_UNREF(cmdBuffer);
+
+ m_expected = std::vector<deInt32>(testParams.width * testParams.height, 1);
+
+ return &m_emptyAccelerationStructure.get();
+}
+
+void TestConfigurationNullASStruct::checkSupport (Context& context,
+ const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ context.requireDeviceFunctionality("VK_EXT_robustness2");
+
+ const vk::VkPhysicalDeviceRobustness2FeaturesEXT& robustness2FeaturesEXT = context.getRobustness2FeaturesEXT();
+
+ if (!robustness2FeaturesEXT.nullDescriptor)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRobustness2FeaturesEXT::nullDescriptor");
+}
+
+const std::string TestConfigurationNullASStruct::getShaderBodyText (const TestParams& testParams)
+{
+ DE_UNREF(testParams);
+
+ const std::string result =
+ " uint rayFlags = 0;\n"
+ " uint cullMask = 0xFF;\n"
+ " float tmin = 0.0;\n"
+ " float tmax = 9.0;\n"
+ " vec3 origin = vec3((float(pos.x) + 0.5f) / float(size.x), (float(pos.y) + 0.5f) / float(size.y), 0.0);\n"
+ " vec3 direct = vec3(0.0, 0.0, -1.0);\n"
+ " uint value = 1;\n"
+ " rayQueryEXT rayQuery;\n"
+ "\n"
+ " rayQueryInitializeEXT(rayQuery, rayQueryTopLevelAccelerationStructure, rayFlags, cullMask, origin, tmin, direct, tmax);\n"
+ "\n"
+ " if (rayQueryProceedEXT(rayQuery))\n"
+ " {\n"
+ " value++;\n"
+ "\n"
+ " rayQueryTerminateEXT(rayQuery);\n"
+ " }\n"
+ "\n"
+ " imageStore(result, pos, ivec4(value, 0, 0, 0));\n";
+
+ return result;
+}
+
class RayQueryBuiltinTestInstance : public TestInstance
{
public:
case TEST_TYPE_OBJECT_RAY_DIRECTION_KHR: m_testConfig = de::MovePtr<TestConfiguration>(new TestConfigurationObjectRayDirection()); break;
case TEST_TYPE_OBJECT_TO_WORLD_KHR: m_testConfig = de::MovePtr<TestConfiguration>(new TestConfigurationObjectToWorld()); break;
case TEST_TYPE_WORLD_TO_OBJECT_KHR: m_testConfig = de::MovePtr<TestConfiguration>(new TestConfigurationWorldToObject()); break;
+ case TEST_TYPE_NULL_ACCELERATION_STRUCTURE: m_testConfig = de::MovePtr<TestConfiguration>(new TestConfigurationNullASStruct()); break;
default: TCU_THROW(InternalError, "Unknown test type");
}
TCU_THROW(NotSupportedError, "Requires rayTracingFeaturesKHR.rayQuery");
m_data.pipelineCheckSupport(context, m_data);
+
+ if (m_data.testConfigCheckSupport != DE_NULL)
+ m_data.testConfigCheckSupport(context, m_data);
}
TestInstance* RayQueryBuiltinTestCase::createInstance (Context& context) const
case TEST_TYPE_OBJECT_RAY_DIRECTION_KHR: return TestConfigurationObjectRayDirection::getShaderBodyText; break;
case TEST_TYPE_OBJECT_TO_WORLD_KHR: return TestConfigurationObjectToWorld::getShaderBodyText; break;
case TEST_TYPE_WORLD_TO_OBJECT_KHR: return TestConfigurationWorldToObject::getShaderBodyText; break;
- default: TCU_THROW(InternalError, "Unknown test type");
+ case TEST_TYPE_NULL_ACCELERATION_STRUCTURE: return TestConfigurationNullASStruct::getShaderBodyText; break;
+ default: TCU_THROW(InternalError, "Unknown test type");
+ }
+}
+
+static inline CheckSupportFunc getTestConfigCheckSupport (const TestType testType)
+{
+ if (testType >= TEST_TYPE_LAST)
+ TCU_THROW(InternalError, "Unknown test type");
+
+ switch (testType)
+ {
+ case TEST_TYPE_NULL_ACCELERATION_STRUCTURE: return TestConfigurationNullASStruct::checkSupport; break;
+ default: return DE_NULL;
}
}
} // anonymous
+const struct PipelineStages
+{
+ VkShaderStageFlagBits stage;
+ const char* name;
+}
+pipelineStages[] =
+{
+ { VK_SHADER_STAGE_VERTEX_BIT, "vert" },
+ { VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "tesc" },
+ { VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "tese" },
+ { VK_SHADER_STAGE_GEOMETRY_BIT, "geom" },
+ { VK_SHADER_STAGE_FRAGMENT_BIT, "frag" },
+ { VK_SHADER_STAGE_COMPUTE_BIT, "comp" },
+ { VK_SHADER_STAGE_RAYGEN_BIT_KHR, "rgen" },
+ { VK_SHADER_STAGE_ANY_HIT_BIT_KHR, "ahit" },
+ { VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, "chit" },
+ { VK_SHADER_STAGE_MISS_BIT_KHR, "miss" },
+ { VK_SHADER_STAGE_INTERSECTION_BIT_KHR, "sect" },
+ { VK_SHADER_STAGE_CALLABLE_BIT_KHR, "call" },
+};
+
+const struct GeomTypes
+{
+ GeomType geomType;
+ const char* name;
+}
+geomTypes[] =
+{
+ { GEOM_TYPE_TRIANGLES, "triangles" },
+ { GEOM_TYPE_AABBS, "aabbs" },
+};
+
tcu::TestCaseGroup* createBuiltinTests (tcu::TestContext& testCtx)
{
- de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "builtin", "Tests verifying builtins provided by ray query"));
+ de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "builtin", "Tests verifying builtins provided by ray query"));
- const struct PipelineStages
- {
- VkShaderStageFlagBits stage;
- const char* name;
- }
- pipelineStages[] =
- {
- { VK_SHADER_STAGE_VERTEX_BIT, "vert" },
- { VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "tesc" },
- { VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "tese" },
- { VK_SHADER_STAGE_GEOMETRY_BIT, "geom" },
- { VK_SHADER_STAGE_FRAGMENT_BIT, "frag" },
- { VK_SHADER_STAGE_COMPUTE_BIT, "comp" },
- { VK_SHADER_STAGE_RAYGEN_BIT_KHR, "rgen" },
- { VK_SHADER_STAGE_ANY_HIT_BIT_KHR, "ahit" },
- { VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, "chit" },
- { VK_SHADER_STAGE_MISS_BIT_KHR, "miss" },
- { VK_SHADER_STAGE_INTERSECTION_BIT_KHR, "sect" },
- { VK_SHADER_STAGE_CALLABLE_BIT_KHR, "call" },
- };
const struct TestTypes
{
TestType testType;
{ TEST_TYPE_OBJECT_TO_WORLD_KHR, "objecttoworld" },
{ TEST_TYPE_WORLD_TO_OBJECT_KHR, "worldtoobject" },
};
- const struct GeomTypes
+
+ for (size_t testTypeNdx = 0; testTypeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++testTypeNdx)
+ {
+ de::MovePtr<tcu::TestCaseGroup> testTypeGroup (new tcu::TestCaseGroup(group->getTestContext(), testTypes[testTypeNdx].name, ""));
+ const TestType testType = testTypes[testTypeNdx].testType;
+ const ShaderBodyTextFunc testConfigShaderBodyTextFunc = getShaderBodyTextFunc(testType);
+ const bool fixedPointVectorOutput = testType == TEST_TYPE_OBJECT_RAY_ORIGIN_KHR
+ || testType == TEST_TYPE_OBJECT_RAY_DIRECTION_KHR;
+ const bool fixedPointMatrixOutput = testType == TEST_TYPE_OBJECT_TO_WORLD_KHR
+ || testType == TEST_TYPE_WORLD_TO_OBJECT_KHR;
+ const bool single = testTypeNdx == TEST_TYPE_FLOW
+ || testType == TEST_TYPE_OBJECT_RAY_ORIGIN_KHR
+ || testType == TEST_TYPE_OBJECT_RAY_DIRECTION_KHR
+ || testType == TEST_TYPE_OBJECT_TO_WORLD_KHR
+ || testType == TEST_TYPE_WORLD_TO_OBJECT_KHR;
+ const deUint32 imageDepth = fixedPointMatrixOutput ? 4 * 4
+ : fixedPointVectorOutput ? 4
+ : 1;
+
+ for (size_t pipelineStageNdx = 0; pipelineStageNdx < DE_LENGTH_OF_ARRAY(pipelineStages); ++pipelineStageNdx)
+ {
+ de::MovePtr<tcu::TestCaseGroup> sourceTypeGroup (new tcu::TestCaseGroup(group->getTestContext(), pipelineStages[pipelineStageNdx].name, ""));
+ const VkShaderStageFlagBits stage = pipelineStages[pipelineStageNdx].stage;
+ const CheckSupportFunc pipelineCheckSupport = getPipelineCheckSupport(stage);
+ const InitProgramsFunc pipelineInitPrograms = getPipelineInitPrograms(stage);
+ const deUint32 instancesGroupCount = single ? 1 : 2;
+ const deUint32 geometriesGroupCount = single ? 1 : 8;
+ const deUint32 squaresGroupCount = (TEST_WIDTH * TEST_HEIGHT) / geometriesGroupCount / instancesGroupCount;
+
+ DE_ASSERT(instancesGroupCount * geometriesGroupCount * squaresGroupCount == TEST_WIDTH * TEST_HEIGHT);
+
+ for (size_t geomTypeNdx = 0; geomTypeNdx < DE_LENGTH_OF_ARRAY(geomTypes); ++geomTypeNdx)
+ {
+ const GeomType geomType = geomTypes[geomTypeNdx].geomType;
+ const TestParams testParams =
+ {
+ TEST_WIDTH, // deUint32 width;
+ TEST_HEIGHT, // deUint32 height;
+ imageDepth, // deUint32 depth;
+ testType, // TestType testType;
+ stage, // VkShaderStageFlagBits stage;
+ geomType, // GeomType geomType;
+ squaresGroupCount, // deUint32 squaresGroupCount;
+ geometriesGroupCount, // deUint32 geometriesGroupCount;
+ instancesGroupCount, // deUint32 instancesGroupCount;
+ VK_FORMAT_R32_SINT, // VkFormat format;
+ pipelineCheckSupport, // CheckSupportFunc pipelineCheckSupport;
+ pipelineInitPrograms, // InitProgramsFunc pipelineInitPrograms;
+ testConfigShaderBodyTextFunc, // ShaderTestTextFunc testConfigShaderBodyText;
+ DE_NULL, // CheckSupportFunc testConfigCheckSupport;
+ };
+
+ sourceTypeGroup->addChild(new RayQueryBuiltinTestCase(group->getTestContext(), geomTypes[geomTypeNdx].name, "", testParams));
+ }
+
+ testTypeGroup->addChild(sourceTypeGroup.release());
+ }
+
+ group->addChild(testTypeGroup.release());
+ }
+
+ return group.release();
+}
+
+tcu::TestCaseGroup* createAdvancedTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "advanced", "Advanced ray query tests"));
+
+ const struct TestTypes
{
- GeomType geomType;
+ TestType testType;
const char* name;
}
- geomTypes[] =
+ testTypes[] =
{
- { GEOM_TYPE_TRIANGLES, "triangles" },
- { GEOM_TYPE_AABBS, "aabbs" },
+ { TEST_TYPE_NULL_ACCELERATION_STRUCTURE, "null_as" },
};
for (size_t testTypeNdx = 0; testTypeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++testTypeNdx)
{
- de::MovePtr<tcu::TestCaseGroup> testTypeGroup (new tcu::TestCaseGroup(group->getTestContext(), testTypes[testTypeNdx].name, ""));
- const TestType testType = testTypes[testTypeNdx].testType;
- const ShaderBodyTextFunc shaderBodyTextFunc = getShaderBodyTextFunc(testType);
- const bool fixedPointVectorOutput = testType == TEST_TYPE_OBJECT_RAY_ORIGIN_KHR
- || testType == TEST_TYPE_OBJECT_RAY_DIRECTION_KHR;
- const bool fixedPointMatrixOutput = testType == TEST_TYPE_OBJECT_TO_WORLD_KHR
- || testType == TEST_TYPE_WORLD_TO_OBJECT_KHR;
- const bool single = testTypeNdx == TEST_TYPE_FLOW
- || testType == TEST_TYPE_OBJECT_RAY_ORIGIN_KHR
- || testType == TEST_TYPE_OBJECT_RAY_DIRECTION_KHR
- || testType == TEST_TYPE_OBJECT_TO_WORLD_KHR
- || testType == TEST_TYPE_WORLD_TO_OBJECT_KHR;
- const deUint32 imageDepth = fixedPointMatrixOutput ? 4 * 4
- : fixedPointVectorOutput ? 4
- : 1;
+ de::MovePtr<tcu::TestCaseGroup> testTypeGroup (new tcu::TestCaseGroup(group->getTestContext(), testTypes[testTypeNdx].name, ""));
+ const TestType testType = testTypes[testTypeNdx].testType;
+ const ShaderBodyTextFunc testConfigShaderBodyTextFunc = getShaderBodyTextFunc(testType);
+ const CheckSupportFunc testConfigCheckSupport = getTestConfigCheckSupport(testType);
+ const deUint32 imageDepth = 1;
for (size_t pipelineStageNdx = 0; pipelineStageNdx < DE_LENGTH_OF_ARRAY(pipelineStages); ++pipelineStageNdx)
{
const VkShaderStageFlagBits stage = pipelineStages[pipelineStageNdx].stage;
const CheckSupportFunc pipelineCheckSupport = getPipelineCheckSupport(stage);
const InitProgramsFunc pipelineInitPrograms = getPipelineInitPrograms(stage);
- const deUint32 instancesGroupCount = single ? 1 : 2;
- const deUint32 geometriesGroupCount = single ? 1 : 8;
+ const deUint32 instancesGroupCount = 1;
+ const deUint32 geometriesGroupCount = 1;
const deUint32 squaresGroupCount = (TEST_WIDTH * TEST_HEIGHT) / geometriesGroupCount / instancesGroupCount;
DE_ASSERT(instancesGroupCount * geometriesGroupCount * squaresGroupCount == TEST_WIDTH * TEST_HEIGHT);
const GeomType geomType = geomTypes[geomTypeNdx].geomType;
const TestParams testParams =
{
- TEST_WIDTH, // deUint32 width;
- TEST_HEIGHT, // deUint32 height;
- imageDepth, // deUint32 depth;
- testType, // TestType testType;
- stage, // VkShaderStageFlagBits stage;
- geomType, // GeomType geomType;
- squaresGroupCount, // deUint32 squaresGroupCount;
- geometriesGroupCount, // deUint32 geometriesGroupCount;
- instancesGroupCount, // deUint32 instancesGroupCount;
- VK_FORMAT_R32_SINT, // VkFormat format;
- pipelineCheckSupport, // CheckSupportFunc pipelineCheckSupport;
- pipelineInitPrograms, // InitProgramsFunc pipelineInitPrograms;
- shaderBodyTextFunc, // ShaderTestTextFunc testConfigShaderBodyText;
+ TEST_WIDTH, // deUint32 width;
+ TEST_HEIGHT, // deUint32 height;
+ imageDepth, // deUint32 depth;
+ testType, // TestType testType;
+ stage, // VkShaderStageFlagBits stage;
+ geomType, // GeomType geomType;
+ squaresGroupCount, // deUint32 squaresGroupCount;
+ geometriesGroupCount, // deUint32 geometriesGroupCount;
+ instancesGroupCount, // deUint32 instancesGroupCount;
+ VK_FORMAT_R32_SINT, // VkFormat format;
+ pipelineCheckSupport, // CheckSupportFunc pipelineCheckSupport;
+ pipelineInitPrograms, // InitProgramsFunc pipelineInitPrograms;
+ testConfigShaderBodyTextFunc, // ShaderTestTextFunc testConfigShaderBodyText;
+ testConfigCheckSupport, // CheckSupportFunc testConfigCheckSupport;
};
sourceTypeGroup->addChild(new RayQueryBuiltinTestCase(group->getTestContext(), geomTypes[geomTypeNdx].name, "", testParams));
{
tcu::TestCaseGroup* createBuiltinTests (tcu::TestContext& testCtx);
+tcu::TestCaseGroup* createAdvancedTests (tcu::TestContext& testCtx);
} // RayQuery
} // vkt
group->addChild(createBuiltinTests(testCtx));
group->addChild(createTraversalControlTests(testCtx));
group->addChild(createAccelerationStructuresTests(testCtx));
+ group->addChild(createAdvancedTests(testCtx));
return group.release();
}
vktRayTracingTraceRaysIndirectTests.hpp
vktRayTracingMemGuaranteeTests.cpp
vktRayTracingMemGuaranteeTests.hpp
+ vktRayTracingNullASTests.cpp
+ vktRayTracingNullASTests.hpp
vktRayTracingShaderBindingTableTests.cpp
vktRayTracingShaderBindingTableTests.hpp
vktRayTracingTraversalControlTests.cpp
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2020 The Khronos Group Inc.
+ *
+ * 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 Acceleration Structure Null Handle Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktRayTracingNullASTests.hpp"
+
+#include "vkDefs.hpp"
+
+#include "vktTestCase.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkObjUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkBarrierUtil.hpp"
+#include "vkBufferWithMemory.hpp"
+#include "vkImageWithMemory.hpp"
+#include "vkTypeUtil.hpp"
+
+#include "vkRayTracingUtil.hpp"
+
+#include "deClock.h"
+
+namespace vkt
+{
+namespace RayTracing
+{
+namespace
+{
+using namespace vk;
+using namespace std;
+
+static const VkFlags ALL_RAY_TRACING_STAGES = VK_SHADER_STAGE_RAYGEN_BIT_KHR
+ | VK_SHADER_STAGE_ANY_HIT_BIT_KHR
+ | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR
+ | VK_SHADER_STAGE_MISS_BIT_KHR
+ | VK_SHADER_STAGE_INTERSECTION_BIT_KHR
+ | VK_SHADER_STAGE_CALLABLE_BIT_KHR;
+
+struct CaseDef
+{
+ deUint32 width;
+ deUint32 height;
+};
+
+enum ShaderGroups
+{
+ FIRST_GROUP = 0,
+ RAYGEN_GROUP = FIRST_GROUP,
+ MISS_GROUP,
+ HIT_GROUP,
+ GROUP_COUNT
+};
+
+deUint32 getShaderGroupSize (const InstanceInterface& vki,
+ const VkPhysicalDevice physicalDevice)
+{
+ de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
+
+ rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
+ return rayTracingPropertiesKHR->getShaderGroupHandleSize();
+}
+
+deUint32 getShaderGroupBaseAlignment (const InstanceInterface& vki,
+ const VkPhysicalDevice physicalDevice)
+{
+ de::MovePtr<RayTracingProperties> rayTracingPropertiesKHR;
+
+ rayTracingPropertiesKHR = makeRayTracingProperties(vki, physicalDevice);
+ return rayTracingPropertiesKHR->getShaderGroupBaseAlignment();
+}
+
+Move<VkPipeline> makePipeline (const DeviceInterface& vkd,
+ const VkDevice device,
+ vk::BinaryCollection& collection,
+ de::MovePtr<RayTracingPipeline>& rayTracingPipeline,
+ VkPipelineLayout pipelineLayout,
+ const deUint32 raygenGroup,
+ const deUint32 missGroup,
+ const deUint32 hitGroup)
+{
+ Move<VkShaderModule> raygenShader = createShaderModule(vkd, device, collection.get("rgen"), 0);
+ Move<VkShaderModule> hitShader = createShaderModule(vkd, device, collection.get("ahit"), 0);
+ Move<VkShaderModule> missShader = createShaderModule(vkd, device, collection.get("miss"), 0);
+ Move<VkShaderModule> intersectionShader = createShaderModule(vkd, device, collection.get("sect"), 0);
+
+ rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, raygenShader, raygenGroup);
+ rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR, hitShader, hitGroup);
+ rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR, missShader, missGroup);
+ rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR, intersectionShader, hitGroup);
+
+ Move<VkPipeline> pipeline = rayTracingPipeline->createPipeline(vkd, device, pipelineLayout);
+
+ return pipeline;
+}
+
+VkImageCreateInfo makeImageCreateInfo (deUint32 width, deUint32 height, VkFormat format)
+{
+ const VkImageUsageFlags usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+ const VkImageCreateInfo imageCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (VkImageCreateFlags)0u, // VkImageCreateFlags flags;
+ VK_IMAGE_TYPE_2D, // VkImageType imageType;
+ format, // VkFormat format;
+ makeExtent3D(width, height, 1u), // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ 1u, // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ usage, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
+ };
+
+ return imageCreateInfo;
+}
+
+class RayTracingBuildTestInstance : public TestInstance
+{
+public:
+ RayTracingBuildTestInstance (Context& context, const CaseDef& data);
+ ~RayTracingBuildTestInstance (void);
+ tcu::TestStatus iterate (void);
+
+protected:
+ deUint32 validateBuffer (de::MovePtr<BufferWithMemory> buffer);
+ de::MovePtr<BufferWithMemory> runTest (void);
+
+private:
+ CaseDef m_data;
+};
+
+RayTracingBuildTestInstance::RayTracingBuildTestInstance (Context& context, const CaseDef& data)
+ : vkt::TestInstance (context)
+ , m_data (data)
+{
+}
+
+RayTracingBuildTestInstance::~RayTracingBuildTestInstance (void)
+{
+}
+
+class RayTracingTestCase : public TestCase
+{
+ public:
+ RayTracingTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
+ ~RayTracingTestCase (void);
+
+ virtual void initPrograms (SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& context) const;
+ virtual void checkSupport (Context& context) const;
+
+private:
+ CaseDef m_data;
+};
+
+RayTracingTestCase::RayTracingTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
+ : vkt::TestCase (context, name, desc)
+ , m_data (data)
+{
+}
+
+RayTracingTestCase::~RayTracingTestCase (void)
+{
+}
+
+void RayTracingTestCase::checkSupport(Context& context) const
+{
+ context.requireDeviceFunctionality("VK_EXT_robustness2");
+
+ const vk::VkPhysicalDeviceRobustness2FeaturesEXT& robustness2FeaturesEXT = context.getRobustness2FeaturesEXT();
+
+ if (!robustness2FeaturesEXT.nullDescriptor)
+ TCU_THROW(NotSupportedError, "Requires VkPhysicalDeviceRobustness2FeaturesEXT::nullDescriptor");
+}
+
+void RayTracingTestCase::initPrograms (SourceCollections& programCollection) const
+{
+ programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(getCommonRayGenerationShader()));
+
+ {
+ std::stringstream css;
+ css <<
+ "#version 460 core\n"
+ "#extension GL_EXT_nonuniform_qualifier : enable\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n"
+ "hitAttributeEXT vec3 hitAttribute;\n"
+ "void main()\n"
+ "{\n"
+ " reportIntersectionEXT(1.0f, 0);\n"
+ " uvec4 color = uvec4(1,0,0,1);\n"
+ " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n"
+ "}\n";
+
+ programCollection.glslSources.add("sect") << glu::IntersectionSource(updateRayTracingGLSL(css.str()));
+ }
+
+ {
+ std::stringstream css;
+ css <<
+ "#version 460 core\n"
+ "#extension GL_EXT_nonuniform_qualifier : enable\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ "hitAttributeEXT vec3 attribs;\n"
+ "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n"
+ "void main()\n"
+ "{\n"
+ " uvec4 color = uvec4(2,0,0,1);\n"
+ " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n"
+ "}\n";
+
+ programCollection.glslSources.add("ahit") << glu::AnyHitSource(updateRayTracingGLSL(css.str()));
+ }
+
+ {
+ std::stringstream css;
+ css <<
+ "#version 460 core\n"
+ "#extension GL_EXT_nonuniform_qualifier : enable\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "layout(location = 0) rayPayloadInEXT vec3 hitValue;\n"
+ "hitAttributeEXT vec3 attribs;\n"
+ "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n"
+ "void main()\n"
+ "{\n"
+ " uvec4 color = uvec4(3,0,0,1);\n"
+ " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n"
+ "}\n";
+
+ programCollection.glslSources.add("chit") << glu::ClosestHitSource(updateRayTracingGLSL(css.str()));
+ }
+
+ {
+ std::stringstream css;
+ css <<
+ "#version 460 core\n"
+ "#extension GL_EXT_nonuniform_qualifier : enable\n"
+ "#extension GL_EXT_ray_tracing : require\n"
+ "layout(location = 0) rayPayloadInEXT dummyPayload { vec4 dummy; };\n"
+ "layout(r32ui, set = 0, binding = 0) uniform uimage2D result;\n"
+ "void main()\n"
+ "{\n"
+ " uvec4 color = uvec4(4,0,0,1);\n"
+ " imageStore(result, ivec2(gl_LaunchIDEXT.xy), color);\n"
+ "}\n";
+
+ programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(css.str()));
+ }
+}
+
+TestInstance* RayTracingTestCase::createInstance (Context& context) const
+{
+ return new RayTracingBuildTestInstance(context, m_data);
+}
+
+de::MovePtr<BufferWithMemory> RayTracingBuildTestInstance::runTest (void)
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+ const VkQueue queue = m_context.getUniversalQueue();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const VkFormat format = VK_FORMAT_R32_UINT;
+ const deUint32 pixelCount = m_data.width * m_data.height;
+ const deUint32 shaderGroupHandleSize = getShaderGroupSize(vki, physicalDevice);
+ const deUint32 shaderGroupBaseAlignment = getShaderGroupBaseAlignment(vki, physicalDevice);
+
+ const Move<VkDescriptorSetLayout> descriptorSetLayout = DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, ALL_RAY_TRACING_STAGES)
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ALL_RAY_TRACING_STAGES)
+ .build(vkd, device);
+ const Move<VkDescriptorPool> descriptorPool = DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
+ .addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR)
+ .build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+ const Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout);
+ const Move<VkPipelineLayout> pipelineLayout = makePipelineLayout(vkd, device, descriptorSetLayout.get());
+ const Move<VkCommandPool> cmdPool = createCommandPool(vkd, device, 0, queueFamilyIndex);
+ const Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
+
+ de::MovePtr<RayTracingPipeline> rayTracingPipeline = de::newMovePtr<RayTracingPipeline>();
+ const Move<VkPipeline> pipeline = makePipeline(vkd, device, m_context.getBinaryCollection(), rayTracingPipeline, *pipelineLayout, RAYGEN_GROUP, MISS_GROUP, HIT_GROUP);
+ const de::MovePtr<BufferWithMemory> raygenShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, RAYGEN_GROUP, 1u);
+ const de::MovePtr<BufferWithMemory> missShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, MISS_GROUP, 1u);
+ const de::MovePtr<BufferWithMemory> hitShaderBindingTable = rayTracingPipeline->createShaderBindingTable(vkd, device, *pipeline, allocator, shaderGroupHandleSize, shaderGroupBaseAlignment, HIT_GROUP, 1u);
+
+ const VkStridedDeviceAddressRegionKHR raygenShaderBindingTableRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, raygenShaderBindingTable->get(), 0), 0, shaderGroupHandleSize);
+ const VkStridedDeviceAddressRegionKHR missShaderBindingTableRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, missShaderBindingTable->get(), 0), 0, shaderGroupHandleSize);
+ const VkStridedDeviceAddressRegionKHR hitShaderBindingTableRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, hitShaderBindingTable->get(), 0), 0, shaderGroupHandleSize);
+ const VkStridedDeviceAddressRegionKHR callableShaderBindingTableRegion = makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0);
+
+ const VkImageCreateInfo imageCreateInfo = makeImageCreateInfo(m_data.width, m_data.height, format);
+ const VkImageSubresourceRange imageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0, 1u);
+ const de::MovePtr<ImageWithMemory> image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
+ const Move<VkImageView> imageView = makeImageView(vkd, device, **image, VK_IMAGE_VIEW_TYPE_2D, format, imageSubresourceRange);
+
+ const VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(pixelCount*sizeof(deUint32), VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+ const VkImageSubresourceLayers bufferImageSubresourceLayers = makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u);
+ const VkBufferImageCopy bufferImageRegion = makeBufferImageCopy(makeExtent3D(m_data.width, m_data.height, 1u), bufferImageSubresourceLayers);
+ de::MovePtr<BufferWithMemory> buffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(vkd, device, allocator, bufferCreateInfo, MemoryRequirement::HostVisible));
+
+ const VkDescriptorImageInfo descriptorImageInfo = makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL);
+
+ const VkImageMemoryBarrier preImageBarrier = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+ **image, imageSubresourceRange);
+ const VkImageMemoryBarrier postImageBarrier = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
+ **image, imageSubresourceRange);
+ const VkMemoryBarrier preTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
+ const VkMemoryBarrier postTraceMemoryBarrier = makeMemoryBarrier(VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
+ const VkMemoryBarrier postCopyMemoryBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_READ_BIT, 0);
+ const VkClearValue clearValue = makeClearValueColorU32(5u, 5u, 5u, 255u);
+ const VkAccelerationStructureKHR topLevelAccelerationStructure = DE_NULL;
+
+ beginCommandBuffer(vkd, *cmdBuffer, 0u);
+ {
+ cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, &preImageBarrier);
+ vkd.cmdClearColorImage(*cmdBuffer, **image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue.color, 1, &imageSubresourceRange);
+ cmdPipelineImageMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, ALL_RAY_TRACING_STAGES, &postImageBarrier);
+
+ cmdPipelineMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, ALL_RAY_TRACING_STAGES, &preTraceMemoryBarrier);
+
+ VkWriteDescriptorSetAccelerationStructureKHR accelerationStructureWriteDescriptorSet =
+ {
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 1u, // deUint32 accelerationStructureCount;
+ &topLevelAccelerationStructure, // const VkAccelerationStructureKHR* pAccelerationStructures;
+ };
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorImageInfo)
+ .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, &accelerationStructureWriteDescriptorSet)
+ .update(vkd, device);
+
+ vkd.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *pipelineLayout, 0, 1, &descriptorSet.get(), 0, DE_NULL);
+
+ vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, *pipeline);
+
+ cmdTraceRays(vkd,
+ *cmdBuffer,
+ &raygenShaderBindingTableRegion,
+ &missShaderBindingTableRegion,
+ &hitShaderBindingTableRegion,
+ &callableShaderBindingTableRegion,
+ m_data.width, m_data.height, 1);
+
+ cmdPipelineMemoryBarrier(vkd, *cmdBuffer, ALL_RAY_TRACING_STAGES, VK_PIPELINE_STAGE_TRANSFER_BIT, &postTraceMemoryBarrier);
+
+ vkd.cmdCopyImageToBuffer(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **buffer, 1u, &bufferImageRegion);
+
+ cmdPipelineMemoryBarrier(vkd, *cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, &postCopyMemoryBarrier);
+ }
+ endCommandBuffer(vkd, *cmdBuffer);
+
+ submitCommandsAndWait(vkd, device, queue, cmdBuffer.get());
+
+ invalidateMappedMemoryRange(vkd, device, buffer->getAllocation().getMemory(), buffer->getAllocation().getOffset(), pixelCount * sizeof(deUint32));
+
+ return buffer;
+}
+
+deUint32 RayTracingBuildTestInstance::validateBuffer (de::MovePtr<BufferWithMemory> buffer)
+{
+ const deUint32* bufferPtr = (deUint32*)buffer->getAllocation().getHostPtr();
+ const deUint32 expectedValue = 4;
+ deUint32 failures = 0;
+ deUint32 pos = 0;
+
+ for (deUint32 y = 0; y < m_data.height; ++y)
+ for (deUint32 x = 0; x < m_data.width; ++x)
+ {
+ if (bufferPtr[pos] != expectedValue)
+ failures++;
+
+ ++pos;
+ }
+
+ return failures;
+}
+
+tcu::TestStatus RayTracingBuildTestInstance::iterate (void)
+{
+ de::MovePtr<BufferWithMemory> buffer = runTest();
+ const deUint32 failures = validateBuffer(buffer);
+
+ if (failures == 0)
+ return tcu::TestStatus::pass("Pass");
+ else
+ return tcu::TestStatus::fail("failures=" + de::toString(failures));
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createNullAccelerationStructureTests (tcu::TestContext& testCtx)
+{
+ de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "null_as", "Null Acceleration Structure is accepted as 'always miss' case"));
+
+ const CaseDef caseDef =
+ {
+ 8, // deUint32 width;
+ 8, // deUint32 height;
+ };
+ group->addChild(new RayTracingTestCase(testCtx, "test", "", caseDef));
+
+ return group.release();
+}
+
+} // RayTracing
+} // vkt
--- /dev/null
+#ifndef _VKTRAYTRACINGNULLASTESTS_HPP
+#define _VKTRAYTRACINGNULLASTESTS_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2020 The Khronos Group Inc.
+ *
+ * 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 Acceleration Structure Null Handle Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace RayTracing
+{
+
+tcu::TestCaseGroup* createNullAccelerationStructureTests (tcu::TestContext& testCtx);
+
+} // RayTracing
+} // vkt
+
+#endif // _VKTRAYTRACINGNULLASTESTS_HPP
#include "vktRayTracingWatertightnessTests.hpp"
#include "vktRayTracingPipelineLibraryTests.hpp"
#include "vktRayTracingMemGuaranteeTests.hpp"
+#include "vktRayTracingNullASTests.hpp"
#include "deUniquePtr.hpp"
group->addChild(createWatertightnessTests(testCtx));
group->addChild(createPipelineLibraryTests(testCtx));
group->addChild(createMemGuaranteeTests(testCtx));
+ group->addChild(createNullAccelerationStructureTests(testCtx));
return group.release();
}
dEQP-VK.ray_tracing.memguarantee.between.sect
dEQP-VK.ray_tracing.memguarantee.between.miss
dEQP-VK.ray_tracing.memguarantee.between.call
+dEQP-VK.ray_tracing.null_as.test
dEQP-VK.ray_query.builtin.flow.vert.triangles
dEQP-VK.ray_query.builtin.flow.vert.aabbs
dEQP-VK.ray_query.builtin.flow.tesc.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.top_acceleration_structure.aabbs
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.triangles
dEQP-VK.ray_query.acceleration_structures.host_threading.max.call_shader.serialization.cpu_built.bottom_acceleration_structure.aabbs
+dEQP-VK.ray_query.advanced.null_as.vert.triangles
+dEQP-VK.ray_query.advanced.null_as.vert.aabbs
+dEQP-VK.ray_query.advanced.null_as.tesc.triangles
+dEQP-VK.ray_query.advanced.null_as.tesc.aabbs
+dEQP-VK.ray_query.advanced.null_as.tese.triangles
+dEQP-VK.ray_query.advanced.null_as.tese.aabbs
+dEQP-VK.ray_query.advanced.null_as.geom.triangles
+dEQP-VK.ray_query.advanced.null_as.geom.aabbs
+dEQP-VK.ray_query.advanced.null_as.frag.triangles
+dEQP-VK.ray_query.advanced.null_as.frag.aabbs
+dEQP-VK.ray_query.advanced.null_as.comp.triangles
+dEQP-VK.ray_query.advanced.null_as.comp.aabbs
+dEQP-VK.ray_query.advanced.null_as.rgen.triangles
+dEQP-VK.ray_query.advanced.null_as.rgen.aabbs
+dEQP-VK.ray_query.advanced.null_as.ahit.triangles
+dEQP-VK.ray_query.advanced.null_as.ahit.aabbs
+dEQP-VK.ray_query.advanced.null_as.chit.triangles
+dEQP-VK.ray_query.advanced.null_as.chit.aabbs
+dEQP-VK.ray_query.advanced.null_as.miss.triangles
+dEQP-VK.ray_query.advanced.null_as.miss.aabbs
+dEQP-VK.ray_query.advanced.null_as.sect.triangles
+dEQP-VK.ray_query.advanced.null_as.sect.aabbs
+dEQP-VK.ray_query.advanced.null_as.call.triangles
+dEQP-VK.ray_query.advanced.null_as.call.aabbs
projects / platform / upstream / VK-GL-CTS.git / commitdiff