2019-09-23 19:02:02 +01:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2019-09-25 23:19:41 +01:00
|
|
|
#include <algorithm>
|
2019-11-27 10:53:40 +00:00
|
|
|
#include <tuple>
|
2019-11-27 10:51:13 +00:00
|
|
|
|
2020-03-02 04:08:10 +00:00
|
|
|
#include "common/assert.h"
|
2019-09-23 19:02:02 +01:00
|
|
|
#include "common/common_types.h"
|
2020-02-29 06:49:51 +00:00
|
|
|
#include "video_core/engines/kepler_compute.h"
|
2019-09-23 19:02:02 +01:00
|
|
|
#include "video_core/engines/maxwell_3d.h"
|
2019-11-18 21:35:21 +00:00
|
|
|
#include "video_core/engines/shader_type.h"
|
2020-02-28 23:53:10 +00:00
|
|
|
#include "video_core/shader/registry.h"
|
2019-09-23 19:02:02 +01:00
|
|
|
|
|
|
|
namespace VideoCommon::Shader {
|
|
|
|
|
2020-02-29 06:49:51 +00:00
|
|
|
using Tegra::Engines::ConstBufferEngineInterface;
|
2019-09-25 23:19:41 +01:00
|
|
|
using Tegra::Engines::SamplerDescriptor;
|
2020-02-29 06:49:51 +00:00
|
|
|
using Tegra::Engines::ShaderType;
|
2019-09-25 23:19:41 +01:00
|
|
|
|
2020-02-29 06:49:51 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
GraphicsInfo MakeGraphicsInfo(ShaderType shader_stage, ConstBufferEngineInterface& engine) {
|
|
|
|
if (shader_stage == ShaderType::Compute) {
|
|
|
|
return {};
|
|
|
|
}
|
2020-09-23 20:06:21 +01:00
|
|
|
|
|
|
|
auto& graphics = dynamic_cast<Tegra::Engines::Maxwell3D&>(engine);
|
|
|
|
|
|
|
|
return {
|
|
|
|
.tfb_layouts = graphics.regs.tfb_layouts,
|
|
|
|
.tfb_varying_locs = graphics.regs.tfb_varying_locs,
|
|
|
|
.primitive_topology = graphics.regs.draw.topology,
|
|
|
|
.tessellation_primitive = graphics.regs.tess_mode.prim,
|
|
|
|
.tessellation_spacing = graphics.regs.tess_mode.spacing,
|
|
|
|
.tfb_enabled = graphics.regs.tfb_enabled != 0,
|
|
|
|
.tessellation_clockwise = graphics.regs.tess_mode.cw.Value() != 0,
|
|
|
|
};
|
2020-02-29 06:49:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ComputeInfo MakeComputeInfo(ShaderType shader_stage, ConstBufferEngineInterface& engine) {
|
|
|
|
if (shader_stage != ShaderType::Compute) {
|
|
|
|
return {};
|
|
|
|
}
|
2020-09-23 20:06:21 +01:00
|
|
|
|
|
|
|
auto& compute = dynamic_cast<Tegra::Engines::KeplerCompute&>(engine);
|
2020-02-29 06:49:51 +00:00
|
|
|
const auto& launch = compute.launch_description;
|
|
|
|
|
2020-09-23 20:06:21 +01:00
|
|
|
return {
|
|
|
|
.workgroup_size = {launch.block_dim_x, launch.block_dim_y, launch.block_dim_z},
|
|
|
|
.shared_memory_size_in_words = launch.shared_alloc,
|
|
|
|
.local_memory_size_in_words = launch.local_pos_alloc,
|
|
|
|
};
|
2020-02-29 06:49:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // Anonymous namespace
|
|
|
|
|
|
|
|
Registry::Registry(Tegra::Engines::ShaderType shader_stage, const SerializedRegistryInfo& info)
|
|
|
|
: stage{shader_stage}, stored_guest_driver_profile{info.guest_driver_profile},
|
|
|
|
bound_buffer{info.bound_buffer}, graphics_info{info.graphics}, compute_info{info.compute} {}
|
2019-09-23 19:02:02 +01:00
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
Registry::Registry(Tegra::Engines::ShaderType shader_stage,
|
|
|
|
Tegra::Engines::ConstBufferEngineInterface& engine)
|
2020-02-29 06:49:51 +00:00
|
|
|
: stage{shader_stage}, engine{&engine}, bound_buffer{engine.GetBoundBuffer()},
|
|
|
|
graphics_info{MakeGraphicsInfo(shader_stage, engine)}, compute_info{MakeComputeInfo(
|
|
|
|
shader_stage, engine)} {}
|
2019-09-23 19:02:02 +01:00
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
Registry::~Registry() = default;
|
2019-10-17 15:35:16 +01:00
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
std::optional<u32> Registry::ObtainKey(u32 buffer, u32 offset) {
|
2019-09-23 19:02:02 +01:00
|
|
|
const std::pair<u32, u32> key = {buffer, offset};
|
2019-09-25 23:19:41 +01:00
|
|
|
const auto iter = keys.find(key);
|
|
|
|
if (iter != keys.end()) {
|
|
|
|
return iter->second;
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
if (!engine) {
|
2019-10-17 15:35:16 +01:00
|
|
|
return std::nullopt;
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
const u32 value = engine->AccessConstBuffer32(stage, buffer, offset);
|
|
|
|
keys.emplace(key, value);
|
|
|
|
return value;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
std::optional<SamplerDescriptor> Registry::ObtainBoundSampler(u32 offset) {
|
2019-09-25 14:53:18 +01:00
|
|
|
const u32 key = offset;
|
2019-09-25 23:19:41 +01:00
|
|
|
const auto iter = bound_samplers.find(key);
|
|
|
|
if (iter != bound_samplers.end()) {
|
|
|
|
return iter->second;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
if (!engine) {
|
2019-10-17 15:35:16 +01:00
|
|
|
return std::nullopt;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
const SamplerDescriptor value = engine->AccessBoundSampler(stage, offset);
|
|
|
|
bound_samplers.emplace(key, value);
|
|
|
|
return value;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
|
|
|
|
2020-06-05 03:03:49 +01:00
|
|
|
std::optional<Tegra::Engines::SamplerDescriptor> Registry::ObtainSeparateSampler(
|
|
|
|
std::pair<u32, u32> buffers, std::pair<u32, u32> offsets) {
|
|
|
|
SeparateSamplerKey key;
|
|
|
|
key.buffers = buffers;
|
|
|
|
key.offsets = offsets;
|
|
|
|
const auto iter = separate_samplers.find(key);
|
|
|
|
if (iter != separate_samplers.end()) {
|
|
|
|
return iter->second;
|
|
|
|
}
|
|
|
|
if (!engine) {
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
|
|
|
|
const u32 handle_1 = engine->AccessConstBuffer32(stage, key.buffers.first, key.offsets.first);
|
|
|
|
const u32 handle_2 = engine->AccessConstBuffer32(stage, key.buffers.second, key.offsets.second);
|
|
|
|
const SamplerDescriptor value = engine->AccessSampler(handle_1 | handle_2);
|
|
|
|
separate_samplers.emplace(key, value);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
std::optional<Tegra::Engines::SamplerDescriptor> Registry::ObtainBindlessSampler(u32 buffer,
|
|
|
|
u32 offset) {
|
2019-09-25 23:19:41 +01:00
|
|
|
const std::pair key = {buffer, offset};
|
|
|
|
const auto iter = bindless_samplers.find(key);
|
|
|
|
if (iter != bindless_samplers.end()) {
|
|
|
|
return iter->second;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
if (!engine) {
|
2019-10-17 15:35:16 +01:00
|
|
|
return std::nullopt;
|
2019-09-25 14:53:18 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
const SamplerDescriptor value = engine->AccessBindlessSampler(stage, buffer, offset);
|
|
|
|
bindless_samplers.emplace(key, value);
|
|
|
|
return value;
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
void Registry::InsertKey(u32 buffer, u32 offset, u32 value) {
|
2019-09-25 23:19:41 +01:00
|
|
|
keys.insert_or_assign({buffer, offset}, value);
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
void Registry::InsertBoundSampler(u32 offset, SamplerDescriptor sampler) {
|
2019-09-25 23:19:41 +01:00
|
|
|
bound_samplers.insert_or_assign(offset, sampler);
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
void Registry::InsertBindlessSampler(u32 buffer, u32 offset, SamplerDescriptor sampler) {
|
2019-09-25 23:19:41 +01:00
|
|
|
bindless_samplers.insert_or_assign({buffer, offset}, sampler);
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
bool Registry::IsConsistent() const {
|
2019-09-25 23:19:41 +01:00
|
|
|
if (!engine) {
|
2020-02-26 19:13:47 +00:00
|
|
|
return true;
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
2019-09-25 23:19:41 +01:00
|
|
|
return std::all_of(keys.begin(), keys.end(),
|
2019-09-26 04:23:08 +01:00
|
|
|
[this](const auto& pair) {
|
|
|
|
const auto [cbuf, offset] = pair.first;
|
|
|
|
const auto value = pair.second;
|
|
|
|
return value == engine->AccessConstBuffer32(stage, cbuf, offset);
|
2019-09-25 23:19:41 +01:00
|
|
|
}) &&
|
|
|
|
std::all_of(bound_samplers.begin(), bound_samplers.end(),
|
|
|
|
[this](const auto& sampler) {
|
|
|
|
const auto [key, value] = sampler;
|
2019-09-26 04:23:08 +01:00
|
|
|
return value == engine->AccessBoundSampler(stage, key);
|
2019-09-25 23:19:41 +01:00
|
|
|
}) &&
|
2019-09-26 04:23:08 +01:00
|
|
|
std::all_of(bindless_samplers.begin(), bindless_samplers.end(),
|
|
|
|
[this](const auto& sampler) {
|
|
|
|
const auto [cbuf, offset] = sampler.first;
|
|
|
|
const auto value = sampler.second;
|
|
|
|
return value == engine->AccessBindlessSampler(stage, cbuf, offset);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-02-28 23:53:10 +00:00
|
|
|
bool Registry::HasEqualKeys(const Registry& rhs) const {
|
2019-11-27 10:53:40 +00:00
|
|
|
return std::tie(keys, bound_samplers, bindless_samplers) ==
|
|
|
|
std::tie(rhs.keys, rhs.bound_samplers, rhs.bindless_samplers);
|
2019-09-23 19:02:02 +01:00
|
|
|
}
|
|
|
|
|
2020-03-02 04:08:10 +00:00
|
|
|
const GraphicsInfo& Registry::GetGraphicsInfo() const {
|
|
|
|
ASSERT(stage != Tegra::Engines::ShaderType::Compute);
|
|
|
|
return graphics_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ComputeInfo& Registry::GetComputeInfo() const {
|
|
|
|
ASSERT(stage == Tegra::Engines::ShaderType::Compute);
|
|
|
|
return compute_info;
|
|
|
|
}
|
|
|
|
|
2019-09-23 19:02:02 +01:00
|
|
|
} // namespace VideoCommon::Shader
|