2019-09-23 20:02:02 +02:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2019-09-26 00:19:41 +02:00
|
|
|
#include <algorithm>
|
2019-11-27 11:51:13 +01:00
|
|
|
|
2019-09-23 20:02:02 +02:00
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "video_core/engines/maxwell_3d.h"
|
2019-11-18 22:35:21 +01:00
|
|
|
#include "video_core/engines/shader_type.h"
|
2019-09-23 20:02:02 +02:00
|
|
|
#include "video_core/shader/const_buffer_locker.h"
|
|
|
|
|
|
|
|
namespace VideoCommon::Shader {
|
|
|
|
|
2019-09-26 00:19:41 +02:00
|
|
|
using Tegra::Engines::SamplerDescriptor;
|
|
|
|
|
2019-09-23 20:02:02 +02:00
|
|
|
ConstBufferLocker::ConstBufferLocker(Tegra::Engines::ShaderType shader_stage)
|
2019-09-26 00:19:41 +02:00
|
|
|
: stage{shader_stage} {}
|
2019-09-23 20:02:02 +02:00
|
|
|
|
|
|
|
ConstBufferLocker::ConstBufferLocker(Tegra::Engines::ShaderType shader_stage,
|
2019-09-25 04:34:18 +02:00
|
|
|
Tegra::Engines::ConstBufferEngineInterface& engine)
|
2019-09-26 00:19:41 +02:00
|
|
|
: stage{shader_stage}, engine{&engine} {}
|
2019-09-23 20:02:02 +02:00
|
|
|
|
2019-10-17 16:35:16 +02:00
|
|
|
ConstBufferLocker::~ConstBufferLocker() = default;
|
|
|
|
|
2019-09-23 20:02:02 +02:00
|
|
|
std::optional<u32> ConstBufferLocker::ObtainKey(u32 buffer, u32 offset) {
|
|
|
|
const std::pair<u32, u32> key = {buffer, offset};
|
2019-09-26 00:19:41 +02:00
|
|
|
const auto iter = keys.find(key);
|
|
|
|
if (iter != keys.end()) {
|
|
|
|
return iter->second;
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
if (!engine) {
|
2019-10-17 16:35:16 +02:00
|
|
|
return std::nullopt;
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
const u32 value = engine->AccessConstBuffer32(stage, buffer, offset);
|
|
|
|
keys.emplace(key, value);
|
|
|
|
return value;
|
2019-09-25 15:53:18 +02:00
|
|
|
}
|
|
|
|
|
2019-09-26 00:19:41 +02:00
|
|
|
std::optional<SamplerDescriptor> ConstBufferLocker::ObtainBoundSampler(u32 offset) {
|
2019-09-25 15:53:18 +02:00
|
|
|
const u32 key = offset;
|
2019-09-26 00:19:41 +02:00
|
|
|
const auto iter = bound_samplers.find(key);
|
|
|
|
if (iter != bound_samplers.end()) {
|
|
|
|
return iter->second;
|
2019-09-25 15:53:18 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
if (!engine) {
|
2019-10-17 16:35:16 +02:00
|
|
|
return std::nullopt;
|
2019-09-25 15:53:18 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
const SamplerDescriptor value = engine->AccessBoundSampler(stage, offset);
|
|
|
|
bound_samplers.emplace(key, value);
|
|
|
|
return value;
|
2019-09-25 15:53:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
std::optional<Tegra::Engines::SamplerDescriptor> ConstBufferLocker::ObtainBindlessSampler(
|
|
|
|
u32 buffer, u32 offset) {
|
2019-09-26 00:19:41 +02: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 15:53:18 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
if (!engine) {
|
2019-10-17 16:35:16 +02:00
|
|
|
return std::nullopt;
|
2019-09-25 15:53:18 +02:00
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
const SamplerDescriptor value = engine->AccessBindlessSampler(stage, buffer, offset);
|
|
|
|
bindless_samplers.emplace(key, value);
|
|
|
|
return value;
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ConstBufferLocker::InsertKey(u32 buffer, u32 offset, u32 value) {
|
2019-09-26 00:19:41 +02:00
|
|
|
keys.insert_or_assign({buffer, offset}, value);
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
|
|
|
|
2019-09-26 00:19:41 +02:00
|
|
|
void ConstBufferLocker::InsertBoundSampler(u32 offset, SamplerDescriptor sampler) {
|
|
|
|
bound_samplers.insert_or_assign(offset, sampler);
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
|
|
|
|
2019-09-26 00:19:41 +02:00
|
|
|
void ConstBufferLocker::InsertBindlessSampler(u32 buffer, u32 offset, SamplerDescriptor sampler) {
|
|
|
|
bindless_samplers.insert_or_assign({buffer, offset}, sampler);
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
|
|
|
|
2019-09-25 21:03:13 +02:00
|
|
|
bool ConstBufferLocker::IsConsistent() const {
|
2019-09-26 00:19:41 +02:00
|
|
|
if (!engine) {
|
2019-09-23 20:02:02 +02:00
|
|
|
return false;
|
|
|
|
}
|
2019-09-26 00:19:41 +02:00
|
|
|
return std::all_of(keys.begin(), keys.end(),
|
2019-09-26 05:23:08 +02: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-26 00:19:41 +02:00
|
|
|
}) &&
|
|
|
|
std::all_of(bound_samplers.begin(), bound_samplers.end(),
|
|
|
|
[this](const auto& sampler) {
|
|
|
|
const auto [key, value] = sampler;
|
2019-09-26 05:23:08 +02:00
|
|
|
return value == engine->AccessBoundSampler(stage, key);
|
2019-09-26 00:19:41 +02:00
|
|
|
}) &&
|
2019-09-26 05:23:08 +02: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);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ConstBufferLocker::HasEqualKeys(const ConstBufferLocker& rhs) const {
|
|
|
|
return keys == rhs.keys && bound_samplers == rhs.bound_samplers &&
|
|
|
|
bindless_samplers == rhs.bindless_samplers;
|
2019-09-23 20:02:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace VideoCommon::Shader
|