archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-12 17:58:37 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

rsx: Fixups

Browse source 
- Improve vertex attribute layout format. Allows for full 16-bit attribute divisor
- Use actual pitch when declaring framebuffer rsx pitch instead of register value in case of swizzle? rendering
This commit is contained in:
kd-11 2018-11-01 00:25:59 +03:00 • committed by kd-11
parent 2e32777375
commit 846daadd5d
5 changed files with 77 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

42
rpcs3/Emu/RSX/Common/GLSLCommon.h
View file

@ -168,7 +168,7 @@ namespace glsl
" int swap_bytes;\n" " int swap_bytes;\n"
" int is_volatile;\n" " int is_volatile;\n"
" int frequency;\n" " int frequency;\n"
" int divisor;\n" " int modulo;\n"
"};\n\n" "};\n\n"
"uint get_bits(uvec4 v, int swap)\n" "uint get_bits(uvec4 v, int swap)\n"
@ -291,22 +291,24 @@ namespace glsl
"{\n" "{\n"
" // Each descriptor is 64 bits wide\n" " // Each descriptor is 64 bits wide\n"
" // [0-8] attribute stride\n" " // [0-8] attribute stride\n"
" // [8-20] attribute divisor\n" " // [8-24] attribute divisor\n"
" // [20-21] swap bytes flag\n"
" // [21-22] volatile flag\n"
" // [22-24] frequency op\n"
" // [24-27] attribute type\n" " // [24-27] attribute type\n"
" // [27-30] attribute size\n" " // [27-30] attribute size\n"
" // [32-60] starting offset\n"
" // [60-61] swap bytes flag\n"
" // [61-62] volatile flag\n"
" // [62-63] modulo enable flag\n"
" attribute_desc result;\n" " attribute_desc result;\n"
" int attribute_flags = input_attributes[location].x;\n" " int attrib0 = input_attributes[location].x;\n"
" result.stride = attribute_flags & 0xFF;\n" " int attrib1 = input_attributes[location].y;\n"
" result.divisor = (attribute_flags >> 8) & 0xFFF;\n" " result.stride = attrib0 & 0xFF;\n"
" result.swap_bytes = (attribute_flags >> 20) & 0x1;\n" " result.frequency = (attrib0 >> 8) & 0xFFFF;\n"
" result.is_volatile = (attribute_flags >> 21) & 0x1;\n" " result.type = (attrib0 >> 24) & 0x7;\n"
" result.frequency = (attribute_flags >> 22) & 0x3;\n" " result.attribute_size = (attrib0 >> 27) & 0x7;\n"
" result.type = (attribute_flags >> 24) & 0x7;\n" " result.starting_offset = (attrib1 & 0x1FFFFFFF);\n"
" result.attribute_size = (attribute_flags >> 27) & 0x7;\n" " result.swap_bytes = (attrib1 >> 29) & 0x1;\n"
" result.starting_offset = input_attributes[location].y;\n" " result.is_volatile = (attrib1 >> 30) & 0x1;\n"
" result.modulo = (attrib1 >> 31) & 0x3;\n"
" return result;\n" " return result;\n"
"}\n\n" "}\n\n"
@ -334,15 +336,17 @@ namespace glsl
" {\n" " {\n"
" vertex_id = 0;\n" " vertex_id = 0;\n"
" }\n" " }\n"
" else if (desc.frequency == 2)\n" " else if (desc.frequency > 1)\n"
" {\n" " {\n"
" //if a vertex modifier is active; vertex_base must be 0 and is ignored\n" " //if a vertex modifier is active; vertex_base must be 0 and is ignored\n"
" vertex_id = " << vertex_id_name << " / desc.divisor;\n" " if (desc.modulo != 0)\n"
" {\n"
" vertex_id = " << vertex_id_name << " % desc.frequency;\n"
" }\n" " }\n"
" else if (desc.frequency == 3)\n" " else\n"
" {\n" " {\n"
" //if a vertex modifier is active; vertex_base must be 0 and is ignored\n" " vertex_id = " << vertex_id_name << " / desc.frequency; \n"
" vertex_id = " << vertex_id_name << " % desc.divisor;\n" " }\n"
" }\n" " }\n"
"\n" "\n"
" if (desc.is_volatile != 0)\n" " if (desc.is_volatile != 0)\n"

11
rpcs3/Emu/RSX/GL/GLGSRender.cpp
View file

@ -1301,17 +1301,16 @@ void GLGSRender::load_program_env()
if (update_vertex_env) if (update_vertex_env)
{ {
// Vertex state // Vertex state
auto mapping = m_vertex_env_buffer->alloc_from_heap(160, m_uniform_buffer_offset_align); auto mapping = m_vertex_env_buffer->alloc_from_heap(144, m_uniform_buffer_offset_align);
auto buf = static_cast<u8*>(mapping.first); auto buf = static_cast<u8*>(mapping.first);
fill_scale_offset_data(buf, false); fill_scale_offset_data(buf, false);
fill_user_clip_data(buf + 64); fill_user_clip_data(buf + 64);
*(reinterpret_cast<u32*>(buf + 128)) = rsx::method_registers.transform_branch_bits(); *(reinterpret_cast<u32*>(buf + 128)) = rsx::method_registers.transform_branch_bits();
*(reinterpret_cast<u32*>(buf + 132)) = 0; // Reserved *(reinterpret_cast<f32*>(buf + 132)) = rsx::method_registers.point_size();
*(reinterpret_cast<f32*>(buf + 136)) = rsx::method_registers.point_size(); *(reinterpret_cast<f32*>(buf + 136)) = rsx::method_registers.clip_min();
*(reinterpret_cast<f32*>(buf + 140)) = rsx::method_registers.clip_min(); *(reinterpret_cast<f32*>(buf + 140)) = rsx::method_registers.clip_max();
*(reinterpret_cast<f32*>(buf + 144)) = rsx::method_registers.clip_max();
m_vertex_env_buffer->bind_range(0, mapping.second, 160); m_vertex_env_buffer->bind_range(0, mapping.second, 144);
} }
if (update_transform_constants) if (update_transform_constants)

4
rpcs3/Emu/RSX/GL/GLRenderTargets.cpp
View file

@ -247,7 +247,7 @@ void GLGSRender::init_buffers(rsx::framebuffer_creation_context context, bool sk
auto rtt = std::get<1>(m_rtts.m_bound_render_targets[i]); auto rtt = std::get<1>(m_rtts.m_bound_render_targets[i]);
color_targets[i] = rtt->id(); color_targets[i] = rtt->id();
rtt->set_rsx_pitch(layout.color_pitch[i]); rtt->set_rsx_pitch(layout.actual_color_pitch[i]);
m_surface_info[i] = { layout.color_addresses[i], layout.actual_color_pitch[i], false, layout.color_format, layout.depth_format, layout.width, layout.height }; m_surface_info[i] = { layout.color_addresses[i], layout.actual_color_pitch[i], false, layout.color_format, layout.depth_format, layout.width, layout.height };
rtt->tile = find_tile(color_offsets[i], color_locations[i]); rtt->tile = find_tile(color_offsets[i], color_locations[i]);
@ -277,7 +277,7 @@ void GLGSRender::init_buffers(rsx::framebuffer_creation_context context, bool sk
auto ds = std::get<1>(m_rtts.m_bound_depth_stencil); auto ds = std::get<1>(m_rtts.m_bound_depth_stencil);
depth_stencil_target = ds->id(); depth_stencil_target = ds->id();
std::get<1>(m_rtts.m_bound_depth_stencil)->set_rsx_pitch(rsx::method_registers.surface_z_pitch()); std::get<1>(m_rtts.m_bound_depth_stencil)->set_rsx_pitch(layout.actual_zeta_pitch);
m_depth_surface_info = { layout.zeta_address, layout.actual_zeta_pitch, true, layout.color_format, layout.depth_format, layout.width, layout.height }; m_depth_surface_info = { layout.zeta_address, layout.actual_zeta_pitch, true, layout.color_format, layout.depth_format, layout.width, layout.height };
ds->write_aa_mode = layout.aa_mode; ds->write_aa_mode = layout.aa_mode;

75
rpcs3/Emu/RSX/RSXThread.cpp
View file

@ -2024,21 +2024,20 @@ namespace rsx
// Fill the data // Fill the data
// Each descriptor field is 64 bits wide // Each descriptor field is 64 bits wide
// [0-8] attribute stride\n" // [0-8] attribute stride
// [8-20] attribute divisor\n" // [8-24] attribute divisor
// [20-21] swap bytes flag\n" // [24-27] attribute type
// [21-22] volatile flag\n" // [27-30] attribute size
// [22-24] frequency op\n" // [30-31] reserved
// [24-27] attribute type\n" // [31-60] starting offset
// [27-30] attribute size\n" // [60-21] swap bytes flag
// [61-22] volatile flag
// [62-63] modulo enable flag
memset(buffer, 0, 256); const s32 default_frequency_mask = (1 << 8);
const s32 swap_storage_mask = (1 << 29);
const s32 swap_storage_mask = (1 << 20); const s32 volatile_storage_mask = (1 << 30);
const s32 volatile_storage_mask = (1 << 21); const s32 modulo_op_frequency_mask = (1 << 31);
const s32 default_frequency_mask = (1 << 22);
const s32 division_op_frequency_mask = (2 << 22);
const s32 modulo_op_frequency_mask = (3 << 22);
const u32 modulo_mask = rsx::method_registers.frequency_divider_operation_mask(); const u32 modulo_mask = rsx::method_registers.frequency_divider_operation_mask();
@ -2049,30 +2048,28 @@ namespace rsx
rsx::vertex_base_type type = {}; rsx::vertex_base_type type = {};
s32 size = 0; s32 size = 0;
s32 attributes = 0; s32 attrib0 = 0;
s32 attrib1 = 0;
if (layout.attribute_placement[index] == attribute_buffer_placement::transient) if (layout.attribute_placement[index] == attribute_buffer_placement::transient)
{ {
if (rsx::method_registers.current_draw_clause.command == rsx::draw_command::inlined_array) if (rsx::method_registers.current_draw_clause.command == rsx::draw_command::inlined_array)
{ {
auto &info = rsx::method_registers.vertex_arrays_info[index]; const auto &info = rsx::method_registers.vertex_arrays_info[index];
type = info.type();
size = info.size();
if (!size) if (!info.size())
{ {
// Register // Register
const auto& reginfo = rsx::method_registers.register_vertex_info[index]; const auto& reginfo = rsx::method_registers.register_vertex_info[index];
type = reginfo.type; type = reginfo.type;
size = reginfo.size; size = reginfo.size;
attributes = rsx::get_vertex_type_size_on_host(type, size); attrib0 = rsx::get_vertex_type_size_on_host(type, size);
attributes |= volatile_storage_mask;
} }
else else
{ {
attributes = layout.interleaved_blocks[0].attribute_stride; // Array
attributes |= default_frequency_mask | volatile_storage_mask; attrib0 = layout.interleaved_blocks[0].attribute_stride | default_frequency_mask;
} }
} }
else else
@ -2083,12 +2080,12 @@ namespace rsx
if (rsx::method_registers.current_draw_clause.is_immediate_draw && if (rsx::method_registers.current_draw_clause.is_immediate_draw &&
vertex_push_buffers[index].vertex_count > 1) vertex_push_buffers[index].vertex_count > 1)
{ {
// Push buffer
const auto &info = rsx::method_registers.register_vertex_info[index]; const auto &info = rsx::method_registers.register_vertex_info[index];
type = info.type; type = info.type;
size = info.size; size = info.size;
attributes = rsx::get_vertex_type_size_on_host(type, size); attrib0 = rsx::get_vertex_type_size_on_host(type, size) | default_frequency_mask;
attributes |= default_frequency_mask | volatile_storage_mask;
} }
else else
{ {
@ -2097,10 +2094,11 @@ namespace rsx
type = info.type; type = info.type;
size = info.size; size = info.size;
attributes = rsx::get_vertex_type_size_on_host(type, size); attrib0 = rsx::get_vertex_type_size_on_host(type, size);
attributes |= volatile_storage_mask;
} }
} }
attrib1 |= volatile_storage_mask;
} }
else else
{ {
@ -2109,7 +2107,7 @@ namespace rsx
size = info.size(); size = info.size();
auto stride = info.stride(); auto stride = info.stride();
attributes |= stride; attrib0 = stride;
if (stride > 0) //when stride is 0, input is not an array but a single element if (stride > 0) //when stride is 0, input is not an array but a single element
{ {
@ -2119,19 +2117,15 @@ namespace rsx
case 0: case 0:
case 1: case 1:
{ {
attributes |= default_frequency_mask; attrib0 |= default_frequency_mask;
break; break;
} }
default: default:
{ {
verify(HERE), frequency <= 4095u;
if (modulo_mask & (1 << index)) if (modulo_mask & (1 << index))
attributes |= modulo_op_frequency_mask; attrib1 |= modulo_op_frequency_mask;
else
attributes |= division_op_frequency_mask;
attributes |= (frequency << 8); attrib0 |= (frequency << 8);
break; break;
} }
} }
@ -2155,13 +2149,14 @@ namespace rsx
break; break;
} }
if (to_swap_bytes) attributes |= swap_storage_mask; if (to_swap_bytes) attrib1 |= swap_storage_mask;
attributes |= (static_cast<s32>(type) << 24); attrib0 |= (static_cast<s32>(type) << 24);
attributes |= (size << 27); attrib0 |= (size << 27);
attrib1 |= offset_in_block[index];
buffer[index * 4 + 0] = attributes; buffer[index * 4 + 0] = attrib0;
buffer[index * 4 + 1] = offset_in_block[index]; buffer[index * 4 + 1] = attrib1;
} }
} }

19
rpcs3/Emu/RSX/VK/VKGSRender.cpp
View file

@ -2598,18 +2598,17 @@ void VKGSRender::load_program_env()
{ {
// Vertex state // Vertex state
const auto mem = m_vertex_env_ring_info.alloc<256>(256); const auto mem = m_vertex_env_ring_info.alloc<256>(256);
auto buf = (u8*)m_vertex_env_ring_info.map(mem, 160); auto buf = (u8*)m_vertex_env_ring_info.map(mem, 144);
fill_scale_offset_data(buf, false); fill_scale_offset_data(buf, false);
fill_user_clip_data(buf + 64); fill_user_clip_data(buf + 64);
*(reinterpret_cast<u32*>(buf + 128)) = rsx::method_registers.transform_branch_bits(); *(reinterpret_cast<u32*>(buf + 128)) = rsx::method_registers.transform_branch_bits();
*(reinterpret_cast<u32*>(buf + 132)) = 0; // Reserved *(reinterpret_cast<f32*>(buf + 132)) = rsx::method_registers.point_size();
*(reinterpret_cast<f32*>(buf + 136)) = rsx::method_registers.point_size(); *(reinterpret_cast<f32*>(buf + 136)) = rsx::method_registers.clip_min();
*(reinterpret_cast<f32*>(buf + 140)) = rsx::method_registers.clip_min(); *(reinterpret_cast<f32*>(buf + 140)) = rsx::method_registers.clip_max();
*(reinterpret_cast<f32*>(buf + 144)) = rsx::method_registers.clip_max();
m_vertex_env_ring_info.unmap(); m_vertex_env_ring_info.unmap();
m_vertex_env_buffer_info = { m_vertex_env_ring_info.heap->value, mem, 160 }; m_vertex_env_buffer_info = { m_vertex_env_ring_info.heap->value, mem, 144 };
} }
if (update_transform_constants) if (update_transform_constants)
@ -2883,8 +2882,8 @@ void VKGSRender::prepare_rtts(rsx::framebuffer_creation_context context)
bound_images.push_back(surface); bound_images.push_back(surface);
m_surface_info[index].address = layout.color_addresses[index]; m_surface_info[index].address = layout.color_addresses[index];
m_surface_info[index].pitch = layout.color_pitch[index]; m_surface_info[index].pitch = layout.actual_color_pitch[index];
surface->rsx_pitch = layout.color_pitch[index]; surface->rsx_pitch = layout.actual_color_pitch[index];
surface->write_aa_mode = layout.aa_mode; surface->write_aa_mode = layout.aa_mode;
m_texture_cache.notify_surface_changed(layout.color_addresses[index]); m_texture_cache.notify_surface_changed(layout.color_addresses[index]);
@ -2899,8 +2898,8 @@ void VKGSRender::prepare_rtts(rsx::framebuffer_creation_context context)
bound_images.push_back(ds); bound_images.push_back(ds);
m_depth_surface_info.address = layout.zeta_address; m_depth_surface_info.address = layout.zeta_address;
m_depth_surface_info.pitch = layout.zeta_pitch; m_depth_surface_info.pitch = layout.actual_zeta_pitch;
ds->rsx_pitch = layout.zeta_pitch; ds->rsx_pitch = layout.actual_zeta_pitch;
ds->write_aa_mode = layout.aa_mode; ds->write_aa_mode = layout.aa_mode;
m_texture_cache.notify_surface_changed(layout.zeta_address); m_texture_cache.notify_surface_changed(layout.zeta_address);