You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
127 lines
5.0 KiB
127 lines
5.0 KiB
// VK tests
|
|
//
|
|
// Copyright (c) 2015-2019 The Khronos Group Inc.
|
|
// Copyright (c) 2015-2019 Valve Corporation
|
|
// Copyright (c) 2015-2019 LunarG, Inc.
|
|
// Copyright (c) 2015-2019 Google, 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.
|
|
|
|
#include "vktestframeworkandroid.h"
|
|
#include "shaderc/shaderc.hpp"
|
|
#include <android/log.h>
|
|
|
|
VkTestFramework::VkTestFramework() {}
|
|
VkTestFramework::~VkTestFramework() {}
|
|
|
|
// Define static elements
|
|
bool VkTestFramework::m_devsim_layer = false;
|
|
bool VkTestFramework::m_khronos_layer_disable = false;
|
|
ANativeWindow *VkTestFramework::window = nullptr;
|
|
|
|
VkFormat VkTestFramework::GetFormat(VkInstance instance, vk_testing::Device *device) {
|
|
VkFormatProperties format_props;
|
|
vkGetPhysicalDeviceFormatProperties(device->phy().handle(), VK_FORMAT_B8G8R8A8_UNORM, &format_props);
|
|
if (format_props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT ||
|
|
format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
|
|
return VK_FORMAT_B8G8R8A8_UNORM;
|
|
}
|
|
vkGetPhysicalDeviceFormatProperties(device->phy().handle(), VK_FORMAT_R8G8B8A8_UNORM, &format_props);
|
|
if (format_props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT ||
|
|
format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
|
|
return VK_FORMAT_R8G8B8A8_UNORM;
|
|
}
|
|
printf("Error - device does not support VK_FORMAT_B8G8R8A8_UNORM nor VK_FORMAT_R8G8B8A8_UNORM - exiting\n");
|
|
exit(0);
|
|
}
|
|
|
|
void VkTestFramework::InitArgs(int *argc, char *argv[]) {}
|
|
void VkTestFramework::Finish() {}
|
|
|
|
void TestEnvironment::SetUp() { vk_testing::set_error_callback(test_error_callback); }
|
|
|
|
void TestEnvironment::TearDown() {}
|
|
|
|
// Android specific helper functions for shaderc.
|
|
struct shader_type_mapping {
|
|
VkShaderStageFlagBits vkshader_type;
|
|
shaderc_shader_kind shaderc_type;
|
|
};
|
|
|
|
static const shader_type_mapping shader_map_table[] = {
|
|
{VK_SHADER_STAGE_VERTEX_BIT, shaderc_glsl_vertex_shader},
|
|
{VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, shaderc_glsl_tess_control_shader},
|
|
{VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, shaderc_glsl_tess_evaluation_shader},
|
|
{VK_SHADER_STAGE_GEOMETRY_BIT, shaderc_glsl_geometry_shader},
|
|
{VK_SHADER_STAGE_FRAGMENT_BIT, shaderc_glsl_fragment_shader},
|
|
{VK_SHADER_STAGE_COMPUTE_BIT, shaderc_glsl_compute_shader},
|
|
};
|
|
|
|
shaderc_shader_kind MapShadercType(VkShaderStageFlagBits vkShader) {
|
|
for (auto shader : shader_map_table) {
|
|
if (shader.vkshader_type == vkShader) {
|
|
return shader.shaderc_type;
|
|
}
|
|
}
|
|
assert(false);
|
|
return shaderc_glsl_infer_from_source;
|
|
}
|
|
|
|
// Compile a given string containing GLSL into SPIR-V
|
|
// Return value of false means an error was encountered
|
|
bool VkTestFramework::GLSLtoSPV(const VkShaderStageFlagBits shader_type, const char *pshader, std::vector<unsigned int> &spirv,
|
|
bool debug) {
|
|
// On Android, use shaderc instead.
|
|
shaderc::Compiler compiler;
|
|
shaderc::CompileOptions options;
|
|
if (debug) {
|
|
options.SetOptimizationLevel(shaderc_optimization_level_zero);
|
|
options.SetGenerateDebugInfo();
|
|
}
|
|
shaderc::SpvCompilationResult result =
|
|
compiler.CompileGlslToSpv(pshader, strlen(pshader), MapShadercType(shader_type), "shader", options);
|
|
if (result.GetCompilationStatus() != shaderc_compilation_status_success) {
|
|
__android_log_print(ANDROID_LOG_ERROR, "VkLayerValidationTests", "GLSLtoSPV compilation failed: %s",
|
|
result.GetErrorMessage().c_str());
|
|
return false;
|
|
}
|
|
|
|
for (auto iter = result.begin(); iter != result.end(); iter++) {
|
|
spirv.push_back(*iter);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Compile a given string containing SPIR-V assembly into SPV for use by VK
|
|
// Return value of false means an error was encountered.
|
|
//
|
|
bool VkTestFramework::ASMtoSPV(const spv_target_env target_env, const uint32_t options, const char *pasm,
|
|
std::vector<unsigned int> &spv) {
|
|
spv_binary binary;
|
|
spv_diagnostic diagnostic = nullptr;
|
|
spv_context context = spvContextCreate(target_env);
|
|
spv_result_t error = spvTextToBinaryWithOptions(context, pasm, strlen(pasm), options, &binary, &diagnostic);
|
|
spvContextDestroy(context);
|
|
if (error) {
|
|
__android_log_print(ANDROID_LOG_ERROR, "VkLayerValidationTest", "ASMtoSPV compilation failed");
|
|
spvDiagnosticDestroy(diagnostic);
|
|
return false;
|
|
}
|
|
spv.insert(spv.end(), binary->code, binary->code + binary->wordCount);
|
|
spvBinaryDestroy(binary);
|
|
|
|
return true;
|
|
}
|