lux/yuzu
1
0
Fork 0
mirror of https://git.h3cjp.net/H3cJP/yuzu.git synced 2024-12-23 19:46:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Address PR feedback from Rein

Browse source
This commit is contained in:
ameerj 2020-11-19 02:25:37 -05:00
parent 9014861858
commit 1dbf71ceb3
5 changed files with 31 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
View file

@ -61,8 +61,9 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
topology.Assign(regs.draw.topology); topology.Assign(regs.draw.topology);
alpha_raw = 0; alpha_raw = 0;
alpha_test_enabled.Assign(regs.alpha_test_enabled); const auto test_func =
alpha_test_func.Assign(PackComparisonOp(regs.alpha_test_func)); regs.alpha_test_enabled == 1 ? regs.alpha_test_func : Maxwell::ComparisonOp::Always;
alpha_test_func.Assign(PackComparisonOp(test_func));
std::memcpy(&alpha_test_ref, &regs.alpha_test_ref, sizeof(u32)); // TODO: C++20 std::bit_cast std::memcpy(&alpha_test_ref, &regs.alpha_test_ref, sizeof(u32)); // TODO: C++20 std::bit_cast
std::memcpy(&point_size, &regs.point_size, sizeof(point_size)); // TODO: C++20 std::bit_cast std::memcpy(&point_size, &regs.point_size, sizeof(point_size)); // TODO: C++20 std::bit_cast

3
src/video_core/renderer_vulkan/fixed_pipeline_state.h
View file

@ -188,11 +188,10 @@ struct FixedPipelineState {
BitField<24, 4, Maxwell::PrimitiveTopology> topology; BitField<24, 4, Maxwell::PrimitiveTopology> topology;
}; };
u32 alpha_test_ref; /// < Alpha test reference u32 alpha_test_ref; ///< Alpha test reference value
union { union {
u32 alpha_raw; u32 alpha_raw;
BitField<0, 3, u32> alpha_test_func; BitField<0, 3, u32> alpha_test_func;
BitField<3, 1, u32> alpha_test_enabled;
}; };
u32 point_size; u32 point_size;

10
src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
View file

@ -345,12 +345,10 @@ VKPipelineCache::DecompileShaders(const FixedPipelineState& fixed_state) {
specialization.ndc_minus_one_to_one = fixed_state.ndc_minus_one_to_one; specialization.ndc_minus_one_to_one = fixed_state.ndc_minus_one_to_one;
// Alpha test // Alpha test
if (fixed_state.alpha_test_enabled == 1) { specialization.alpha_test_func =
specialization.alpha_test_enabled = true; FixedPipelineState::UnpackComparisonOp(fixed_state.alpha_test_func.Value());
specialization.alpha_test_func = static_cast<u8>(fixed_state.alpha_test_func); // memcpy from u32 to float TODO: C++20 std::bit_cast
// memcpy from u32 to float TODO: C++20 std::bit_cast std::memcpy(&specialization.alpha_test_ref, &fixed_state.alpha_test_ref, sizeof(float));
std::memcpy(&specialization.alpha_test_ref, &fixed_state.alpha_test_ref, sizeof(float));
}
SPIRVProgram program; SPIRVProgram program;
std::vector<VkDescriptorSetLayoutBinding> bindings; std::vector<VkDescriptorSetLayoutBinding> bindings;

50
src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
View file

@ -2075,48 +2075,42 @@ private:
return {}; return {};
} }
void AlphaTest(const Id& pointer) { void AlphaTest(Id pointer) {
const Id true_label = OpLabel(); const Id true_label = OpLabel();
const Id skip_label = OpLabel(); const Id skip_label = OpLabel();
const Id alpha_reference = Constant(t_float, specialization.alpha_test_ref);
const Id alpha_value = OpLoad(t_float, pointer);
Id condition; Id condition;
using Compare = Maxwell::ComparisonOp;
switch (specialization.alpha_test_func) { switch (specialization.alpha_test_func) {
case VK_COMPARE_OP_NEVER: case Compare::NeverOld:
condition = Constant(t_float, false); // Never true condition = v_false; // Never true
break; break;
case VK_COMPARE_OP_LESS: case Compare::LessOld:
condition = OpFOrdLessThan(t_bool, Constant(t_float, specialization.alpha_test_ref), condition = OpFOrdLessThan(t_bool, alpha_reference, alpha_value);
OpLoad(t_float, pointer));
break; break;
case VK_COMPARE_OP_EQUAL: case Compare::EqualOld:
condition = OpFOrdEqual(t_bool, Constant(t_float, specialization.alpha_test_ref), condition = OpFOrdEqual(t_bool, alpha_reference, alpha_value);
OpLoad(t_float, pointer));
break; break;
case VK_COMPARE_OP_LESS_OR_EQUAL: case Compare::LessEqualOld:
condition = OpFOrdLessThanEqual( condition = OpFOrdLessThanEqual(t_bool, alpha_reference, alpha_value);
t_bool, Constant(t_float, specialization.alpha_test_ref), OpLoad(t_float, pointer));
break; break;
case VK_COMPARE_OP_GREATER: case Compare::GreaterOld:
// Note: requires "Equal" to properly work for ssbu. perhaps a precision issue // Note: requires "Equal" to properly work for ssbu. perhaps a precision issue
condition = OpFOrdGreaterThanEqual( condition = OpFOrdGreaterThanEqual(t_bool, alpha_reference, alpha_value);
t_bool, Constant(t_float, specialization.alpha_test_ref), OpLoad(t_float, pointer));
break; break;
case VK_COMPARE_OP_NOT_EQUAL: case Compare::NotEqualOld:
// Note: not accurate when tested against a unit test // Note: not accurate when tested against a unit test
// TODO: confirm if used by games // TODO: confirm if used by games
condition = OpFOrdNotEqual(t_bool, Constant(t_float, specialization.alpha_test_ref), condition = OpFOrdNotEqual(t_bool, alpha_reference, alpha_value);
OpLoad(t_float, pointer));
break; break;
case VK_COMPARE_OP_GREATER_OR_EQUAL: case Compare::GreaterEqualOld:
condition = OpFOrdGreaterThanEqual( condition = OpFOrdGreaterThanEqual(t_bool, alpha_reference, alpha_value);
t_bool, Constant(t_float, specialization.alpha_test_ref), OpLoad(t_float, pointer));
break;
case VK_COMPARE_OP_ALWAYS:
condition = Constant(t_bool, true); // Always true
break; break;
case Compare::AlwaysOld:
return;
default: default:
LOG_WARNING(Render_Vulkan, "Unimplemented alpha test function"); UNREACHABLE();
condition = Constant(t_bool, true); // Always true
break;
} }
OpBranchConditional(condition, true_label, skip_label); OpBranchConditional(condition, true_label, skip_label);
AddLabel(true_label); AddLabel(true_label);
@ -2157,7 +2151,7 @@ private:
} }
const Id pointer = AccessElement(t_out_float, frag_colors[rt], component); const Id pointer = AccessElement(t_out_float, frag_colors[rt], component);
OpStore(pointer, SafeGetRegister(current_reg)); OpStore(pointer, SafeGetRegister(current_reg));
if (specialization.alpha_test_enabled && component == 3) { if (rt == 0 && component == 3) {
AlphaTest(pointer); AlphaTest(pointer);
} }
++current_reg; ++current_reg;

3
src/video_core/renderer_vulkan/vk_shader_decompiler.h
View file

@ -95,9 +95,8 @@ struct Specialization final {
std::bitset<Maxwell::NumVertexAttributes> enabled_attributes; std::bitset<Maxwell::NumVertexAttributes> enabled_attributes;
std::array<Maxwell::VertexAttribute::Type, Maxwell::NumVertexAttributes> attribute_types{}; std::array<Maxwell::VertexAttribute::Type, Maxwell::NumVertexAttributes> attribute_types{};
bool ndc_minus_one_to_one{}; bool ndc_minus_one_to_one{};
bool alpha_test_enabled{};
float alpha_test_ref{}; float alpha_test_ref{};
u8 alpha_test_func{}; Maxwell::ComparisonOp alpha_test_func{};
}; };
// Old gcc versions don't consider this trivially copyable. // Old gcc versions don't consider this trivially copyable.
// static_assert(std::is_trivially_copyable_v<Specialization>); // static_assert(std::is_trivially_copyable_v<Specialization>);