2019-03-02 22:34:11 +01:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
#include <iterator>
|
|
|
|
|
2019-03-02 22:34:11 +01:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "video_core/engines/maxwell_3d.h"
|
|
|
|
#include "video_core/renderer_vulkan/maxwell_to_vk.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_device.h"
|
2020-03-27 05:33:21 +01:00
|
|
|
#include "video_core/renderer_vulkan/wrapper.h"
|
2019-03-02 22:34:11 +01:00
|
|
|
#include "video_core/surface.h"
|
|
|
|
|
|
|
|
namespace Vulkan::MaxwellToVK {
|
|
|
|
|
2019-11-18 22:35:21 +01:00
|
|
|
using Maxwell = Tegra::Engines::Maxwell3D::Regs;
|
|
|
|
|
2019-03-02 22:34:11 +01:00
|
|
|
namespace Sampler {
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkFilter Filter(Tegra::Texture::TextureFilter filter) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (filter) {
|
|
|
|
case Tegra::Texture::TextureFilter::Linear:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FILTER_LINEAR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::TextureFilter::Nearest:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FILTER_NEAREST;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented sampler filter={}", static_cast<u32>(filter));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkSamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filter) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (mipmap_filter) {
|
|
|
|
case Tegra::Texture::TextureMipmapFilter::None:
|
|
|
|
// TODO(Rodrigo): None seems to be mapped to OpenGL's mag and min filters without mipmapping
|
|
|
|
// (e.g. GL_NEAREST and GL_LINEAR). Vulkan doesn't have such a thing, find out if we have to
|
|
|
|
// use an image view with a single mipmap level to emulate this.
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
|
|
|
;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::TextureMipmapFilter::Linear:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::TextureMipmapFilter::Nearest:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_MIPMAP_MODE_NEAREST;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented sampler mipmap mode={}", static_cast<u32>(mipmap_filter));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkSamplerAddressMode WrapMode(const VKDevice& device, Tegra::Texture::WrapMode wrap_mode,
|
|
|
|
Tegra::Texture::TextureFilter filter) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (wrap_mode) {
|
|
|
|
case Tegra::Texture::WrapMode::Wrap:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::WrapMode::Mirror:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::WrapMode::ClampToEdge:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::WrapMode::Border:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
|
2019-05-22 01:29:41 +02:00
|
|
|
case Tegra::Texture::WrapMode::Clamp:
|
2020-03-27 05:33:21 +01:00
|
|
|
if (device.GetDriverID() == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR) {
|
2020-01-10 20:48:49 +01:00
|
|
|
// Nvidia's Vulkan driver defaults to GL_CLAMP on invalid enumerations, we can hack this
|
|
|
|
// by sending an invalid enumeration.
|
2020-03-27 05:33:21 +01:00
|
|
|
return static_cast<VkSamplerAddressMode>(0xcafe);
|
2020-01-10 20:48:49 +01:00
|
|
|
}
|
|
|
|
// TODO(Rodrigo): Emulate GL_CLAMP properly on other vendors
|
2019-12-13 06:38:34 +01:00
|
|
|
switch (filter) {
|
|
|
|
case Tegra::Texture::TextureFilter::Nearest:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
2019-12-13 06:38:34 +01:00
|
|
|
case Tegra::Texture::TextureFilter::Linear:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
|
2019-12-13 06:38:34 +01:00
|
|
|
}
|
|
|
|
UNREACHABLE();
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::WrapMode::MirrorOnceClampToEdge:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::WrapMode::MirrorOnceBorder:
|
|
|
|
UNIMPLEMENTED();
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
|
2019-04-03 09:33:36 +02:00
|
|
|
default:
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented wrap mode={}", static_cast<u32>(wrap_mode));
|
|
|
|
return {};
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkCompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_func) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (depth_compare_func) {
|
|
|
|
case Tegra::Texture::DepthCompareFunc::Never:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_NEVER;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::Less:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_LESS;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::LessEqual:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_LESS_OR_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::Equal:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::NotEqual:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_NOT_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::Greater:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_GREATER;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::GreaterEqual:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_GREATER_OR_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::DepthCompareFunc::Always:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_ALWAYS;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented sampler depth compare function={}",
|
|
|
|
static_cast<u32>(depth_compare_func));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Sampler
|
|
|
|
|
2019-12-13 06:44:45 +01:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
enum : u32 { Attachable = 1, Storage = 2 };
|
|
|
|
|
2019-03-02 22:34:11 +01:00
|
|
|
struct FormatTuple {
|
2020-03-27 05:33:21 +01:00
|
|
|
VkFormat format; ///< Vulkan format
|
|
|
|
int usage = 0; ///< Describes image format usage
|
2019-12-13 06:44:45 +01:00
|
|
|
} constexpr tex_format_tuples[] = {
|
2020-03-27 05:33:21 +01:00
|
|
|
{VK_FORMAT_A8B8G8R8_UNORM_PACK32, Attachable | Storage}, // ABGR8U
|
|
|
|
{VK_FORMAT_A8B8G8R8_SNORM_PACK32, Attachable | Storage}, // ABGR8S
|
|
|
|
{VK_FORMAT_A8B8G8R8_UINT_PACK32, Attachable | Storage}, // ABGR8UI
|
|
|
|
{VK_FORMAT_B5G6R5_UNORM_PACK16}, // B5G6R5U
|
|
|
|
{VK_FORMAT_A2B10G10R10_UNORM_PACK32, Attachable | Storage}, // A2B10G10R10U
|
|
|
|
{VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable}, // A1B5G5R5U (flipped with swizzle)
|
|
|
|
{VK_FORMAT_R8_UNORM, Attachable | Storage}, // R8U
|
|
|
|
{VK_FORMAT_R8_UINT, Attachable | Storage}, // R8UI
|
|
|
|
{VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage}, // RGBA16F
|
|
|
|
{VK_FORMAT_R16G16B16A16_UNORM, Attachable | Storage}, // RGBA16U
|
|
|
|
{VK_FORMAT_R16G16B16A16_SNORM, Attachable | Storage}, // RGBA16S
|
|
|
|
{VK_FORMAT_R16G16B16A16_UINT, Attachable | Storage}, // RGBA16UI
|
|
|
|
{VK_FORMAT_B10G11R11_UFLOAT_PACK32, Attachable | Storage}, // R11FG11FB10F
|
|
|
|
{VK_FORMAT_R32G32B32A32_UINT, Attachable | Storage}, // RGBA32UI
|
|
|
|
{VK_FORMAT_BC1_RGBA_UNORM_BLOCK}, // DXT1
|
|
|
|
{VK_FORMAT_BC2_UNORM_BLOCK}, // DXT23
|
|
|
|
{VK_FORMAT_BC3_UNORM_BLOCK}, // DXT45
|
|
|
|
{VK_FORMAT_BC4_UNORM_BLOCK}, // DXN1
|
|
|
|
{VK_FORMAT_BC5_UNORM_BLOCK}, // DXN2UNORM
|
|
|
|
{VK_FORMAT_BC5_SNORM_BLOCK}, // DXN2SNORM
|
|
|
|
{VK_FORMAT_BC7_UNORM_BLOCK}, // BC7U
|
|
|
|
{VK_FORMAT_BC6H_UFLOAT_BLOCK}, // BC6H_UF16
|
|
|
|
{VK_FORMAT_BC6H_SFLOAT_BLOCK}, // BC6H_SF16
|
|
|
|
{VK_FORMAT_ASTC_4x4_UNORM_BLOCK}, // ASTC_2D_4X4
|
|
|
|
{VK_FORMAT_B8G8R8A8_UNORM}, // BGRA8
|
|
|
|
{VK_FORMAT_R32G32B32A32_SFLOAT, Attachable | Storage}, // RGBA32F
|
|
|
|
{VK_FORMAT_R32G32_SFLOAT, Attachable | Storage}, // RG32F
|
|
|
|
{VK_FORMAT_R32_SFLOAT, Attachable | Storage}, // R32F
|
|
|
|
{VK_FORMAT_R16_SFLOAT, Attachable | Storage}, // R16F
|
|
|
|
{VK_FORMAT_R16_UNORM, Attachable | Storage}, // R16U
|
|
|
|
{VK_FORMAT_UNDEFINED}, // R16S
|
|
|
|
{VK_FORMAT_UNDEFINED}, // R16UI
|
|
|
|
{VK_FORMAT_UNDEFINED}, // R16I
|
|
|
|
{VK_FORMAT_R16G16_UNORM, Attachable | Storage}, // RG16
|
|
|
|
{VK_FORMAT_R16G16_SFLOAT, Attachable | Storage}, // RG16F
|
|
|
|
{VK_FORMAT_UNDEFINED}, // RG16UI
|
|
|
|
{VK_FORMAT_UNDEFINED}, // RG16I
|
|
|
|
{VK_FORMAT_R16G16_SNORM, Attachable | Storage}, // RG16S
|
|
|
|
{VK_FORMAT_UNDEFINED}, // RGB32F
|
|
|
|
{VK_FORMAT_R8G8B8A8_SRGB, Attachable}, // RGBA8_SRGB
|
|
|
|
{VK_FORMAT_R8G8_UNORM, Attachable | Storage}, // RG8U
|
|
|
|
{VK_FORMAT_R8G8_SNORM, Attachable | Storage}, // RG8S
|
|
|
|
{VK_FORMAT_R32G32_UINT, Attachable | Storage}, // RG32UI
|
|
|
|
{VK_FORMAT_UNDEFINED}, // RGBX16F
|
|
|
|
{VK_FORMAT_R32_UINT, Attachable | Storage}, // R32UI
|
|
|
|
{VK_FORMAT_R32_SINT, Attachable | Storage}, // R32I
|
|
|
|
{VK_FORMAT_ASTC_8x8_UNORM_BLOCK}, // ASTC_2D_8X8
|
|
|
|
{VK_FORMAT_UNDEFINED}, // ASTC_2D_8X5
|
|
|
|
{VK_FORMAT_UNDEFINED}, // ASTC_2D_5X4
|
|
|
|
{VK_FORMAT_UNDEFINED}, // BGRA8_SRGB
|
|
|
|
{VK_FORMAT_BC1_RGBA_SRGB_BLOCK}, // DXT1_SRGB
|
|
|
|
{VK_FORMAT_BC2_SRGB_BLOCK}, // DXT23_SRGB
|
|
|
|
{VK_FORMAT_BC3_SRGB_BLOCK}, // DXT45_SRGB
|
|
|
|
{VK_FORMAT_BC7_SRGB_BLOCK}, // BC7U_SRGB
|
|
|
|
{VK_FORMAT_R4G4B4A4_UNORM_PACK16, Attachable}, // R4G4B4A4U
|
|
|
|
{VK_FORMAT_ASTC_4x4_SRGB_BLOCK}, // ASTC_2D_4X4_SRGB
|
|
|
|
{VK_FORMAT_ASTC_8x8_SRGB_BLOCK}, // ASTC_2D_8X8_SRGB
|
|
|
|
{VK_FORMAT_ASTC_8x5_SRGB_BLOCK}, // ASTC_2D_8X5_SRGB
|
|
|
|
{VK_FORMAT_ASTC_5x4_SRGB_BLOCK}, // ASTC_2D_5X4_SRGB
|
|
|
|
{VK_FORMAT_ASTC_5x5_UNORM_BLOCK}, // ASTC_2D_5X5
|
|
|
|
{VK_FORMAT_ASTC_5x5_SRGB_BLOCK}, // ASTC_2D_5X5_SRGB
|
|
|
|
{VK_FORMAT_ASTC_10x8_UNORM_BLOCK}, // ASTC_2D_10X8
|
|
|
|
{VK_FORMAT_ASTC_10x8_SRGB_BLOCK}, // ASTC_2D_10X8_SRGB
|
|
|
|
{VK_FORMAT_ASTC_6x6_UNORM_BLOCK}, // ASTC_2D_6X6
|
|
|
|
{VK_FORMAT_ASTC_6x6_SRGB_BLOCK}, // ASTC_2D_6X6_SRGB
|
|
|
|
{VK_FORMAT_ASTC_10x10_UNORM_BLOCK}, // ASTC_2D_10X10
|
|
|
|
{VK_FORMAT_ASTC_10x10_SRGB_BLOCK}, // ASTC_2D_10X10_SRGB
|
|
|
|
{VK_FORMAT_ASTC_12x12_UNORM_BLOCK}, // ASTC_2D_12X12
|
|
|
|
{VK_FORMAT_ASTC_12x12_SRGB_BLOCK}, // ASTC_2D_12X12_SRGB
|
|
|
|
{VK_FORMAT_ASTC_8x6_UNORM_BLOCK}, // ASTC_2D_8X6
|
|
|
|
{VK_FORMAT_ASTC_8x6_SRGB_BLOCK}, // ASTC_2D_8X6_SRGB
|
|
|
|
{VK_FORMAT_ASTC_6x5_UNORM_BLOCK}, // ASTC_2D_6X5
|
|
|
|
{VK_FORMAT_ASTC_6x5_SRGB_BLOCK}, // ASTC_2D_6X5_SRGB
|
|
|
|
{VK_FORMAT_E5B9G9R9_UFLOAT_PACK32}, // E5B9G9R9F
|
2019-03-02 22:34:11 +01:00
|
|
|
|
|
|
|
// Depth formats
|
2020-03-27 05:33:21 +01:00
|
|
|
{VK_FORMAT_D32_SFLOAT, Attachable}, // Z32F
|
|
|
|
{VK_FORMAT_D16_UNORM, Attachable}, // Z16
|
2019-03-02 22:34:11 +01:00
|
|
|
|
|
|
|
// DepthStencil formats
|
2020-03-27 05:33:21 +01:00
|
|
|
{VK_FORMAT_D24_UNORM_S8_UINT, Attachable}, // Z24S8
|
|
|
|
{VK_FORMAT_D24_UNORM_S8_UINT, Attachable}, // S8Z24 (emulated)
|
|
|
|
{VK_FORMAT_D32_SFLOAT_S8_UINT, Attachable}, // Z32FS8
|
2019-12-13 06:44:45 +01:00
|
|
|
};
|
|
|
|
static_assert(std::size(tex_format_tuples) == VideoCore::Surface::MaxPixelFormat);
|
2019-03-02 22:34:11 +01:00
|
|
|
|
2019-12-13 06:44:45 +01:00
|
|
|
constexpr bool IsZetaFormat(PixelFormat pixel_format) {
|
2019-03-02 22:34:11 +01:00
|
|
|
return pixel_format >= PixelFormat::MaxColorFormat &&
|
|
|
|
pixel_format < PixelFormat::MaxDepthStencilFormat;
|
|
|
|
}
|
|
|
|
|
2019-12-13 06:44:45 +01:00
|
|
|
} // Anonymous namespace
|
2019-03-02 22:34:11 +01:00
|
|
|
|
2019-12-13 06:44:45 +01:00
|
|
|
FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFormat pixel_format) {
|
|
|
|
ASSERT(static_cast<std::size_t>(pixel_format) < std::size(tex_format_tuples));
|
2019-03-02 22:34:11 +01:00
|
|
|
|
2019-12-13 06:44:45 +01:00
|
|
|
auto tuple = tex_format_tuples[static_cast<std::size_t>(pixel_format)];
|
2020-03-27 05:33:21 +01:00
|
|
|
if (tuple.format == VK_FORMAT_UNDEFINED) {
|
2019-12-13 06:44:45 +01:00
|
|
|
UNIMPLEMENTED_MSG("Unimplemented texture format with pixel format={}",
|
|
|
|
static_cast<u32>(pixel_format));
|
2020-03-27 05:33:21 +01:00
|
|
|
return {VK_FORMAT_A8B8G8R8_UNORM_PACK32, true, true};
|
2019-12-13 06:44:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Use ABGR8 on hardware that doesn't support ASTC natively
|
|
|
|
if (!device.IsOptimalAstcSupported() && VideoCore::Surface::IsPixelFormatASTC(pixel_format)) {
|
|
|
|
tuple.format = VideoCore::Surface::IsPixelFormatSRGB(pixel_format)
|
2020-03-27 05:33:21 +01:00
|
|
|
? VK_FORMAT_A8B8G8R8_SRGB_PACK32
|
|
|
|
: VK_FORMAT_A8B8G8R8_UNORM_PACK32;
|
2019-12-13 06:44:45 +01:00
|
|
|
}
|
|
|
|
const bool attachable = tuple.usage & Attachable;
|
|
|
|
const bool storage = tuple.usage & Storage;
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkFormatFeatureFlags usage;
|
2019-12-13 06:44:45 +01:00
|
|
|
if (format_type == FormatType::Buffer) {
|
2020-03-27 05:33:21 +01:00
|
|
|
usage =
|
|
|
|
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
|
2019-12-13 06:44:45 +01:00
|
|
|
} else {
|
2020-03-27 05:33:21 +01:00
|
|
|
usage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
|
|
|
|
VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
|
2019-12-13 06:44:45 +01:00
|
|
|
if (attachable) {
|
2020-03-27 05:33:21 +01:00
|
|
|
usage |= IsZetaFormat(pixel_format) ? VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
|
|
|
|
: VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
|
2019-12-13 06:44:45 +01:00
|
|
|
}
|
|
|
|
if (storage) {
|
2020-03-27 05:33:21 +01:00
|
|
|
usage |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
|
2019-12-13 06:44:45 +01:00
|
|
|
}
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
2019-12-13 06:44:45 +01:00
|
|
|
return {device.GetSupportedFormat(tuple.format, usage, format_type), attachable, storage};
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (stage) {
|
2019-11-18 22:35:21 +01:00
|
|
|
case Tegra::Engines::ShaderType::Vertex:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_VERTEX_BIT;
|
2019-11-18 22:35:21 +01:00
|
|
|
case Tegra::Engines::ShaderType::TesselationControl:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
|
2019-11-18 22:35:21 +01:00
|
|
|
case Tegra::Engines::ShaderType::TesselationEval:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
|
2019-11-18 22:35:21 +01:00
|
|
|
case Tegra::Engines::ShaderType::Geometry:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_GEOMETRY_BIT;
|
2019-11-18 22:35:21 +01:00
|
|
|
case Tegra::Engines::ShaderType::Fragment:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_FRAGMENT_BIT;
|
2020-03-18 21:32:39 +01:00
|
|
|
case Tegra::Engines::ShaderType::Compute:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_SHADER_STAGE_COMPUTE_BIT;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented shader stage={}", static_cast<u32>(stage));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
|
|
|
|
Maxwell::PrimitiveTopology topology) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (topology) {
|
|
|
|
case Maxwell::PrimitiveTopology::Points:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::PrimitiveTopology::Lines:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::PrimitiveTopology::LineStrip:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::PrimitiveTopology::Triangles:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::PrimitiveTopology::TriangleStrip:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
|
2019-12-13 06:41:29 +01:00
|
|
|
case Maxwell::PrimitiveTopology::TriangleFan:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
|
2019-12-13 06:41:29 +01:00
|
|
|
case Maxwell::PrimitiveTopology::Quads:
|
|
|
|
// TODO(Rodrigo): Use VK_PRIMITIVE_TOPOLOGY_QUAD_LIST_EXT whenever it releases
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
2019-12-13 06:41:29 +01:00
|
|
|
case Maxwell::PrimitiveTopology::Patches:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
|
2019-04-03 09:33:36 +02:00
|
|
|
default:
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented topology={}", static_cast<u32>(topology));
|
|
|
|
return {};
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (type) {
|
|
|
|
case Maxwell::VertexAttribute::Type::SignedNorm:
|
2019-12-13 06:43:59 +01:00
|
|
|
switch (size) {
|
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_SNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
|
2019-12-13 06:43:59 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2019-03-02 22:34:11 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedNorm:
|
|
|
|
switch (size) {
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_UNORM;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16_UNORM;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_UNORM;
|
2020-03-13 11:26:13 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
|
2020-03-13 11:37:24 +01:00
|
|
|
default:
|
2019-03-02 22:34:11 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Maxwell::VertexAttribute::Type::SignedInt:
|
2019-12-13 06:43:59 +01:00
|
|
|
switch (size) {
|
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32_SINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2020-04-15 09:05:33 +02:00
|
|
|
break;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedInt:
|
|
|
|
switch (size) {
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_UINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_UINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_UINT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_UINT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32_UINT;
|
2020-03-15 22:51:49 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32_UINT;
|
2020-03-15 22:51:49 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32B32_UINT;
|
2020-02-18 15:52:51 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32B32A32_UINT;
|
2019-03-02 22:34:11 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2020-04-15 09:05:33 +02:00
|
|
|
break;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedScaled:
|
2019-12-13 06:43:59 +01:00
|
|
|
switch (size) {
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_USCALED;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16_USCALED;
|
2020-02-23 21:45:58 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_USCALED;
|
2019-12-13 06:43:59 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::VertexAttribute::Type::SignedScaled:
|
2020-03-27 00:14:19 +01:00
|
|
|
switch (size) {
|
|
|
|
case Maxwell::VertexAttribute::Size::Size_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R8G8B8A8_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_SSCALED;
|
2020-03-27 00:14:19 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2019-03-02 22:34:11 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::VertexAttribute::Type::Float:
|
|
|
|
switch (size) {
|
|
|
|
case Maxwell::VertexAttribute::Size::Size_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32B32_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R32G32B32A32_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16_SFLOAT;
|
2019-12-13 06:43:59 +01:00
|
|
|
case Maxwell::VertexAttribute::Size::Size_16_16_16_16:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FORMAT_R16G16B16A16_SFLOAT;
|
2019-03-02 22:34:11 +01:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented vertex format of type={} and size={}", static_cast<u32>(type),
|
|
|
|
static_cast<u32>(size));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkCompareOp ComparisonOp(Maxwell::ComparisonOp comparison) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (comparison) {
|
|
|
|
case Maxwell::ComparisonOp::Never:
|
|
|
|
case Maxwell::ComparisonOp::NeverOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_NEVER;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::Less:
|
|
|
|
case Maxwell::ComparisonOp::LessOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_LESS;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::Equal:
|
|
|
|
case Maxwell::ComparisonOp::EqualOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::LessEqual:
|
|
|
|
case Maxwell::ComparisonOp::LessEqualOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_LESS_OR_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::Greater:
|
|
|
|
case Maxwell::ComparisonOp::GreaterOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_GREATER;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::NotEqual:
|
|
|
|
case Maxwell::ComparisonOp::NotEqualOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_NOT_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::GreaterEqual:
|
|
|
|
case Maxwell::ComparisonOp::GreaterEqualOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_GREATER_OR_EQUAL;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::ComparisonOp::Always:
|
|
|
|
case Maxwell::ComparisonOp::AlwaysOld:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPARE_OP_ALWAYS;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented comparison op={}", static_cast<u32>(comparison));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkIndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_format) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (index_format) {
|
|
|
|
case Maxwell::IndexFormat::UnsignedByte:
|
2019-12-13 06:37:23 +01:00
|
|
|
if (!device.IsExtIndexTypeUint8Supported()) {
|
|
|
|
UNIMPLEMENTED_MSG("Native uint8 indices are not supported on this device");
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_INDEX_TYPE_UINT16;
|
2019-12-13 06:37:23 +01:00
|
|
|
}
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_INDEX_TYPE_UINT8_EXT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::IndexFormat::UnsignedShort:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_INDEX_TYPE_UINT16;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::IndexFormat::UnsignedInt:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_INDEX_TYPE_UINT32;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented index_format={}", static_cast<u32>(index_format));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkStencilOp StencilOp(Maxwell::StencilOp stencil_op) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (stencil_op) {
|
|
|
|
case Maxwell::StencilOp::Keep:
|
|
|
|
case Maxwell::StencilOp::KeepOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_KEEP;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::Zero:
|
|
|
|
case Maxwell::StencilOp::ZeroOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_ZERO;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::Replace:
|
|
|
|
case Maxwell::StencilOp::ReplaceOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_REPLACE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::Incr:
|
|
|
|
case Maxwell::StencilOp::IncrOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::Decr:
|
|
|
|
case Maxwell::StencilOp::DecrOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::Invert:
|
|
|
|
case Maxwell::StencilOp::InvertOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_INVERT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::IncrWrap:
|
|
|
|
case Maxwell::StencilOp::IncrWrapOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_INCREMENT_AND_WRAP;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::StencilOp::DecrWrap:
|
|
|
|
case Maxwell::StencilOp::DecrWrapOGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_STENCIL_OP_DECREMENT_AND_WRAP;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented stencil op={}", static_cast<u32>(stencil_op));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkBlendOp BlendEquation(Maxwell::Blend::Equation equation) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (equation) {
|
|
|
|
case Maxwell::Blend::Equation::Add:
|
|
|
|
case Maxwell::Blend::Equation::AddGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_OP_ADD;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Equation::Subtract:
|
|
|
|
case Maxwell::Blend::Equation::SubtractGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_OP_SUBTRACT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Equation::ReverseSubtract:
|
|
|
|
case Maxwell::Blend::Equation::ReverseSubtractGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_OP_REVERSE_SUBTRACT;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Equation::Min:
|
|
|
|
case Maxwell::Blend::Equation::MinGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_OP_MIN;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Equation::Max:
|
|
|
|
case Maxwell::Blend::Equation::MaxGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_OP_MAX;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented blend equation={}", static_cast<u32>(equation));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkBlendFactor BlendFactor(Maxwell::Blend::Factor factor) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (factor) {
|
|
|
|
case Maxwell::Blend::Factor::Zero:
|
|
|
|
case Maxwell::Blend::Factor::ZeroGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ZERO;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::One:
|
|
|
|
case Maxwell::Blend::Factor::OneGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::SourceColor:
|
|
|
|
case Maxwell::Blend::Factor::SourceColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_SRC_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusSourceColor:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusSourceColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::SourceAlpha:
|
|
|
|
case Maxwell::Blend::Factor::SourceAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_SRC_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusSourceAlpha:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusSourceAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::DestAlpha:
|
|
|
|
case Maxwell::Blend::Factor::DestAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_DST_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusDestAlpha:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusDestAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::DestColor:
|
|
|
|
case Maxwell::Blend::Factor::DestColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_DST_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusDestColor:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusDestColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::SourceAlphaSaturate:
|
|
|
|
case Maxwell::Blend::Factor::SourceAlphaSaturateGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::Source1Color:
|
|
|
|
case Maxwell::Blend::Factor::Source1ColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_SRC1_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusSource1Color:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusSource1ColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::Source1Alpha:
|
|
|
|
case Maxwell::Blend::Factor::Source1AlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_SRC1_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusSource1Alpha:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusSource1AlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::ConstantColor:
|
|
|
|
case Maxwell::Blend::Factor::ConstantColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_CONSTANT_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusConstantColor:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusConstantColorGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::ConstantAlpha:
|
|
|
|
case Maxwell::Blend::Factor::ConstantAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_CONSTANT_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Maxwell::Blend::Factor::OneMinusConstantAlpha:
|
|
|
|
case Maxwell::Blend::Factor::OneMinusConstantAlphaGL:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented blend factor={}", static_cast<u32>(factor));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkFrontFace FrontFace(Maxwell::FrontFace front_face) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (front_face) {
|
2019-12-29 01:41:41 +01:00
|
|
|
case Maxwell::FrontFace::ClockWise:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FRONT_FACE_CLOCKWISE;
|
2019-12-29 01:41:41 +01:00
|
|
|
case Maxwell::FrontFace::CounterClockWise:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented front face={}", static_cast<u32>(front_face));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkCullModeFlags CullFace(Maxwell::CullFace cull_face) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (cull_face) {
|
2019-12-29 01:41:41 +01:00
|
|
|
case Maxwell::CullFace::Front:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_CULL_MODE_FRONT_BIT;
|
2019-12-29 01:41:41 +01:00
|
|
|
case Maxwell::CullFace::Back:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_CULL_MODE_BACK_BIT;
|
2019-12-29 01:41:41 +01:00
|
|
|
case Maxwell::CullFace::FrontAndBack:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_CULL_MODE_FRONT_AND_BACK;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented cull face={}", static_cast<u32>(cull_face));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-03-27 05:33:21 +01:00
|
|
|
VkComponentSwizzle SwizzleSource(Tegra::Texture::SwizzleSource swizzle) {
|
2019-03-02 22:34:11 +01:00
|
|
|
switch (swizzle) {
|
|
|
|
case Tegra::Texture::SwizzleSource::Zero:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_ZERO;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::SwizzleSource::R:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_R;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::SwizzleSource::G:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_G;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::SwizzleSource::B:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_B;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::SwizzleSource::A:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_A;
|
2019-03-02 22:34:11 +01:00
|
|
|
case Tegra::Texture::SwizzleSource::OneInt:
|
|
|
|
case Tegra::Texture::SwizzleSource::OneFloat:
|
2020-03-27 05:33:21 +01:00
|
|
|
return VK_COMPONENT_SWIZZLE_ONE;
|
2019-03-02 22:34:11 +01:00
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented swizzle source={}", static_cast<u32>(swizzle));
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Vulkan::MaxwellToVK
|