2020-01-07 01:18:38 +01:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2020-01-07 01:55:06 +01:00
|
|
|
#include <algorithm>
|
2020-01-07 01:18:38 +01:00
|
|
|
#include <cstddef>
|
2021-03-23 01:03:20 +01:00
|
|
|
#include <fstream>
|
2020-01-07 01:55:06 +01:00
|
|
|
#include <memory>
|
2021-04-05 08:56:58 +02:00
|
|
|
#include <thread>
|
2020-01-07 01:18:38 +01:00
|
|
|
#include <vector>
|
|
|
|
|
2020-11-25 06:33:20 +01:00
|
|
|
#include "common/bit_cast.h"
|
2020-12-30 06:25:23 +01:00
|
|
|
#include "common/cityhash.h"
|
2021-03-23 01:03:20 +01:00
|
|
|
#include "common/file_util.h"
|
2020-01-07 01:55:06 +01:00
|
|
|
#include "common/microprofile.h"
|
2021-03-23 01:03:20 +01:00
|
|
|
#include "common/thread_worker.h"
|
2020-01-07 01:55:06 +01:00
|
|
|
#include "core/core.h"
|
|
|
|
#include "core/memory.h"
|
2021-03-19 23:28:31 +01:00
|
|
|
#include "shader_recompiler/backend/spirv/emit_spirv.h"
|
2021-02-17 04:59:28 +01:00
|
|
|
#include "shader_recompiler/environment.h"
|
2021-03-19 23:28:31 +01:00
|
|
|
#include "shader_recompiler/frontend/maxwell/control_flow.h"
|
|
|
|
#include "shader_recompiler/frontend/maxwell/program.h"
|
|
|
|
#include "shader_recompiler/program_header.h"
|
2021-04-24 23:27:25 +02:00
|
|
|
#include "video_core/dirty_flags.h"
|
2020-01-07 01:55:06 +01:00
|
|
|
#include "video_core/engines/kepler_compute.h"
|
|
|
|
#include "video_core/engines/maxwell_3d.h"
|
|
|
|
#include "video_core/memory_manager.h"
|
|
|
|
#include "video_core/renderer_vulkan/fixed_pipeline_state.h"
|
|
|
|
#include "video_core/renderer_vulkan/maxwell_to_vk.h"
|
2021-03-26 22:45:38 +01:00
|
|
|
#include "video_core/renderer_vulkan/pipeline_helper.h"
|
2020-01-07 01:55:06 +01:00
|
|
|
#include "video_core/renderer_vulkan/vk_compute_pipeline.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_descriptor_pool.h"
|
2020-01-07 01:18:38 +01:00
|
|
|
#include "video_core/renderer_vulkan/vk_pipeline_cache.h"
|
2020-01-07 01:55:06 +01:00
|
|
|
#include "video_core/renderer_vulkan/vk_rasterizer.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
2021-02-17 04:59:28 +01:00
|
|
|
#include "video_core/renderer_vulkan/vk_shader_util.h"
|
2020-01-07 01:18:38 +01:00
|
|
|
#include "video_core/renderer_vulkan/vk_update_descriptor.h"
|
2020-05-23 02:01:36 +02:00
|
|
|
#include "video_core/shader_cache.h"
|
2020-08-02 19:05:41 +02:00
|
|
|
#include "video_core/shader_notify.h"
|
2020-12-26 05:19:46 +01:00
|
|
|
#include "video_core/vulkan_common/vulkan_device.h"
|
2020-12-25 01:30:11 +01:00
|
|
|
#include "video_core/vulkan_common/vulkan_wrapper.h"
|
2020-01-07 01:18:38 +01:00
|
|
|
|
|
|
|
namespace Vulkan {
|
2020-01-07 01:55:06 +01:00
|
|
|
MICROPROFILE_DECLARE(Vulkan_PipelineCache);
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
template <typename Container>
|
|
|
|
auto MakeSpan(Container& container) {
|
|
|
|
return std::span(container.data(), container.size());
|
|
|
|
}
|
2021-03-19 23:28:31 +01:00
|
|
|
|
2021-04-06 04:25:22 +02:00
|
|
|
static u64 MakeCbufKey(u32 index, u32 offset) {
|
2021-03-27 22:30:24 +01:00
|
|
|
return (static_cast<u64>(index) << 32) | offset;
|
2021-03-26 22:45:38 +01:00
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
class GenericEnvironment : public Shader::Environment {
|
2021-02-17 04:59:28 +01:00
|
|
|
public:
|
2021-03-19 23:28:31 +01:00
|
|
|
explicit GenericEnvironment() = default;
|
2021-03-23 01:03:20 +01:00
|
|
|
explicit GenericEnvironment(Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_,
|
|
|
|
u32 start_address_)
|
|
|
|
: gpu_memory{&gpu_memory_}, program_base{program_base_} {
|
|
|
|
start_address = start_address_;
|
|
|
|
}
|
2021-02-17 04:59:28 +01:00
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
~GenericEnvironment() override = default;
|
2021-02-17 04:59:28 +01:00
|
|
|
|
2021-04-01 09:09:09 +02:00
|
|
|
u32 TextureBoundBuffer() const final {
|
|
|
|
return texture_bound;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 LocalMemorySize() const final {
|
|
|
|
return local_memory_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 SharedMemorySize() const final {
|
|
|
|
return shared_memory_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::array<u32, 3> WorkgroupSize() const final {
|
|
|
|
return workgroup_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 ReadInstruction(u32 address) final {
|
|
|
|
read_lowest = std::min(read_lowest, address);
|
|
|
|
read_highest = std::max(read_highest, address);
|
|
|
|
|
|
|
|
if (address >= cached_lowest && address < cached_highest) {
|
|
|
|
return code[(address - cached_lowest) / INST_SIZE];
|
|
|
|
}
|
|
|
|
has_unbound_instructions = true;
|
|
|
|
return gpu_memory->Read<u64>(program_base + address);
|
|
|
|
}
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
std::optional<u128> Analyze() {
|
2021-03-27 06:56:09 +01:00
|
|
|
const std::optional<u64> size{TryFindSize()};
|
2021-02-17 04:59:28 +01:00
|
|
|
if (!size) {
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
cached_lowest = start_address;
|
|
|
|
cached_highest = start_address + static_cast<u32>(*size);
|
2021-03-29 02:55:47 +02:00
|
|
|
return Common::CityHash128(reinterpret_cast<const char*>(code.data()), *size);
|
2021-02-17 04:59:28 +01:00
|
|
|
}
|
2020-01-07 01:55:06 +01:00
|
|
|
|
2021-03-27 06:56:09 +01:00
|
|
|
void SetCachedSize(size_t size_bytes) {
|
|
|
|
cached_lowest = start_address;
|
|
|
|
cached_highest = start_address + static_cast<u32>(size_bytes);
|
|
|
|
code.resize(CachedSize());
|
|
|
|
gpu_memory->ReadBlock(program_base + cached_lowest, code.data(), code.size() * sizeof(u64));
|
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
[[nodiscard]] size_t CachedSize() const noexcept {
|
|
|
|
return cached_highest - cached_lowest + INST_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
[[nodiscard]] size_t ReadSize() const noexcept {
|
2021-02-17 04:59:28 +01:00
|
|
|
return read_highest - read_lowest + INST_SIZE;
|
|
|
|
}
|
2020-01-07 01:55:06 +01:00
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
[[nodiscard]] bool CanBeSerialized() const noexcept {
|
2021-03-27 06:56:09 +01:00
|
|
|
return !has_unbound_instructions;
|
2021-03-23 01:03:20 +01:00
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
[[nodiscard]] u128 CalculateHash() const {
|
|
|
|
const size_t size{ReadSize()};
|
2021-03-23 01:03:20 +01:00
|
|
|
const auto data{std::make_unique<char[]>(size)};
|
2021-03-19 23:28:31 +01:00
|
|
|
gpu_memory->ReadBlock(program_base + read_lowest, data.get(), size);
|
2021-03-23 01:03:20 +01:00
|
|
|
return Common::CityHash128(data.get(), size);
|
2020-01-07 01:55:06 +01:00
|
|
|
}
|
2021-02-17 04:59:28 +01:00
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
void Serialize(std::ofstream& file) const {
|
2021-04-01 09:09:09 +02:00
|
|
|
const u64 code_size{static_cast<u64>(CachedSize())};
|
2021-03-26 22:45:38 +01:00
|
|
|
const u64 num_texture_types{static_cast<u64>(texture_types.size())};
|
2021-03-27 22:30:24 +01:00
|
|
|
const u64 num_cbuf_values{static_cast<u64>(cbuf_values.size())};
|
2021-03-23 01:03:20 +01:00
|
|
|
|
|
|
|
file.write(reinterpret_cast<const char*>(&code_size), sizeof(code_size))
|
2021-03-26 22:45:38 +01:00
|
|
|
.write(reinterpret_cast<const char*>(&num_texture_types), sizeof(num_texture_types))
|
2021-03-27 22:30:24 +01:00
|
|
|
.write(reinterpret_cast<const char*>(&num_cbuf_values), sizeof(num_cbuf_values))
|
2021-03-29 00:53:34 +02:00
|
|
|
.write(reinterpret_cast<const char*>(&local_memory_size), sizeof(local_memory_size))
|
2021-03-23 01:03:20 +01:00
|
|
|
.write(reinterpret_cast<const char*>(&texture_bound), sizeof(texture_bound))
|
|
|
|
.write(reinterpret_cast<const char*>(&start_address), sizeof(start_address))
|
2021-04-01 09:09:09 +02:00
|
|
|
.write(reinterpret_cast<const char*>(&cached_lowest), sizeof(cached_lowest))
|
|
|
|
.write(reinterpret_cast<const char*>(&cached_highest), sizeof(cached_highest))
|
2021-03-23 01:03:20 +01:00
|
|
|
.write(reinterpret_cast<const char*>(&stage), sizeof(stage))
|
2021-04-01 09:09:09 +02:00
|
|
|
.write(reinterpret_cast<const char*>(code.data()), code_size);
|
2021-03-26 22:45:38 +01:00
|
|
|
for (const auto [key, type] : texture_types) {
|
|
|
|
file.write(reinterpret_cast<const char*>(&key), sizeof(key))
|
|
|
|
.write(reinterpret_cast<const char*>(&type), sizeof(type));
|
|
|
|
}
|
2021-03-27 22:30:24 +01:00
|
|
|
for (const auto [key, type] : cbuf_values) {
|
|
|
|
file.write(reinterpret_cast<const char*>(&key), sizeof(key))
|
|
|
|
.write(reinterpret_cast<const char*>(&type), sizeof(type));
|
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
if (stage == Shader::Stage::Compute) {
|
2021-03-29 00:53:34 +02:00
|
|
|
file.write(reinterpret_cast<const char*>(&workgroup_size), sizeof(workgroup_size))
|
|
|
|
.write(reinterpret_cast<const char*>(&shared_memory_size),
|
|
|
|
sizeof(shared_memory_size));
|
2021-03-23 01:03:20 +01:00
|
|
|
} else {
|
|
|
|
file.write(reinterpret_cast<const char*>(&sph), sizeof(sph));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
protected:
|
2021-02-17 04:59:28 +01:00
|
|
|
static constexpr size_t INST_SIZE = sizeof(u64);
|
|
|
|
|
2021-03-27 06:56:09 +01:00
|
|
|
std::optional<u64> TryFindSize() {
|
2021-03-19 23:28:31 +01:00
|
|
|
constexpr size_t BLOCK_SIZE = 0x1000;
|
|
|
|
constexpr size_t MAXIMUM_SIZE = 0x100000;
|
|
|
|
|
|
|
|
constexpr u64 SELF_BRANCH_A = 0xE2400FFFFF87000FULL;
|
|
|
|
constexpr u64 SELF_BRANCH_B = 0xE2400FFFFF07000FULL;
|
2021-02-17 04:59:28 +01:00
|
|
|
|
2021-03-27 06:56:09 +01:00
|
|
|
GPUVAddr guest_addr{program_base + start_address};
|
|
|
|
size_t offset{0};
|
|
|
|
size_t size{BLOCK_SIZE};
|
2021-02-17 04:59:28 +01:00
|
|
|
while (size <= MAXIMUM_SIZE) {
|
|
|
|
code.resize(size / INST_SIZE);
|
|
|
|
u64* const data = code.data() + offset / INST_SIZE;
|
2021-03-19 23:28:31 +01:00
|
|
|
gpu_memory->ReadBlock(guest_addr, data, BLOCK_SIZE);
|
2021-03-29 02:55:47 +02:00
|
|
|
for (size_t index = 0; index < BLOCK_SIZE; index += INST_SIZE) {
|
|
|
|
const u64 inst = data[index / INST_SIZE];
|
2021-02-17 04:59:28 +01:00
|
|
|
if (inst == SELF_BRANCH_A || inst == SELF_BRANCH_B) {
|
2021-03-29 02:55:47 +02:00
|
|
|
return offset + index;
|
2021-02-17 04:59:28 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
guest_addr += BLOCK_SIZE;
|
|
|
|
size += BLOCK_SIZE;
|
|
|
|
offset += BLOCK_SIZE;
|
|
|
|
}
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
|
2021-03-26 22:45:38 +01:00
|
|
|
Shader::TextureType ReadTextureTypeImpl(GPUVAddr tic_addr, u32 tic_limit, bool via_header_index,
|
2021-04-21 00:48:45 +02:00
|
|
|
u32 raw) {
|
2021-03-26 22:45:38 +01:00
|
|
|
const TextureHandle handle{raw, via_header_index};
|
|
|
|
const GPUVAddr descriptor_addr{tic_addr + handle.image * sizeof(Tegra::Texture::TICEntry)};
|
|
|
|
Tegra::Texture::TICEntry entry;
|
|
|
|
gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));
|
|
|
|
|
|
|
|
const Shader::TextureType result{[&] {
|
|
|
|
switch (entry.texture_type) {
|
|
|
|
case Tegra::Texture::TextureType::Texture1D:
|
|
|
|
return Shader::TextureType::Color1D;
|
|
|
|
case Tegra::Texture::TextureType::Texture2D:
|
|
|
|
case Tegra::Texture::TextureType::Texture2DNoMipmap:
|
|
|
|
return Shader::TextureType::Color2D;
|
|
|
|
case Tegra::Texture::TextureType::Texture3D:
|
|
|
|
return Shader::TextureType::Color3D;
|
|
|
|
case Tegra::Texture::TextureType::TextureCubemap:
|
|
|
|
return Shader::TextureType::ColorCube;
|
|
|
|
case Tegra::Texture::TextureType::Texture1DArray:
|
|
|
|
return Shader::TextureType::ColorArray1D;
|
|
|
|
case Tegra::Texture::TextureType::Texture2DArray:
|
|
|
|
return Shader::TextureType::ColorArray2D;
|
|
|
|
case Tegra::Texture::TextureType::Texture1DBuffer:
|
2021-04-06 07:56:15 +02:00
|
|
|
return Shader::TextureType::Buffer;
|
2021-03-26 22:45:38 +01:00
|
|
|
case Tegra::Texture::TextureType::TextureCubeArray:
|
|
|
|
return Shader::TextureType::ColorArrayCube;
|
|
|
|
default:
|
|
|
|
throw Shader::NotImplementedException("Unknown texture type");
|
|
|
|
}
|
|
|
|
}()};
|
2021-04-21 00:48:45 +02:00
|
|
|
texture_types.emplace(raw, result);
|
2021-03-26 22:45:38 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
Tegra::MemoryManager* gpu_memory{};
|
|
|
|
GPUVAddr program_base{};
|
|
|
|
|
|
|
|
std::vector<u64> code;
|
2021-04-21 00:48:45 +02:00
|
|
|
std::unordered_map<u32, Shader::TextureType> texture_types;
|
2021-03-27 22:30:24 +01:00
|
|
|
std::unordered_map<u64, u32> cbuf_values;
|
2021-02-17 04:59:28 +01:00
|
|
|
|
2021-04-01 09:09:09 +02:00
|
|
|
u32 local_memory_size{};
|
|
|
|
u32 texture_bound{};
|
|
|
|
u32 shared_memory_size{};
|
|
|
|
std::array<u32, 3> workgroup_size{};
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
u32 read_lowest = std::numeric_limits<u32>::max();
|
2021-02-17 04:59:28 +01:00
|
|
|
u32 read_highest = 0;
|
|
|
|
|
|
|
|
u32 cached_lowest = std::numeric_limits<u32>::max();
|
|
|
|
u32 cached_highest = 0;
|
2021-03-23 01:03:20 +01:00
|
|
|
|
|
|
|
bool has_unbound_instructions = false;
|
2021-02-17 04:59:28 +01:00
|
|
|
};
|
2021-03-19 23:28:31 +01:00
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
namespace {
|
|
|
|
using Shader::Backend::SPIRV::EmitSPIRV;
|
|
|
|
using Shader::Maxwell::TranslateProgram;
|
|
|
|
|
2021-04-14 06:04:59 +02:00
|
|
|
// TODO: Move this to a separate file
|
|
|
|
constexpr std::array<char, 8> MAGIC_NUMBER{'y', 'u', 'z', 'u', 'c', 'a', 'c', 'h'};
|
2021-04-21 00:48:45 +02:00
|
|
|
constexpr u32 CACHE_VERSION{2};
|
2021-04-14 06:04:59 +02:00
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
class GraphicsEnvironment final : public GenericEnvironment {
|
|
|
|
public:
|
|
|
|
explicit GraphicsEnvironment() = default;
|
|
|
|
explicit GraphicsEnvironment(Tegra::Engines::Maxwell3D& maxwell3d_,
|
|
|
|
Tegra::MemoryManager& gpu_memory_, Maxwell::ShaderProgram program,
|
2021-03-23 01:03:20 +01:00
|
|
|
GPUVAddr program_base_, u32 start_address_)
|
|
|
|
: GenericEnvironment{gpu_memory_, program_base_, start_address_}, maxwell3d{&maxwell3d_} {
|
|
|
|
gpu_memory->ReadBlock(program_base + start_address, &sph, sizeof(sph));
|
2021-03-19 23:28:31 +01:00
|
|
|
switch (program) {
|
|
|
|
case Maxwell::ShaderProgram::VertexA:
|
|
|
|
stage = Shader::Stage::VertexA;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 0;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::ShaderProgram::VertexB:
|
|
|
|
stage = Shader::Stage::VertexB;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 0;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::ShaderProgram::TesselationControl:
|
|
|
|
stage = Shader::Stage::TessellationControl;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 1;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::ShaderProgram::TesselationEval:
|
|
|
|
stage = Shader::Stage::TessellationEval;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 2;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::ShaderProgram::Geometry:
|
|
|
|
stage = Shader::Stage::Geometry;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 3;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
case Maxwell::ShaderProgram::Fragment:
|
|
|
|
stage = Shader::Stage::Fragment;
|
2021-03-26 22:45:38 +01:00
|
|
|
stage_index = 4;
|
2021-03-19 23:28:31 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UNREACHABLE_MSG("Invalid program={}", program);
|
2021-03-26 22:45:38 +01:00
|
|
|
break;
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
2021-04-01 09:09:09 +02:00
|
|
|
const u64 local_size{sph.LocalMemorySize()};
|
|
|
|
ASSERT(local_size <= std::numeric_limits<u32>::max());
|
|
|
|
local_memory_size = static_cast<u32>(local_size);
|
|
|
|
texture_bound = maxwell3d->regs.tex_cb_index;
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
~GraphicsEnvironment() override = default;
|
|
|
|
|
2021-03-27 22:30:24 +01:00
|
|
|
u32 ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) override {
|
|
|
|
const auto& cbuf{maxwell3d->state.shader_stages[stage_index].const_buffers[cbuf_index]};
|
|
|
|
ASSERT(cbuf.enabled);
|
|
|
|
u32 value{};
|
|
|
|
if (cbuf_offset < cbuf.size) {
|
|
|
|
value = gpu_memory->Read<u32>(cbuf.address + cbuf_offset);
|
|
|
|
}
|
|
|
|
cbuf_values.emplace(MakeCbufKey(cbuf_index, cbuf_offset), value);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:48:45 +02:00
|
|
|
Shader::TextureType ReadTextureType(u32 handle) override {
|
2021-03-26 22:45:38 +01:00
|
|
|
const auto& regs{maxwell3d->regs};
|
|
|
|
const bool via_header_index{regs.sampler_index == Maxwell::SamplerIndex::ViaHeaderIndex};
|
2021-04-21 00:48:45 +02:00
|
|
|
return ReadTextureTypeImpl(regs.tic.Address(), regs.tic.limit, via_header_index, handle);
|
2021-03-26 22:45:38 +01:00
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
private:
|
|
|
|
Tegra::Engines::Maxwell3D* maxwell3d{};
|
2021-03-26 22:45:38 +01:00
|
|
|
size_t stage_index{};
|
2021-03-19 23:28:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class ComputeEnvironment final : public GenericEnvironment {
|
|
|
|
public:
|
|
|
|
explicit ComputeEnvironment() = default;
|
|
|
|
explicit ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_compute_,
|
2021-03-23 01:03:20 +01:00
|
|
|
Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_,
|
|
|
|
u32 start_address_)
|
|
|
|
: GenericEnvironment{gpu_memory_, program_base_, start_address_}, kepler_compute{
|
|
|
|
&kepler_compute_} {
|
2021-04-01 09:09:09 +02:00
|
|
|
const auto& qmd{kepler_compute->launch_description};
|
2021-03-19 23:28:31 +01:00
|
|
|
stage = Shader::Stage::Compute;
|
2021-04-01 09:09:09 +02:00
|
|
|
local_memory_size = qmd.local_pos_alloc;
|
|
|
|
texture_bound = kepler_compute->regs.tex_cb_index;
|
|
|
|
shared_memory_size = qmd.shared_alloc;
|
|
|
|
workgroup_size = {qmd.block_dim_x, qmd.block_dim_y, qmd.block_dim_z};
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
~ComputeEnvironment() override = default;
|
|
|
|
|
2021-03-27 22:30:24 +01:00
|
|
|
u32 ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) override {
|
|
|
|
const auto& qmd{kepler_compute->launch_description};
|
|
|
|
ASSERT(((qmd.const_buffer_enable_mask.Value() >> cbuf_index) & 1) != 0);
|
|
|
|
const auto& cbuf{qmd.const_buffer_config[cbuf_index]};
|
|
|
|
u32 value{};
|
|
|
|
if (cbuf_offset < cbuf.size) {
|
|
|
|
value = gpu_memory->Read<u32>(cbuf.Address() + cbuf_offset);
|
|
|
|
}
|
|
|
|
cbuf_values.emplace(MakeCbufKey(cbuf_index, cbuf_offset), value);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:48:45 +02:00
|
|
|
Shader::TextureType ReadTextureType(u32 handle) override {
|
2021-03-26 22:45:38 +01:00
|
|
|
const auto& regs{kepler_compute->regs};
|
|
|
|
const auto& qmd{kepler_compute->launch_description};
|
2021-04-21 00:48:45 +02:00
|
|
|
return ReadTextureTypeImpl(regs.tic.Address(), regs.tic.limit, qmd.linked_tsc != 0, handle);
|
2021-03-26 22:45:38 +01:00
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
private:
|
|
|
|
Tegra::Engines::KeplerCompute* kepler_compute{};
|
|
|
|
};
|
2021-03-23 01:03:20 +01:00
|
|
|
|
|
|
|
void SerializePipeline(std::span<const char> key, std::span<const GenericEnvironment* const> envs,
|
|
|
|
std::ofstream& file) {
|
|
|
|
if (!std::ranges::all_of(envs, &GenericEnvironment::CanBeSerialized)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const u32 num_envs{static_cast<u32>(envs.size())};
|
|
|
|
file.write(reinterpret_cast<const char*>(&num_envs), sizeof(num_envs));
|
|
|
|
for (const GenericEnvironment* const env : envs) {
|
|
|
|
env->Serialize(file);
|
|
|
|
}
|
|
|
|
file.write(key.data(), key.size_bytes());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Key, typename Envs>
|
|
|
|
void SerializePipeline(const Key& key, const Envs& envs, const std::string& filename) {
|
|
|
|
try {
|
|
|
|
std::ofstream file;
|
|
|
|
file.exceptions(std::ifstream::failbit);
|
2021-04-14 06:04:59 +02:00
|
|
|
Common::FS::OpenFStream(file, filename, std::ios::binary | std::ios::ate | std::ios::app);
|
2021-03-23 01:03:20 +01:00
|
|
|
if (!file.is_open()) {
|
|
|
|
LOG_ERROR(Common_Filesystem, "Failed to open pipeline cache file {}", filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (file.tellp() == 0) {
|
2021-04-14 06:04:59 +02:00
|
|
|
file.write(MAGIC_NUMBER.data(), MAGIC_NUMBER.size())
|
|
|
|
.write(reinterpret_cast<const char*>(&CACHE_VERSION), sizeof(CACHE_VERSION));
|
2021-03-23 01:03:20 +01:00
|
|
|
}
|
|
|
|
const std::span key_span(reinterpret_cast<const char*>(&key), sizeof(key));
|
|
|
|
SerializePipeline(key_span, MakeSpan(envs), file);
|
|
|
|
|
|
|
|
} catch (const std::ios_base::failure& e) {
|
|
|
|
LOG_ERROR(Common_Filesystem, "{}", e.what());
|
|
|
|
if (!Common::FS::Delete(filename)) {
|
|
|
|
LOG_ERROR(Common_Filesystem, "Failed to delete pipeline cache file {}", filename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class FileEnvironment final : public Shader::Environment {
|
|
|
|
public:
|
|
|
|
void Deserialize(std::ifstream& file) {
|
|
|
|
u64 code_size{};
|
2021-03-26 22:45:38 +01:00
|
|
|
u64 num_texture_types{};
|
2021-03-27 22:30:24 +01:00
|
|
|
u64 num_cbuf_values{};
|
2021-03-23 01:03:20 +01:00
|
|
|
file.read(reinterpret_cast<char*>(&code_size), sizeof(code_size))
|
2021-03-26 22:45:38 +01:00
|
|
|
.read(reinterpret_cast<char*>(&num_texture_types), sizeof(num_texture_types))
|
2021-03-27 22:30:24 +01:00
|
|
|
.read(reinterpret_cast<char*>(&num_cbuf_values), sizeof(num_cbuf_values))
|
2021-03-29 00:53:34 +02:00
|
|
|
.read(reinterpret_cast<char*>(&local_memory_size), sizeof(local_memory_size))
|
2021-03-23 01:03:20 +01:00
|
|
|
.read(reinterpret_cast<char*>(&texture_bound), sizeof(texture_bound))
|
|
|
|
.read(reinterpret_cast<char*>(&start_address), sizeof(start_address))
|
|
|
|
.read(reinterpret_cast<char*>(&read_lowest), sizeof(read_lowest))
|
|
|
|
.read(reinterpret_cast<char*>(&read_highest), sizeof(read_highest))
|
|
|
|
.read(reinterpret_cast<char*>(&stage), sizeof(stage));
|
|
|
|
code = std::make_unique<u64[]>(Common::DivCeil(code_size, sizeof(u64)));
|
|
|
|
file.read(reinterpret_cast<char*>(code.get()), code_size);
|
2021-03-26 22:45:38 +01:00
|
|
|
for (size_t i = 0; i < num_texture_types; ++i) {
|
2021-04-21 00:48:45 +02:00
|
|
|
u32 key;
|
2021-03-26 22:45:38 +01:00
|
|
|
Shader::TextureType type;
|
|
|
|
file.read(reinterpret_cast<char*>(&key), sizeof(key))
|
|
|
|
.read(reinterpret_cast<char*>(&type), sizeof(type));
|
|
|
|
texture_types.emplace(key, type);
|
|
|
|
}
|
2021-03-27 22:30:24 +01:00
|
|
|
for (size_t i = 0; i < num_cbuf_values; ++i) {
|
|
|
|
u64 key;
|
|
|
|
u32 value;
|
|
|
|
file.read(reinterpret_cast<char*>(&key), sizeof(key))
|
|
|
|
.read(reinterpret_cast<char*>(&value), sizeof(value));
|
|
|
|
cbuf_values.emplace(key, value);
|
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
if (stage == Shader::Stage::Compute) {
|
2021-03-29 00:53:34 +02:00
|
|
|
file.read(reinterpret_cast<char*>(&workgroup_size), sizeof(workgroup_size))
|
|
|
|
.read(reinterpret_cast<char*>(&shared_memory_size), sizeof(shared_memory_size));
|
2021-03-23 01:03:20 +01:00
|
|
|
} else {
|
|
|
|
file.read(reinterpret_cast<char*>(&sph), sizeof(sph));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 ReadInstruction(u32 address) override {
|
|
|
|
if (address < read_lowest || address > read_highest) {
|
|
|
|
throw Shader::LogicError("Out of bounds address {}", address);
|
|
|
|
}
|
|
|
|
return code[(address - read_lowest) / sizeof(u64)];
|
|
|
|
}
|
|
|
|
|
2021-03-27 22:30:24 +01:00
|
|
|
u32 ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) override {
|
|
|
|
const auto it{cbuf_values.find(MakeCbufKey(cbuf_index, cbuf_offset))};
|
|
|
|
if (it == cbuf_values.end()) {
|
|
|
|
throw Shader::LogicError("Uncached read texture type");
|
|
|
|
}
|
|
|
|
return it->second;
|
|
|
|
}
|
|
|
|
|
2021-04-21 00:48:45 +02:00
|
|
|
Shader::TextureType ReadTextureType(u32 handle) override {
|
|
|
|
const auto it{texture_types.find(handle)};
|
2021-03-26 22:45:38 +01:00
|
|
|
if (it == texture_types.end()) {
|
|
|
|
throw Shader::LogicError("Uncached read texture type");
|
|
|
|
}
|
|
|
|
return it->second;
|
|
|
|
}
|
|
|
|
|
2021-03-29 00:53:34 +02:00
|
|
|
u32 LocalMemorySize() const override {
|
|
|
|
return local_memory_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 SharedMemorySize() const override {
|
|
|
|
return shared_memory_size;
|
|
|
|
}
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
u32 TextureBoundBuffer() const override {
|
|
|
|
return texture_bound;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::array<u32, 3> WorkgroupSize() const override {
|
|
|
|
return workgroup_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::unique_ptr<u64[]> code;
|
2021-04-21 00:48:45 +02:00
|
|
|
std::unordered_map<u32, Shader::TextureType> texture_types;
|
2021-03-27 22:30:24 +01:00
|
|
|
std::unordered_map<u64, u32> cbuf_values;
|
2021-03-23 01:03:20 +01:00
|
|
|
std::array<u32, 3> workgroup_size{};
|
2021-03-29 00:53:34 +02:00
|
|
|
u32 local_memory_size{};
|
|
|
|
u32 shared_memory_size{};
|
2021-03-23 01:03:20 +01:00
|
|
|
u32 texture_bound{};
|
|
|
|
u32 read_lowest{};
|
|
|
|
u32 read_highest{};
|
|
|
|
};
|
2021-04-14 06:32:18 +02:00
|
|
|
|
|
|
|
Shader::CompareFunction MaxwellToCompareFunction(Maxwell::ComparisonOp comparison) {
|
|
|
|
switch (comparison) {
|
|
|
|
case Maxwell::ComparisonOp::Never:
|
|
|
|
case Maxwell::ComparisonOp::NeverOld:
|
|
|
|
return Shader::CompareFunction::Never;
|
|
|
|
case Maxwell::ComparisonOp::Less:
|
|
|
|
case Maxwell::ComparisonOp::LessOld:
|
|
|
|
return Shader::CompareFunction::Less;
|
|
|
|
case Maxwell::ComparisonOp::Equal:
|
|
|
|
case Maxwell::ComparisonOp::EqualOld:
|
|
|
|
return Shader::CompareFunction::Equal;
|
|
|
|
case Maxwell::ComparisonOp::LessEqual:
|
|
|
|
case Maxwell::ComparisonOp::LessEqualOld:
|
|
|
|
return Shader::CompareFunction::LessThanEqual;
|
|
|
|
case Maxwell::ComparisonOp::Greater:
|
|
|
|
case Maxwell::ComparisonOp::GreaterOld:
|
|
|
|
return Shader::CompareFunction::Greater;
|
|
|
|
case Maxwell::ComparisonOp::NotEqual:
|
|
|
|
case Maxwell::ComparisonOp::NotEqualOld:
|
|
|
|
return Shader::CompareFunction::NotEqual;
|
|
|
|
case Maxwell::ComparisonOp::GreaterEqual:
|
|
|
|
case Maxwell::ComparisonOp::GreaterEqualOld:
|
|
|
|
return Shader::CompareFunction::GreaterThanEqual;
|
|
|
|
case Maxwell::ComparisonOp::Always:
|
|
|
|
case Maxwell::ComparisonOp::AlwaysOld:
|
|
|
|
return Shader::CompareFunction::Always;
|
|
|
|
}
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented comparison op={}", comparison);
|
|
|
|
return {};
|
|
|
|
}
|
2020-01-07 01:55:06 +01:00
|
|
|
} // Anonymous namespace
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
|
|
|
|
const VideoCore::DiskResourceLoadCallback& callback) {
|
|
|
|
if (title_id == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
std::string shader_dir{Common::FS::GetUserPath(Common::FS::UserPath::ShaderDir)};
|
|
|
|
std::string base_dir{shader_dir + "/vulkan"};
|
|
|
|
std::string transferable_dir{base_dir + "/transferable"};
|
|
|
|
std::string precompiled_dir{base_dir + "/precompiled"};
|
|
|
|
if (!Common::FS::CreateDir(shader_dir) || !Common::FS::CreateDir(base_dir) ||
|
|
|
|
!Common::FS::CreateDir(transferable_dir) || !Common::FS::CreateDir(precompiled_dir)) {
|
|
|
|
LOG_ERROR(Common_Filesystem, "Failed to create pipeline cache directories");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pipeline_cache_filename = fmt::format("{}/{:016x}.bin", transferable_dir, title_id);
|
|
|
|
|
|
|
|
struct {
|
2021-04-01 06:36:22 +02:00
|
|
|
std::mutex mutex;
|
2021-03-23 01:03:20 +01:00
|
|
|
size_t total{0};
|
|
|
|
size_t built{0};
|
|
|
|
bool has_loaded{false};
|
|
|
|
} state;
|
|
|
|
|
|
|
|
std::ifstream file;
|
|
|
|
Common::FS::OpenFStream(file, pipeline_cache_filename, std::ios::binary | std::ios::ate);
|
|
|
|
if (!file.is_open()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
file.exceptions(std::ifstream::failbit);
|
|
|
|
const auto end{file.tellg()};
|
|
|
|
file.seekg(0, std::ios::beg);
|
|
|
|
|
2021-04-14 06:04:59 +02:00
|
|
|
std::array<char, 8> magic_number;
|
|
|
|
u32 cache_version;
|
|
|
|
file.read(magic_number.data(), magic_number.size())
|
|
|
|
.read(reinterpret_cast<char*>(&cache_version), sizeof(cache_version));
|
|
|
|
if (magic_number != MAGIC_NUMBER || cache_version != CACHE_VERSION) {
|
|
|
|
file.close();
|
|
|
|
if (Common::FS::Delete(pipeline_cache_filename)) {
|
|
|
|
if (magic_number != MAGIC_NUMBER) {
|
|
|
|
LOG_ERROR(Render_Vulkan, "Invalid pipeline cache file");
|
|
|
|
}
|
|
|
|
if (cache_version != CACHE_VERSION) {
|
|
|
|
LOG_INFO(Render_Vulkan, "Deleting old pipeline cache");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
LOG_ERROR(Render_Vulkan,
|
|
|
|
"Invalid pipeline cache file and failed to delete it in \"{}\"",
|
|
|
|
pipeline_cache_filename);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
while (file.tellg() != end) {
|
|
|
|
if (stop_loading) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
u32 num_envs{};
|
|
|
|
file.read(reinterpret_cast<char*>(&num_envs), sizeof(num_envs));
|
2021-04-01 06:36:22 +02:00
|
|
|
std::vector<FileEnvironment> envs(num_envs);
|
|
|
|
for (FileEnvironment& env : envs) {
|
2021-03-23 01:03:20 +01:00
|
|
|
env.Deserialize(file);
|
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
if (envs.front().ShaderStage() == Shader::Stage::Compute) {
|
2021-03-23 01:03:20 +01:00
|
|
|
ComputePipelineCacheKey key;
|
|
|
|
file.read(reinterpret_cast<char*>(&key), sizeof(key));
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
workers.QueueWork([this, key, envs = std::move(envs), &state, &callback]() mutable {
|
2021-03-23 01:03:20 +01:00
|
|
|
ShaderPools pools;
|
2021-04-01 06:36:22 +02:00
|
|
|
auto pipeline{CreateComputePipeline(pools, key, envs.front(), false)};
|
2021-03-23 01:03:20 +01:00
|
|
|
|
2021-04-03 10:19:13 +02:00
|
|
|
std::lock_guard lock{state.mutex};
|
|
|
|
compute_cache.emplace(key, std::move(pipeline));
|
|
|
|
++state.built;
|
|
|
|
if (state.has_loaded) {
|
|
|
|
callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
|
2021-03-23 01:03:20 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
GraphicsPipelineCacheKey key;
|
|
|
|
file.read(reinterpret_cast<char*>(&key), sizeof(key));
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
workers.QueueWork([this, key, envs = std::move(envs), &state, &callback]() mutable {
|
2021-03-23 01:03:20 +01:00
|
|
|
ShaderPools pools;
|
|
|
|
boost::container::static_vector<Shader::Environment*, 5> env_ptrs;
|
2021-04-01 06:36:22 +02:00
|
|
|
for (auto& env : envs) {
|
2021-03-23 01:03:20 +01:00
|
|
|
env_ptrs.push_back(&env);
|
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
auto pipeline{CreateGraphicsPipeline(pools, key, MakeSpan(env_ptrs), false)};
|
2021-03-23 01:03:20 +01:00
|
|
|
|
2021-04-03 10:19:13 +02:00
|
|
|
std::lock_guard lock{state.mutex};
|
|
|
|
graphics_cache.emplace(key, std::move(pipeline));
|
|
|
|
++state.built;
|
|
|
|
if (state.has_loaded) {
|
|
|
|
callback(VideoCore::LoadCallbackStage::Build, state.built, state.total);
|
2021-03-23 01:03:20 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
++state.total;
|
|
|
|
}
|
|
|
|
{
|
2021-04-01 06:36:22 +02:00
|
|
|
std::lock_guard lock{state.mutex};
|
2021-03-23 01:03:20 +01:00
|
|
|
callback(VideoCore::LoadCallbackStage::Build, 0, state.total);
|
|
|
|
state.has_loaded = true;
|
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
workers.WaitForRequests();
|
2021-03-23 01:03:20 +01:00
|
|
|
}
|
|
|
|
|
2021-02-17 00:52:12 +01:00
|
|
|
size_t ComputePipelineCacheKey::Hash() const noexcept {
|
2020-04-23 01:52:29 +02:00
|
|
|
const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), sizeof *this);
|
2021-02-17 00:52:12 +01:00
|
|
|
return static_cast<size_t>(hash);
|
2020-04-23 01:52:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ComputePipelineCacheKey::operator==(const ComputePipelineCacheKey& rhs) const noexcept {
|
|
|
|
return std::memcmp(&rhs, this, sizeof *this) == 0;
|
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
size_t GraphicsPipelineCacheKey::Hash() const noexcept {
|
|
|
|
const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), Size());
|
|
|
|
return static_cast<size_t>(hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GraphicsPipelineCacheKey::operator==(const GraphicsPipelineCacheKey& rhs) const noexcept {
|
|
|
|
return std::memcmp(&rhs, this, Size()) == 0;
|
|
|
|
}
|
|
|
|
|
2021-02-17 00:52:12 +01:00
|
|
|
PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, Tegra::GPU& gpu_,
|
|
|
|
Tegra::Engines::Maxwell3D& maxwell3d_,
|
|
|
|
Tegra::Engines::KeplerCompute& kepler_compute_,
|
|
|
|
Tegra::MemoryManager& gpu_memory_, const Device& device_,
|
|
|
|
VKScheduler& scheduler_, VKDescriptorPool& descriptor_pool_,
|
2021-03-19 23:28:31 +01:00
|
|
|
VKUpdateDescriptorQueue& update_descriptor_queue_,
|
|
|
|
RenderPassCache& render_pass_cache_, BufferCache& buffer_cache_,
|
|
|
|
TextureCache& texture_cache_)
|
2021-02-17 04:59:28 +01:00
|
|
|
: VideoCommon::ShaderCache<ShaderInfo>{rasterizer_}, gpu{gpu_}, maxwell3d{maxwell3d_},
|
2020-12-30 06:25:23 +01:00
|
|
|
kepler_compute{kepler_compute_}, gpu_memory{gpu_memory_}, device{device_},
|
2021-03-19 23:28:31 +01:00
|
|
|
scheduler{scheduler_}, descriptor_pool{descriptor_pool_},
|
|
|
|
update_descriptor_queue{update_descriptor_queue_}, render_pass_cache{render_pass_cache_},
|
2021-04-01 08:15:28 +02:00
|
|
|
buffer_cache{buffer_cache_}, texture_cache{texture_cache_},
|
2021-04-06 00:15:45 +02:00
|
|
|
workers(std::max(std::thread::hardware_concurrency(), 2U) - 1, "yuzu:PipelineBuilder"),
|
2021-04-05 08:56:58 +02:00
|
|
|
serialization_thread(1, "yuzu:PipelineSerialization") {
|
2021-03-19 23:28:31 +01:00
|
|
|
const auto& float_control{device.FloatControlProperties()};
|
2021-03-20 09:04:12 +01:00
|
|
|
const VkDriverIdKHR driver_id{device.GetDriverID()};
|
2021-03-24 05:33:45 +01:00
|
|
|
base_profile = Shader::Profile{
|
2021-03-29 00:53:34 +02:00
|
|
|
.supported_spirv = device.IsKhrSpirv1_4Supported() ? 0x00010400U : 0x00010000U,
|
2021-03-19 23:28:31 +01:00
|
|
|
.unified_descriptor_binding = true,
|
2021-03-20 23:11:56 +01:00
|
|
|
.support_vertex_instance_id = false,
|
2021-03-19 23:28:31 +01:00
|
|
|
.support_float_controls = true,
|
|
|
|
.support_separate_denorm_behavior = float_control.denormBehaviorIndependence ==
|
|
|
|
VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR,
|
|
|
|
.support_separate_rounding_mode =
|
|
|
|
float_control.roundingModeIndependence == VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR,
|
|
|
|
.support_fp16_denorm_preserve = float_control.shaderDenormPreserveFloat16 != VK_FALSE,
|
|
|
|
.support_fp32_denorm_preserve = float_control.shaderDenormPreserveFloat32 != VK_FALSE,
|
|
|
|
.support_fp16_denorm_flush = float_control.shaderDenormFlushToZeroFloat16 != VK_FALSE,
|
|
|
|
.support_fp32_denorm_flush = float_control.shaderDenormFlushToZeroFloat32 != VK_FALSE,
|
|
|
|
.support_fp16_signed_zero_nan_preserve =
|
|
|
|
float_control.shaderSignedZeroInfNanPreserveFloat16 != VK_FALSE,
|
|
|
|
.support_fp32_signed_zero_nan_preserve =
|
|
|
|
float_control.shaderSignedZeroInfNanPreserveFloat32 != VK_FALSE,
|
2021-03-22 00:28:37 +01:00
|
|
|
.support_fp64_signed_zero_nan_preserve =
|
|
|
|
float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
|
2021-03-29 00:53:34 +02:00
|
|
|
.support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),
|
2021-03-24 01:27:17 +01:00
|
|
|
.support_vote = true,
|
2021-04-03 10:19:13 +02:00
|
|
|
.support_viewport_index_layer_non_geometry =
|
|
|
|
device.IsExtShaderViewportIndexLayerSupported(),
|
2021-04-16 21:31:15 +02:00
|
|
|
.support_viewport_mask = device.IsNvViewportArray2Supported(),
|
2021-04-11 07:37:03 +02:00
|
|
|
.support_typeless_image_loads = device.IsFormatlessImageLoadSupported(),
|
2021-03-24 01:27:17 +01:00
|
|
|
.warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyBiggerThanGuest(),
|
2021-04-11 08:07:02 +02:00
|
|
|
.support_int64_atomics = device.IsExtShaderAtomicInt64Supported(),
|
2021-03-20 09:04:12 +01:00
|
|
|
.has_broken_spirv_clamp = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR,
|
2021-03-24 05:33:45 +01:00
|
|
|
.generic_input_types{},
|
2021-04-06 04:25:22 +02:00
|
|
|
.fixed_state_point_size{},
|
2021-04-16 01:01:45 +02:00
|
|
|
.alpha_test_func{},
|
|
|
|
.xfb_varyings{},
|
2021-03-19 23:28:31 +01:00
|
|
|
};
|
|
|
|
}
|
2020-01-07 01:55:06 +01:00
|
|
|
|
2021-02-17 00:52:12 +01:00
|
|
|
PipelineCache::~PipelineCache() = default;
|
2020-01-07 01:55:06 +01:00
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
GraphicsPipeline* PipelineCache::CurrentGraphicsPipeline() {
|
|
|
|
MICROPROFILE_SCOPE(Vulkan_PipelineCache);
|
|
|
|
|
|
|
|
if (!RefreshStages()) {
|
2021-04-24 23:27:25 +02:00
|
|
|
current_pipeline = nullptr;
|
2021-03-19 23:28:31 +01:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
graphics_key.state.Refresh(maxwell3d, device.IsExtExtendedDynamicStateSupported());
|
|
|
|
|
2021-04-24 23:27:25 +02:00
|
|
|
if (current_pipeline) {
|
|
|
|
GraphicsPipeline* const next{current_pipeline->Next(graphics_key)};
|
|
|
|
if (next) {
|
|
|
|
current_pipeline = next;
|
|
|
|
return current_pipeline;
|
|
|
|
}
|
|
|
|
}
|
2021-03-19 23:28:31 +01:00
|
|
|
const auto [pair, is_new]{graphics_cache.try_emplace(graphics_key)};
|
|
|
|
auto& pipeline{pair->second};
|
2021-04-24 23:27:25 +02:00
|
|
|
if (is_new) {
|
|
|
|
pipeline = CreateGraphicsPipeline();
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
2021-04-24 23:27:25 +02:00
|
|
|
if (current_pipeline) {
|
|
|
|
current_pipeline->AddTransition(pipeline.get());
|
|
|
|
}
|
|
|
|
current_pipeline = pipeline.get();
|
|
|
|
return current_pipeline;
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
|
|
|
|
2021-02-17 04:59:28 +01:00
|
|
|
ComputePipeline* PipelineCache::CurrentComputePipeline() {
|
2020-01-07 01:55:06 +01:00
|
|
|
MICROPROFILE_SCOPE(Vulkan_PipelineCache);
|
|
|
|
|
2021-02-17 04:59:28 +01:00
|
|
|
const GPUVAddr program_base{kepler_compute.regs.code_loc.Address()};
|
|
|
|
const auto& qmd{kepler_compute.launch_description};
|
|
|
|
const GPUVAddr shader_addr{program_base + qmd.program_start};
|
|
|
|
const std::optional<VAddr> cpu_shader_addr{gpu_memory.GpuToCpuAddress(shader_addr)};
|
|
|
|
if (!cpu_shader_addr) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
const ShaderInfo* shader{TryGet(*cpu_shader_addr)};
|
2021-02-17 04:59:28 +01:00
|
|
|
if (!shader) {
|
2021-03-23 01:03:20 +01:00
|
|
|
ComputeEnvironment env{kepler_compute, gpu_memory, program_base, qmd.program_start};
|
|
|
|
shader = MakeShaderInfo(env, *cpu_shader_addr);
|
2021-02-17 04:59:28 +01:00
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
const ComputePipelineCacheKey key{
|
2021-03-29 00:53:34 +02:00
|
|
|
.unique_hash{shader->unique_hash},
|
|
|
|
.shared_memory_size{qmd.shared_alloc},
|
2021-03-23 01:03:20 +01:00
|
|
|
.workgroup_size{qmd.block_dim_x, qmd.block_dim_y, qmd.block_dim_z},
|
|
|
|
};
|
2021-02-17 04:59:28 +01:00
|
|
|
const auto [pair, is_new]{compute_cache.try_emplace(key)};
|
|
|
|
auto& pipeline{pair->second};
|
|
|
|
if (!is_new) {
|
2021-04-01 06:36:22 +02:00
|
|
|
return pipeline.get();
|
2021-02-17 04:59:28 +01:00
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
pipeline = CreateComputePipeline(key, shader);
|
2021-04-01 06:36:22 +02:00
|
|
|
return pipeline.get();
|
2021-02-17 04:59:28 +01:00
|
|
|
}
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
bool PipelineCache::RefreshStages() {
|
2021-04-24 23:27:25 +02:00
|
|
|
auto& dirty{maxwell3d.dirty.flags};
|
|
|
|
if (!dirty[VideoCommon::Dirty::Shaders]) {
|
|
|
|
return last_valid_shaders;
|
|
|
|
}
|
|
|
|
dirty[VideoCommon::Dirty::Shaders] = false;
|
|
|
|
|
2021-03-19 23:28:31 +01:00
|
|
|
const GPUVAddr base_addr{maxwell3d.regs.code_address.CodeAddress()};
|
|
|
|
for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
|
|
|
if (!maxwell3d.regs.IsShaderConfigEnabled(index)) {
|
|
|
|
graphics_key.unique_hashes[index] = u128{};
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const auto& shader_config{maxwell3d.regs.shader_config[index]};
|
|
|
|
const auto program{static_cast<Maxwell::ShaderProgram>(index)};
|
|
|
|
const GPUVAddr shader_addr{base_addr + shader_config.offset};
|
|
|
|
const std::optional<VAddr> cpu_shader_addr{gpu_memory.GpuToCpuAddress(shader_addr)};
|
|
|
|
if (!cpu_shader_addr) {
|
|
|
|
LOG_ERROR(Render_Vulkan, "Invalid GPU address for shader 0x{:016x}", shader_addr);
|
2021-04-24 23:27:25 +02:00
|
|
|
last_valid_shaders = false;
|
2021-03-19 23:28:31 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
const ShaderInfo* shader_info{TryGet(*cpu_shader_addr)};
|
|
|
|
if (!shader_info) {
|
2021-03-23 01:03:20 +01:00
|
|
|
const u32 start_address{shader_config.offset};
|
|
|
|
GraphicsEnvironment env{maxwell3d, gpu_memory, program, base_addr, start_address};
|
|
|
|
shader_info = MakeShaderInfo(env, *cpu_shader_addr);
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
2021-03-27 06:56:09 +01:00
|
|
|
shader_infos[index] = shader_info;
|
2021-03-19 23:28:31 +01:00
|
|
|
graphics_key.unique_hashes[index] = shader_info->unique_hash;
|
|
|
|
}
|
2021-04-24 23:27:25 +02:00
|
|
|
last_valid_shaders = true;
|
2021-03-19 23:28:31 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
const ShaderInfo* PipelineCache::MakeShaderInfo(GenericEnvironment& env, VAddr cpu_addr) {
|
2021-03-19 23:28:31 +01:00
|
|
|
auto info = std::make_unique<ShaderInfo>();
|
2021-03-23 01:03:20 +01:00
|
|
|
if (const std::optional<u128> cached_hash{env.Analyze()}) {
|
2021-03-19 23:28:31 +01:00
|
|
|
info->unique_hash = *cached_hash;
|
|
|
|
info->size_bytes = env.CachedSize();
|
|
|
|
} else {
|
|
|
|
// Slow path, not really hit on commercial games
|
|
|
|
// Build a control flow graph to get the real shader size
|
2021-03-23 01:03:20 +01:00
|
|
|
main_pools.flow_block.ReleaseContents();
|
|
|
|
Shader::Maxwell::Flow::CFG cfg{env, main_pools.flow_block, env.StartAddress()};
|
2021-03-19 23:28:31 +01:00
|
|
|
info->unique_hash = env.CalculateHash();
|
|
|
|
info->size_bytes = env.ReadSize();
|
|
|
|
}
|
|
|
|
const size_t size_bytes{info->size_bytes};
|
|
|
|
const ShaderInfo* const result{info.get()};
|
|
|
|
Register(std::move(info), cpu_addr, size_bytes);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
|
|
|
|
ShaderPools& pools, const GraphicsPipelineCacheKey& key,
|
|
|
|
std::span<Shader::Environment* const> envs, bool build_in_parallel) {
|
2021-03-23 01:03:20 +01:00
|
|
|
LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
|
|
|
|
size_t env_index{0};
|
2021-03-19 23:28:31 +01:00
|
|
|
std::array<Shader::IR::Program, Maxwell::MaxShaderProgram> programs;
|
|
|
|
for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
2021-03-23 01:03:20 +01:00
|
|
|
if (key.unique_hashes[index] == u128{}) {
|
2021-03-19 23:28:31 +01:00
|
|
|
continue;
|
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
Shader::Environment& env{*envs[env_index]};
|
|
|
|
++env_index;
|
2021-03-19 23:28:31 +01:00
|
|
|
|
2021-04-06 04:25:22 +02:00
|
|
|
const u32 cfg_offset{static_cast<u32>(env.StartAddress() + sizeof(Shader::ProgramHeader))};
|
2021-03-23 01:03:20 +01:00
|
|
|
Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset);
|
|
|
|
programs[index] = TranslateProgram(pools.inst, pools.block, env, cfg);
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
|
|
|
std::array<const Shader::Info*, Maxwell::MaxShaderStage> infos{};
|
|
|
|
std::array<vk::ShaderModule, Maxwell::MaxShaderStage> modules;
|
|
|
|
|
|
|
|
u32 binding{0};
|
|
|
|
for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
2021-03-23 01:03:20 +01:00
|
|
|
if (key.unique_hashes[index] == u128{}) {
|
2021-03-19 23:28:31 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
UNIMPLEMENTED_IF(index == 0);
|
|
|
|
|
|
|
|
Shader::IR::Program& program{programs[index]};
|
|
|
|
const size_t stage_index{index - 1};
|
|
|
|
infos[stage_index] = &program.info;
|
|
|
|
|
2021-04-13 00:41:22 +02:00
|
|
|
const Shader::Profile profile{MakeProfile(key, program)};
|
2021-03-27 07:08:31 +01:00
|
|
|
const std::vector<u32> code{EmitSPIRV(profile, program, binding)};
|
2021-04-11 07:50:30 +02:00
|
|
|
device.SaveShader(code);
|
2021-03-19 23:28:31 +01:00
|
|
|
modules[stage_index] = BuildShader(device, code);
|
2021-03-31 02:28:00 +02:00
|
|
|
if (device.HasDebuggingToolAttached()) {
|
|
|
|
const std::string name{fmt::format("{:016x}{:016x}", key.unique_hashes[index][0],
|
|
|
|
key.unique_hashes[index][1])};
|
|
|
|
modules[stage_index].SetObjectNameEXT(name.c_str());
|
|
|
|
}
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
|
|
|
|
return std::make_unique<GraphicsPipeline>(
|
|
|
|
maxwell3d, gpu_memory, scheduler, buffer_cache, texture_cache, device, descriptor_pool,
|
2021-04-24 23:27:25 +02:00
|
|
|
update_descriptor_queue, thread_worker, render_pass_cache, key, std::move(modules), infos);
|
2021-03-19 23:28:31 +01:00
|
|
|
}
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
|
2021-03-23 01:03:20 +01:00
|
|
|
main_pools.ReleaseContents();
|
|
|
|
|
|
|
|
std::array<GraphicsEnvironment, Maxwell::MaxShaderProgram> graphics_envs;
|
|
|
|
boost::container::static_vector<Shader::Environment*, Maxwell::MaxShaderProgram> envs;
|
|
|
|
|
|
|
|
const GPUVAddr base_addr{maxwell3d.regs.code_address.CodeAddress()};
|
|
|
|
for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
|
|
|
if (graphics_key.unique_hashes[index] == u128{}) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const auto program{static_cast<Maxwell::ShaderProgram>(index)};
|
2021-03-29 02:55:47 +02:00
|
|
|
auto& env{graphics_envs[index]};
|
2021-03-23 01:03:20 +01:00
|
|
|
const u32 start_address{maxwell3d.regs.shader_config[index].offset};
|
|
|
|
env = GraphicsEnvironment{maxwell3d, gpu_memory, program, base_addr, start_address};
|
2021-03-27 06:56:09 +01:00
|
|
|
env.SetCachedSize(shader_infos[index]->size_bytes);
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
envs.push_back(&env);
|
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
auto pipeline{CreateGraphicsPipeline(main_pools, graphics_key, MakeSpan(envs), true)};
|
2021-04-01 09:09:09 +02:00
|
|
|
if (pipeline_cache_filename.empty()) {
|
|
|
|
return pipeline;
|
|
|
|
}
|
|
|
|
serialization_thread.QueueWork([this, key = graphics_key, envs = std::move(graphics_envs)] {
|
|
|
|
boost::container::static_vector<const GenericEnvironment*, Maxwell::MaxShaderProgram>
|
|
|
|
env_ptrs;
|
|
|
|
for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
|
|
|
|
if (key.unique_hashes[index] != u128{}) {
|
|
|
|
env_ptrs.push_back(&envs[index]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SerializePipeline(key, env_ptrs, pipeline_cache_filename);
|
|
|
|
});
|
2021-03-23 01:03:20 +01:00
|
|
|
return pipeline;
|
|
|
|
}
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
|
|
|
|
const ComputePipelineCacheKey& key, const ShaderInfo* shader) {
|
2021-02-17 04:59:28 +01:00
|
|
|
const GPUVAddr program_base{kepler_compute.regs.code_loc.Address()};
|
|
|
|
const auto& qmd{kepler_compute.launch_description};
|
2021-03-23 01:03:20 +01:00
|
|
|
ComputeEnvironment env{kepler_compute, gpu_memory, program_base, qmd.program_start};
|
2021-03-29 02:55:47 +02:00
|
|
|
env.SetCachedSize(shader->size_bytes);
|
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
main_pools.ReleaseContents();
|
2021-04-01 06:36:22 +02:00
|
|
|
auto pipeline{CreateComputePipeline(main_pools, key, env, true)};
|
2021-03-23 01:03:20 +01:00
|
|
|
if (!pipeline_cache_filename.empty()) {
|
2021-04-01 09:09:09 +02:00
|
|
|
serialization_thread.QueueWork([this, key, env = std::move(env)] {
|
|
|
|
SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env},
|
|
|
|
pipeline_cache_filename);
|
|
|
|
});
|
2020-01-07 01:55:06 +01:00
|
|
|
}
|
2021-03-23 01:03:20 +01:00
|
|
|
return pipeline;
|
|
|
|
}
|
|
|
|
|
2021-04-01 06:36:22 +02:00
|
|
|
std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
|
|
|
|
ShaderPools& pools, const ComputePipelineCacheKey& key, Shader::Environment& env,
|
|
|
|
bool build_in_parallel) {
|
2021-03-23 01:03:20 +01:00
|
|
|
LOG_INFO(Render_Vulkan, "0x{:016x}", key.Hash());
|
2021-03-19 23:28:31 +01:00
|
|
|
|
2021-03-23 01:03:20 +01:00
|
|
|
Shader::Maxwell::Flow::CFG cfg{env, pools.flow_block, env.StartAddress()};
|
|
|
|
Shader::IR::Program program{TranslateProgram(pools.inst, pools.block, env, cfg)};
|
2021-03-19 23:28:31 +01:00
|
|
|
u32 binding{0};
|
2021-04-11 07:50:30 +02:00
|
|
|
const std::vector<u32> code{EmitSPIRV(base_profile, program, binding)};
|
|
|
|
device.SaveShader(code);
|
2021-03-31 02:28:00 +02:00
|
|
|
vk::ShaderModule spv_module{BuildShader(device, code)};
|
|
|
|
if (device.HasDebuggingToolAttached()) {
|
|
|
|
const auto name{fmt::format("{:016x}{:016x}", key.unique_hash[0], key.unique_hash[1])};
|
|
|
|
spv_module.SetObjectNameEXT(name.c_str());
|
|
|
|
}
|
2021-04-01 06:36:22 +02:00
|
|
|
Common::ThreadWorker* const thread_worker{build_in_parallel ? &workers : nullptr};
|
|
|
|
return std::make_unique<ComputePipeline>(device, descriptor_pool, update_descriptor_queue,
|
|
|
|
thread_worker, program.info, std::move(spv_module));
|
2020-01-07 01:55:06 +01:00
|
|
|
}
|
|
|
|
|
2021-03-24 05:33:45 +01:00
|
|
|
static Shader::AttributeType CastAttributeType(const FixedPipelineState::VertexAttribute& attr) {
|
2021-03-27 08:59:58 +01:00
|
|
|
if (attr.enabled == 0) {
|
|
|
|
return Shader::AttributeType::Disabled;
|
|
|
|
}
|
2021-03-24 05:33:45 +01:00
|
|
|
switch (attr.Type()) {
|
|
|
|
case Maxwell::VertexAttribute::Type::SignedNorm:
|
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedNorm:
|
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedScaled:
|
|
|
|
case Maxwell::VertexAttribute::Type::SignedScaled:
|
|
|
|
case Maxwell::VertexAttribute::Type::Float:
|
|
|
|
return Shader::AttributeType::Float;
|
|
|
|
case Maxwell::VertexAttribute::Type::SignedInt:
|
|
|
|
return Shader::AttributeType::SignedInt;
|
|
|
|
case Maxwell::VertexAttribute::Type::UnsignedInt:
|
|
|
|
return Shader::AttributeType::UnsignedInt;
|
|
|
|
}
|
|
|
|
return Shader::AttributeType::Float;
|
|
|
|
}
|
|
|
|
|
2021-04-14 06:04:59 +02:00
|
|
|
static std::vector<Shader::TransformFeedbackVarying> MakeTransformFeedbackVaryings(
|
|
|
|
const GraphicsPipelineCacheKey& key) {
|
|
|
|
static constexpr std::array VECTORS{
|
|
|
|
28, // gl_Position
|
|
|
|
32, // Generic 0
|
|
|
|
36, // Generic 1
|
|
|
|
40, // Generic 2
|
|
|
|
44, // Generic 3
|
|
|
|
48, // Generic 4
|
|
|
|
52, // Generic 5
|
|
|
|
56, // Generic 6
|
|
|
|
60, // Generic 7
|
|
|
|
64, // Generic 8
|
|
|
|
68, // Generic 9
|
|
|
|
72, // Generic 10
|
|
|
|
76, // Generic 11
|
|
|
|
80, // Generic 12
|
|
|
|
84, // Generic 13
|
|
|
|
88, // Generic 14
|
|
|
|
92, // Generic 15
|
|
|
|
96, // Generic 16
|
|
|
|
100, // Generic 17
|
|
|
|
104, // Generic 18
|
|
|
|
108, // Generic 19
|
|
|
|
112, // Generic 20
|
|
|
|
116, // Generic 21
|
|
|
|
120, // Generic 22
|
|
|
|
124, // Generic 23
|
|
|
|
128, // Generic 24
|
|
|
|
132, // Generic 25
|
|
|
|
136, // Generic 26
|
|
|
|
140, // Generic 27
|
|
|
|
144, // Generic 28
|
|
|
|
148, // Generic 29
|
|
|
|
152, // Generic 30
|
|
|
|
156, // Generic 31
|
|
|
|
160, // gl_FrontColor
|
|
|
|
164, // gl_FrontSecondaryColor
|
|
|
|
160, // gl_BackColor
|
|
|
|
164, // gl_BackSecondaryColor
|
|
|
|
192, // gl_TexCoord[0]
|
|
|
|
196, // gl_TexCoord[1]
|
|
|
|
200, // gl_TexCoord[2]
|
|
|
|
204, // gl_TexCoord[3]
|
|
|
|
208, // gl_TexCoord[4]
|
|
|
|
212, // gl_TexCoord[5]
|
|
|
|
216, // gl_TexCoord[6]
|
|
|
|
220, // gl_TexCoord[7]
|
|
|
|
};
|
|
|
|
std::vector<Shader::TransformFeedbackVarying> xfb(256);
|
|
|
|
for (size_t buffer = 0; buffer < Maxwell::NumTransformFeedbackBuffers; ++buffer) {
|
|
|
|
const auto& locations = key.state.xfb_state.varyings[buffer];
|
|
|
|
const auto& layout = key.state.xfb_state.layouts[buffer];
|
|
|
|
const u32 varying_count = layout.varying_count;
|
|
|
|
u32 highest = 0;
|
|
|
|
for (u32 offset = 0; offset < varying_count; ++offset) {
|
|
|
|
const u32 base_offset = offset;
|
|
|
|
const u8 location = locations[offset];
|
|
|
|
|
|
|
|
Shader::TransformFeedbackVarying varying;
|
|
|
|
varying.buffer = layout.stream;
|
|
|
|
varying.stride = layout.stride;
|
|
|
|
varying.offset = offset * 4;
|
|
|
|
varying.components = 1;
|
|
|
|
|
|
|
|
if (std::ranges::find(VECTORS, Common::AlignDown(location, 4)) != VECTORS.end()) {
|
|
|
|
UNIMPLEMENTED_IF_MSG(location % 4 != 0, "Unaligned TFB");
|
|
|
|
|
|
|
|
const u8 base_index = location / 4;
|
|
|
|
while (offset + 1 < varying_count && base_index == locations[offset + 1] / 4) {
|
|
|
|
++offset;
|
|
|
|
++varying.components;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
xfb[location] = varying;
|
|
|
|
highest = std::max(highest, (base_offset + varying.components) * 4);
|
|
|
|
}
|
|
|
|
UNIMPLEMENTED_IF(highest != layout.stride);
|
|
|
|
}
|
|
|
|
return xfb;
|
|
|
|
}
|
|
|
|
|
2021-03-24 05:33:45 +01:00
|
|
|
Shader::Profile PipelineCache::MakeProfile(const GraphicsPipelineCacheKey& key,
|
2021-04-13 00:41:22 +02:00
|
|
|
const Shader::IR::Program& program) {
|
2021-03-24 05:33:45 +01:00
|
|
|
Shader::Profile profile{base_profile};
|
2021-04-13 00:41:22 +02:00
|
|
|
|
|
|
|
const Shader::Stage stage{program.stage};
|
|
|
|
const bool has_geometry{key.unique_hashes[4] != u128{}};
|
|
|
|
const bool gl_ndc{key.state.ndc_minus_one_to_one != 0};
|
|
|
|
const float point_size{Common::BitCast<float>(key.state.point_size)};
|
|
|
|
switch (stage) {
|
|
|
|
case Shader::Stage::VertexB:
|
|
|
|
if (!has_geometry) {
|
|
|
|
if (key.state.topology == Maxwell::PrimitiveTopology::Points) {
|
|
|
|
profile.fixed_state_point_size = point_size;
|
|
|
|
}
|
2021-04-14 06:04:59 +02:00
|
|
|
if (key.state.xfb_enabled != 0) {
|
|
|
|
profile.xfb_varyings = MakeTransformFeedbackVaryings(key);
|
|
|
|
}
|
2021-04-13 00:41:22 +02:00
|
|
|
profile.convert_depth_mode = gl_ndc;
|
2021-03-30 08:58:46 +02:00
|
|
|
}
|
2021-03-24 05:33:45 +01:00
|
|
|
std::ranges::transform(key.state.attributes, profile.generic_input_types.begin(),
|
|
|
|
&CastAttributeType);
|
2021-04-13 00:41:22 +02:00
|
|
|
break;
|
2021-04-16 03:46:11 +02:00
|
|
|
case Shader::Stage::TessellationEval:
|
|
|
|
// We have to flip tessellation clockwise for some reason...
|
|
|
|
profile.tess_clockwise = key.state.tessellation_clockwise == 0;
|
|
|
|
profile.tess_primitive = [&key] {
|
|
|
|
const u32 raw{key.state.tessellation_primitive.Value()};
|
|
|
|
switch (static_cast<Maxwell::TessellationPrimitive>(raw)) {
|
|
|
|
case Maxwell::TessellationPrimitive::Isolines:
|
|
|
|
return Shader::TessPrimitive::Isolines;
|
|
|
|
case Maxwell::TessellationPrimitive::Triangles:
|
|
|
|
return Shader::TessPrimitive::Triangles;
|
|
|
|
case Maxwell::TessellationPrimitive::Quads:
|
|
|
|
return Shader::TessPrimitive::Quads;
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
return Shader::TessPrimitive::Triangles;
|
|
|
|
}();
|
|
|
|
profile.tess_spacing = [&] {
|
|
|
|
const u32 raw{key.state.tessellation_spacing};
|
|
|
|
switch (static_cast<Maxwell::TessellationSpacing>(raw)) {
|
|
|
|
case Maxwell::TessellationSpacing::Equal:
|
|
|
|
return Shader::TessSpacing::Equal;
|
|
|
|
case Maxwell::TessellationSpacing::FractionalOdd:
|
|
|
|
return Shader::TessSpacing::FractionalOdd;
|
|
|
|
case Maxwell::TessellationSpacing::FractionalEven:
|
|
|
|
return Shader::TessSpacing::FractionalEven;
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
return Shader::TessSpacing::Equal;
|
|
|
|
}();
|
|
|
|
break;
|
2021-04-13 00:41:22 +02:00
|
|
|
case Shader::Stage::Geometry:
|
|
|
|
if (program.output_topology == Shader::OutputTopology::PointList) {
|
|
|
|
profile.fixed_state_point_size = point_size;
|
|
|
|
}
|
2021-04-14 06:04:59 +02:00
|
|
|
if (key.state.xfb_enabled != 0) {
|
|
|
|
profile.xfb_varyings = MakeTransformFeedbackVaryings(key);
|
|
|
|
}
|
2021-04-13 00:41:22 +02:00
|
|
|
profile.convert_depth_mode = gl_ndc;
|
|
|
|
break;
|
2021-04-14 06:32:18 +02:00
|
|
|
case Shader::Stage::Fragment:
|
|
|
|
profile.alpha_test_func = MaxwellToCompareFunction(
|
|
|
|
key.state.UnpackComparisonOp(key.state.alpha_test_func.Value()));
|
|
|
|
profile.alpha_test_reference = Common::BitCast<float>(key.state.alpha_test_ref);
|
|
|
|
break;
|
2021-04-13 00:41:22 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (key.state.topology) {
|
|
|
|
case Maxwell::PrimitiveTopology::Points:
|
|
|
|
profile.input_topology = Shader::InputTopology::Points;
|
|
|
|
break;
|
|
|
|
case Maxwell::PrimitiveTopology::Lines:
|
|
|
|
case Maxwell::PrimitiveTopology::LineLoop:
|
|
|
|
case Maxwell::PrimitiveTopology::LineStrip:
|
|
|
|
profile.input_topology = Shader::InputTopology::Lines;
|
|
|
|
break;
|
|
|
|
case Maxwell::PrimitiveTopology::Triangles:
|
|
|
|
case Maxwell::PrimitiveTopology::TriangleStrip:
|
|
|
|
case Maxwell::PrimitiveTopology::TriangleFan:
|
|
|
|
case Maxwell::PrimitiveTopology::Quads:
|
|
|
|
case Maxwell::PrimitiveTopology::QuadStrip:
|
|
|
|
case Maxwell::PrimitiveTopology::Polygon:
|
|
|
|
case Maxwell::PrimitiveTopology::Patches:
|
|
|
|
profile.input_topology = Shader::InputTopology::Triangles;
|
|
|
|
break;
|
|
|
|
case Maxwell::PrimitiveTopology::LinesAdjacency:
|
|
|
|
case Maxwell::PrimitiveTopology::LineStripAdjacency:
|
|
|
|
profile.input_topology = Shader::InputTopology::LinesAdjacency;
|
|
|
|
break;
|
|
|
|
case Maxwell::PrimitiveTopology::TrianglesAdjacency:
|
|
|
|
case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
|
|
|
|
profile.input_topology = Shader::InputTopology::TrianglesAdjacency;
|
|
|
|
break;
|
2021-03-24 05:33:45 +01:00
|
|
|
}
|
2021-04-13 21:56:22 +02:00
|
|
|
profile.force_early_z = key.state.early_z != 0;
|
2021-04-16 23:52:58 +02:00
|
|
|
profile.y_negate = key.state.y_negate != 0;
|
2021-03-24 05:33:45 +01:00
|
|
|
return profile;
|
|
|
|
}
|
|
|
|
|
2020-01-07 01:18:38 +01:00
|
|
|
} // namespace Vulkan
|