summaryrefslogtreecommitdiffstats
path: root/src/video_core/shader
diff options
context:
space:
mode:
Diffstat (limited to 'src/video_core/shader')
-rw-r--r--src/video_core/shader/const_buffer_locker.cpp110
-rw-r--r--src/video_core/shader/const_buffer_locker.h60
-rw-r--r--src/video_core/shader/decode/texture.cpp72
-rw-r--r--src/video_core/shader/shader_ir.h12
4 files changed, 212 insertions, 42 deletions
diff --git a/src/video_core/shader/const_buffer_locker.cpp b/src/video_core/shader/const_buffer_locker.cpp
index 6a9e0ed5e..4f5de8ae9 100644
--- a/src/video_core/shader/const_buffer_locker.cpp
+++ b/src/video_core/shader/const_buffer_locker.cpp
@@ -27,43 +27,121 @@ void ConstBufferLocker::SetEngine(Tegra::Engines::ConstBufferEngineInterface* en
}
std::optional<u32> ConstBufferLocker::ObtainKey(u32 buffer, u32 offset) {
+ if (!keys) {
+ keys = std::make_shared<KeyMap>();
+ }
+ auto& key_map = *keys;
const std::pair<u32, u32> key = {buffer, offset};
- const auto iter = keys.find(key);
- if (iter != keys.end()) {
+ const auto iter = key_map.find(key);
+ if (iter != key_map.end()) {
return {iter->second};
}
if (!IsEngineSet()) {
return {};
}
const u32 value = engine->AccessConstBuffer32(shader_stage, buffer, offset);
- keys.emplace(key, value);
+ key_map.emplace(key, value);
+ return {value};
+}
+
+std::optional<Tegra::Engines::SamplerDescriptor> ConstBufferLocker::ObtainBoundSampler(u32 offset) {
+ if (!bound_samplers) {
+ bound_samplers = std::make_shared<BoundSamplerMap>();
+ }
+ auto& key_map = *bound_samplers;
+ const u32 key = offset;
+ const auto iter = key_map.find(key);
+ if (iter != key_map.end()) {
+ return {iter->second};
+ }
+ if (!IsEngineSet()) {
+ return {};
+ }
+ const Tegra::Engines::SamplerDescriptor value =
+ engine->AccessBoundSampler(shader_stage, offset);
+ key_map.emplace(key, value);
+ return {value};
+}
+
+std::optional<Tegra::Engines::SamplerDescriptor> ConstBufferLocker::ObtainBindlessSampler(
+ u32 buffer, u32 offset) {
+ if (!bindless_samplers) {
+ bindless_samplers = std::make_shared<BindlessSamplerMap>();
+ }
+ auto& key_map = *bindless_samplers;
+ const std::pair<u32, u32> key = {buffer, offset};
+ const auto iter = key_map.find(key);
+ if (iter != key_map.end()) {
+ return {iter->second};
+ }
+ if (!IsEngineSet()) {
+ return {};
+ }
+ const Tegra::Engines::SamplerDescriptor value =
+ engine->AccessBindlessSampler(shader_stage, buffer, offset);
+ key_map.emplace(key, value);
return {value};
}
void ConstBufferLocker::InsertKey(u32 buffer, u32 offset, u32 value) {
+ if (!keys) {
+ keys = std::make_shared<KeyMap>();
+ }
const std::pair<u32, u32> key = {buffer, offset};
- keys[key] = value;
+ (*keys)[key] = value;
}
-u32 ConstBufferLocker::NumKeys() const {
- return keys.size();
+void ConstBufferLocker::InsertBoundSampler(u32 offset, Tegra::Engines::SamplerDescriptor sampler) {
+ if (!bound_samplers) {
+ bound_samplers = std::make_shared<BoundSamplerMap>();
+ }
+ (*bound_samplers)[offset] = sampler;
}
-const std::unordered_map<std::pair<u32, u32>, u32, Common::PairHash>&
-ConstBufferLocker::AccessKeys() const {
- return keys;
+void ConstBufferLocker::InsertBindlessSampler(u32 buffer, u32 offset,
+ Tegra::Engines::SamplerDescriptor sampler) {
+ if (!bindless_samplers) {
+ bindless_samplers = std::make_shared<BindlessSamplerMap>();
+ }
+ const std::pair<u32, u32> key = {buffer, offset};
+ (*bindless_samplers)[key] = sampler;
}
-bool ConstBufferLocker::AreKeysConsistant() const {
+bool ConstBufferLocker::IsConsistant() const {
if (!IsEngineSet()) {
return false;
}
- for (const auto& key_val : keys) {
- const std::pair<u32, u32> key = key_val.first;
- const u32 value = key_val.second;
- const u32 other_value = engine->AccessConstBuffer32(shader_stage, key.first, key.second);
- if (other_value != value) {
- return false;
+ if (keys) {
+ for (const auto& key_val : *keys) {
+ const std::pair<u32, u32> key = key_val.first;
+ const u32 value = key_val.second;
+ const u32 other_value =
+ engine->AccessConstBuffer32(shader_stage, key.first, key.second);
+ if (other_value != value) {
+ return false;
+ }
+ }
+ }
+ if (bound_samplers) {
+ for (const auto& sampler_val : *bound_samplers) {
+ const u32 key = sampler_val.first;
+ const Tegra::Engines::SamplerDescriptor value = sampler_val.second;
+ const Tegra::Engines::SamplerDescriptor other_value =
+ engine->AccessBoundSampler(shader_stage, key);
+ if (other_value.raw != value.raw) {
+ return false;
+ }
+ }
+ }
+ if (bindless_samplers) {
+ for (const auto& sampler_val : *bindless_samplers) {
+ const std::pair<u32, u32> key = sampler_val.first;
+ const Tegra::Engines::SamplerDescriptor value = sampler_val.second;
+ const Tegra::Engines::SamplerDescriptor other_value =
+ engine->AccessBindlessSampler(shader_stage, key.first, key.second);
+ if (other_value.raw != value.raw) {
+ return false;
+ }
}
}
return true;
diff --git a/src/video_core/shader/const_buffer_locker.h b/src/video_core/shader/const_buffer_locker.h
index 39e62584d..0bc257781 100644
--- a/src/video_core/shader/const_buffer_locker.h
+++ b/src/video_core/shader/const_buffer_locker.h
@@ -11,6 +11,11 @@
namespace VideoCommon::Shader {
+using KeyMap = std::unordered_map<std::pair<u32, u32>, u32, Common::PairHash>;
+using BoundSamplerMap = std::unordered_map<u32, Tegra::Engines::SamplerDescriptor>;
+using BindlessSamplerMap =
+ std::unordered_map<std::pair<u32, u32>, Tegra::Engines::SamplerDescriptor, Common::PairHash>;
+
class ConstBufferLocker {
public:
explicit ConstBufferLocker(Tegra::Engines::ShaderType shader_stage);
@@ -29,22 +34,67 @@ public:
// registered value, if not it will obtain it from maxwell3d and register it.
std::optional<u32> ObtainKey(u32 buffer, u32 offset);
+ std::optional<Tegra::Engines::SamplerDescriptor> ObtainBoundSampler(u32 offset);
+
+ std::optional<Tegra::Engines::SamplerDescriptor> ObtainBindlessSampler(u32 buffer, u32 offset);
+
// Manually inserts a key.
void InsertKey(u32 buffer, u32 offset, u32 value);
+ void InsertBoundSampler(u32 offset, Tegra::Engines::SamplerDescriptor sampler);
+
+ void InsertBindlessSampler(u32 buffer, u32 offset, Tegra::Engines::SamplerDescriptor sampler);
+
// Retrieves the number of keys registered.
- u32 NumKeys() const;
+ std::size_t NumKeys() const {
+ if (!keys) {
+ return 0;
+ }
+ return keys->size();
+ }
+
+ std::size_t NumBoundSamplers() const {
+ if (!bound_samplers) {
+ return 0;
+ }
+ return bound_samplers->size();
+ }
+
+ std::size_t NumBindlessSamplers() const {
+ if (!bindless_samplers) {
+ return 0;
+ }
+ return bindless_samplers->size();
+ }
// Gives an accessor to the key's database.
- const std::unordered_map<std::pair<u32, u32>, u32, Common::PairHash>& AccessKeys() const;
+ // Pre: NumKeys > 0
+ const KeyMap& AccessKeys() const {
+ return *keys;
+ }
+
+ // Gives an accessor to the sampler's database.
+ // Pre: NumBindlessSamplers > 0
+ const BoundSamplerMap& AccessBoundSamplers() const {
+ return *bound_samplers;
+ }
+
+ // Gives an accessor to the sampler's database.
+ // Pre: NumBindlessSamplers > 0
+ const BindlessSamplerMap& AccessBindlessSamplers() const {
+ return *bindless_samplers;
+ }
- // Checks keys against maxwell3d's current const buffers. Returns true if they
+ // Checks keys & samplers against engine's current const buffers. Returns true if they
// are the same value, false otherwise;
- bool AreKeysConsistant() const;
+ bool IsConsistant() const;
private:
Tegra::Engines::ConstBufferEngineInterface* engine;
Tegra::Engines::ShaderType shader_stage;
- std::unordered_map<std::pair<u32, u32>, u32, Common::PairHash> keys{};
+ // All containers are lazy initialized as most shaders don't use them.
+ std::shared_ptr<KeyMap> keys{};
+ std::shared_ptr<BoundSamplerMap> bound_samplers{};
+ std::shared_ptr<BindlessSamplerMap> bindless_samplers{};
};
} // namespace VideoCommon::Shader
diff --git a/src/video_core/shader/decode/texture.cpp b/src/video_core/shader/decode/texture.cpp
index 0b934a069..c369e23ad 100644
--- a/src/video_core/shader/decode/texture.cpp
+++ b/src/video_core/shader/decode/texture.cpp
@@ -141,7 +141,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
const Node component = Immediate(static_cast<u32>(instr.tld4s.component));
const auto& sampler =
- GetSampler(instr.sampler, TextureType::Texture2D, false, depth_compare);
+ GetSampler(instr.sampler, {{TextureType::Texture2D, false, depth_compare}});
Node4 values;
for (u32 element = 0; element < values.size(); ++element) {
@@ -165,10 +165,7 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
// Sadly, not all texture instructions specify the type of texture their sampler
// uses. This must be fixed at a later instance.
const auto& sampler =
- is_bindless
- ? GetBindlessSampler(instr.gpr8, Tegra::Shader::TextureType::Texture2D, false,
- false)
- : GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false, false);
+ is_bindless ? GetBindlessSampler(instr.gpr8, {}) : GetSampler(instr.sampler, {});
u32 indexer = 0;
switch (instr.txq.query_type) {
@@ -207,9 +204,9 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
auto texture_type = instr.tmml.texture_type.Value();
const bool is_array = instr.tmml.array != 0;
- const auto& sampler = is_bindless
- ? GetBindlessSampler(instr.gpr20, texture_type, is_array, false)
- : GetSampler(instr.sampler, texture_type, is_array, false);
+ const auto& sampler =
+ is_bindless ? GetBindlessSampler(instr.gpr20, {{texture_type, is_array, false}})
+ : GetSampler(instr.sampler, {{texture_type, is_array, false}});
std::vector<Node> coords;
@@ -285,10 +282,30 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
return pc;
}
-const Sampler& ShaderIR::GetSampler(const Tegra::Shader::Sampler& sampler, TextureType type,
- bool is_array, bool is_shadow) {
+const Sampler& ShaderIR::GetSampler(const Tegra::Shader::Sampler& sampler,
+ std::optional<SamplerInfo> sampler_info) {
const auto offset = static_cast<std::size_t>(sampler.index.Value());
+ Tegra::Shader::TextureType type;
+ bool is_array;
+ bool is_shadow;
+ if (sampler_info) {
+ type = sampler_info->type;
+ is_array = sampler_info->is_array;
+ is_shadow = sampler_info->is_shadow;
+ } else {
+ auto sampler = locker.ObtainBoundSampler(offset);
+ if (sampler) {
+ type = sampler->texture_type.Value();
+ is_array = sampler->is_array.Value() != 0;
+ is_shadow = sampler->is_shadow.Value() != 0;
+ } else {
+ type = Tegra::Shader::TextureType::Texture2D;
+ is_array = false;
+ is_shadow = false;
+ }
+ }
+
// If this sampler has already been used, return the existing mapping.
const auto itr =
std::find_if(used_samplers.begin(), used_samplers.end(),
@@ -305,13 +322,32 @@ const Sampler& ShaderIR::GetSampler(const Tegra::Shader::Sampler& sampler, Textu
return *used_samplers.emplace(entry).first;
}
-const Sampler& ShaderIR::GetBindlessSampler(const Tegra::Shader::Register& reg, TextureType type,
- bool is_array, bool is_shadow) {
+const Sampler& ShaderIR::GetBindlessSampler(const Tegra::Shader::Register& reg,
+ std::optional<SamplerInfo> sampler_info) {
const Node sampler_register = GetRegister(reg);
const auto [base_sampler, cbuf_index, cbuf_offset] =
TrackCbuf(sampler_register, global_code, static_cast<s64>(global_code.size()));
ASSERT(base_sampler != nullptr);
const auto cbuf_key = (static_cast<u64>(cbuf_index) << 32) | static_cast<u64>(cbuf_offset);
+ Tegra::Shader::TextureType type;
+ bool is_array;
+ bool is_shadow;
+ if (sampler_info) {
+ type = sampler_info->type;
+ is_array = sampler_info->is_array;
+ is_shadow = sampler_info->is_shadow;
+ } else {
+ auto sampler = locker.ObtainBindlessSampler(cbuf_index, cbuf_offset);
+ if (sampler) {
+ type = sampler->texture_type.Value();
+ is_array = sampler->is_array.Value() != 0;
+ is_shadow = sampler->is_shadow.Value() != 0;
+ } else {
+ type = Tegra::Shader::TextureType::Texture2D;
+ is_array = false;
+ is_shadow = false;
+ }
+ }
// If this sampler has already been used, return the existing mapping.
const auto itr =
@@ -411,9 +447,9 @@ Node4 ShaderIR::GetTextureCode(Instruction instr, TextureType texture_type,
(texture_type == TextureType::TextureCube && is_array && is_shadow),
"This method is not supported.");
- const auto& sampler = is_bindless
- ? GetBindlessSampler(*bindless_reg, texture_type, is_array, is_shadow)
- : GetSampler(instr.sampler, texture_type, is_array, is_shadow);
+ const auto& sampler =
+ is_bindless ? GetBindlessSampler(*bindless_reg, {{texture_type, is_array, is_shadow}})
+ : GetSampler(instr.sampler, {{texture_type, is_array, is_shadow}});
const bool lod_needed = process_mode == TextureProcessMode::LZ ||
process_mode == TextureProcessMode::LL ||
@@ -577,7 +613,7 @@ Node4 ShaderIR::GetTld4Code(Instruction instr, TextureType texture_type, bool de
dc = GetRegister(parameter_register++);
}
- const auto& sampler = GetSampler(instr.sampler, texture_type, is_array, depth_compare);
+ const auto& sampler = GetSampler(instr.sampler, {{texture_type, is_array, depth_compare}});
Node4 values;
for (u32 element = 0; element < values.size(); ++element) {
@@ -610,7 +646,7 @@ Node4 ShaderIR::GetTldCode(Tegra::Shader::Instruction instr) {
// const Node aoffi_register{is_aoffi ? GetRegister(gpr20_cursor++) : nullptr};
// const Node multisample{is_multisample ? GetRegister(gpr20_cursor++) : nullptr};
- const auto& sampler = GetSampler(instr.sampler, texture_type, is_array, false);
+ const auto& sampler = GetSampler(instr.sampler, {{texture_type, is_array, false}});
Node4 values;
for (u32 element = 0; element < values.size(); ++element) {
@@ -646,7 +682,7 @@ Node4 ShaderIR::GetTldsCode(Instruction instr, TextureType texture_type, bool is
// When lod is used always is in gpr20
const Node lod = lod_enabled ? GetRegister(instr.gpr20) : Immediate(0);
- const auto& sampler = GetSampler(instr.sampler, texture_type, is_array, false);
+ const auto& sampler = GetSampler(instr.sampler, {{texture_type, is_array, false}});
Node4 values;
for (u32 element = 0; element < values.size(); ++element) {
diff --git a/src/video_core/shader/shader_ir.h b/src/video_core/shader/shader_ir.h
index e3b568d3e..3a3e381d2 100644
--- a/src/video_core/shader/shader_ir.h
+++ b/src/video_core/shader/shader_ir.h
@@ -173,6 +173,13 @@ public:
private:
friend class ASTDecoder;
+
+ struct SamplerInfo {
+ Tegra::Shader::TextureType type;
+ bool is_array;
+ bool is_shadow;
+ };
+
void Decode();
NodeBlock DecodeRange(u32 begin, u32 end);
@@ -297,12 +304,11 @@ private:
/// Accesses a texture sampler
const Sampler& GetSampler(const Tegra::Shader::Sampler& sampler,
- Tegra::Shader::TextureType type, bool is_array, bool is_shadow);
+ std::optional<SamplerInfo> sampler_info);
// Accesses a texture sampler for a bindless texture.
const Sampler& GetBindlessSampler(const Tegra::Shader::Register& reg,
- Tegra::Shader::TextureType type, bool is_array,
- bool is_shadow);
+ std::optional<SamplerInfo> sampler_info);
/// Accesses an image.
Image& GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 22:22:21 +0100