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

Factorize rsx state

Browse source
This commit is contained in:
Vincent Lejeune 2016-06-26 23:37:02 +02:00 • committed by vlj
parent 77594dc66c
commit 772706ca4c
31 changed files with 2662 additions and 1199 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -303,15 +303,13 @@ namespace rsx
{
frame_capture_data::draw_state draw_state = {};
int clip_w = rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16;
int clip_h = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16;
rsx::surface_info surface = {};
surface.unpack(rsx::method_registers[NV4097_SET_SURFACE_FORMAT]);
int clip_w = rsx::method_registers.surface_clip_width();
int clip_h = rsx::method_registers.surface_clip_height();
draw_state.width = clip_w;
draw_state.height = clip_h;
draw_state.color_format = surface.color_format;
draw_state.color_format = rsx::method_registers.surface_color();
draw_state.color_buffer = std::move(copy_render_targets_to_memory());
draw_state.depth_format = surface.depth_format;
draw_state.depth_format = rsx::method_registers.surface_depth_fmt();
draw_state.depth_stencil = std::move(copy_depth_stencil_buffer_to_memory());
if (draw_command == rsx::draw_command::indexed)
@ -321,7 +319,7 @@ namespace rsx
{
draw_state.vertex_count += range.second;
}
draw_state.index_type = rsx::to_index_array_type(rsx::method_registers[NV4097_SET_INDEX_ARRAY_DMA] >> 4);
draw_state.index_type = rsx::method_registers.index_type();
if (draw_state.index_type == rsx::index_array_type::u16)
{
@ -346,17 +344,17 @@ namespace rsx
inline_vertex_array.clear();
first_count_commands.clear();
draw_command = rsx::draw_command::none;
draw_mode = to_primitive_type(method_registers[NV4097_SET_BEGIN_END]);
draw_mode = method_registers.primitive_mode();
}
void thread::end()
{
transform_constants.clear();
rsx::method_registers.transform_constants.clear();
for (u8 index = 0; index < rsx::limits::vertex_count; ++index)
{
register_vertex_info[index].size = 0;
register_vertex_data[index].clear();
rsx::method_registers.register_vertex_info[index].size = 0;
rsx::method_registers.register_vertex_data[index].clear();
}
if (capture_current_frame)
@ -494,21 +492,21 @@ namespace rsx
void thread::fill_scale_offset_data(void *buffer, bool is_d3d) const
{
int clip_w = rsx::method_registers[NV4097_SET_SURFACE_CLIP_HORIZONTAL] >> 16;
int clip_h = rsx::method_registers[NV4097_SET_SURFACE_CLIP_VERTICAL] >> 16;
int clip_w = rsx::method_registers.surface_clip_width();
int clip_h = rsx::method_registers.surface_clip_height();
float scale_x = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE] / (clip_w / 2.f);
float offset_x = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET] - (clip_w / 2.f);
float scale_x = rsx::method_registers.viewport_scale_x() / (clip_w / 2.f);
float offset_x = rsx::method_registers.viewport_offset_x() - (clip_w / 2.f);
offset_x /= clip_w / 2.f;
float scale_y = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + 1] / (clip_h / 2.f);
float offset_y = ((float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + 1] - (clip_h / 2.f));
float scale_y = rsx::method_registers.viewport_scale_y() / (clip_h / 2.f);
float offset_y = (rsx::method_registers.viewport_offset_y() - (clip_h / 2.f));
offset_y /= clip_h / 2.f;
if (is_d3d) scale_y *= -1;
if (is_d3d) offset_y *= -1;
float scale_z = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_SCALE + 2];
float offset_z = (float&)rsx::method_registers[NV4097_SET_VIEWPORT_OFFSET + 2];
float scale_z = rsx::method_registers.viewport_scale_z();
float offset_z = rsx::method_registers.viewport_offset_z();
if (!is_d3d) offset_z -= .5;
float one = 1.f;
@ -525,7 +523,7 @@ namespace rsx
*/
void thread::fill_vertex_program_constants_data(void *buffer)
{
for (const auto &entry : transform_constants)
for (const auto &entry : rsx::method_registers.transform_constants)
local_transform_constants[entry.first] = entry.second;
for (const auto &entry : local_transform_constants)
stream_vector_from_memory((char*)buffer + entry.first * 4 * sizeof(float), (void*)entry.second.rgba);
@ -541,7 +539,7 @@ namespace rsx
{
for (int index = 0; index < rsx::limits::vertex_count; ++index)
{
const auto &info = vertex_arrays_info[index];
const auto &info = rsx::method_registers.vertex_arrays_info[index];
if (!info.size) // disabled
continue;
@ -642,17 +640,17 @@ namespace rsx
{
u32 offset_color[] =
{
rsx::method_registers[NV4097_SET_SURFACE_COLOR_AOFFSET],
rsx::method_registers[NV4097_SET_SURFACE_COLOR_BOFFSET],
rsx::method_registers[NV4097_SET_SURFACE_COLOR_COFFSET],
rsx::method_registers[NV4097_SET_SURFACE_COLOR_DOFFSET]
rsx::method_registers.surface_a_offset(),
rsx::method_registers.surface_b_offset(),
rsx::method_registers.surface_c_offset(),
rsx::method_registers.surface_d_offset(),
};
u32 context_dma_color[] =
{
rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_A],
rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_B],
rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_C],
rsx::method_registers[NV4097_SET_CONTEXT_DMA_COLOR_D]
rsx::method_registers.surface_a_dma(),
rsx::method_registers.surface_b_dma(),
rsx::method_registers.surface_c_dma(),
rsx::method_registers.surface_d_dma(),
};
return
{
@ -665,32 +663,32 @@ namespace rsx
u32 thread::get_zeta_surface_address() const
{
u32 m_context_dma_z = rsx::method_registers[NV4097_SET_CONTEXT_DMA_ZETA];
u32 offset_zeta = rsx::method_registers[NV4097_SET_SURFACE_ZETA_OFFSET];
u32 m_context_dma_z = rsx::method_registers.surface_z_dma();
u32 offset_zeta = rsx::method_registers.surface_z_offset();
return rsx::get_address(offset_zeta, m_context_dma_z);
}
RSXVertexProgram thread::get_current_vertex_program() const
{
RSXVertexProgram result = {};
u32 transform_program_start = rsx::method_registers[NV4097_SET_TRANSFORM_PROGRAM_START];
u32 transform_program_start = rsx::method_registers.transform_program_start();
result.data.reserve((512 - transform_program_start) * 4);
for (int i = transform_program_start; i < 512; ++i)
{
result.data.resize((i - transform_program_start) * 4 + 4);
memcpy(result.data.data() + (i - transform_program_start) * 4, transform_program + i * 4, 4 * sizeof(u32));
memcpy(result.data.data() + (i - transform_program_start) * 4, rsx::method_registers.transform_program.data() + i * 4, 4 * sizeof(u32));
D3 d3;
d3.HEX = transform_program[i * 4 + 3];
d3.HEX = rsx::method_registers.transform_program[i * 4 + 3];
if (d3.end)
break;
}
result.output_mask = rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK];
result.output_mask = rsx::method_registers.vertex_attrib_output_mask();
u32 input_mask = rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_INPUT_MASK];
u32 modulo_mask = rsx::method_registers[NV4097_SET_FREQUENCY_DIVIDER_OPERATION];
u32 input_mask = rsx::method_registers.vertex_attrib_input_mask();
u32 modulo_mask = rsx::method_registers.frequency_divider_operation_mask();
result.rsx_vertex_inputs.clear();
for (u8 index = 0; index < rsx::limits::vertex_count; ++index)
{
@ -698,29 +696,29 @@ namespace rsx
if (!enabled)
continue;
if (vertex_arrays_info[index].size > 0)
if (rsx::method_registers.vertex_arrays_info[index].size > 0)
{
result.rsx_vertex_inputs.push_back(
{
index,
vertex_arrays_info[index].size,
vertex_arrays_info[index].frequency,
rsx::method_registers.vertex_arrays_info[index].size,
rsx::method_registers.vertex_arrays_info[index].frequency,
!!((modulo_mask >> index) & 0x1),
true,
is_int_type(vertex_arrays_info[index].type)
is_int_type(rsx::method_registers.vertex_arrays_info[index].type)
}
);
}
else if (register_vertex_info[index].size > 0)
else if (rsx::method_registers.register_vertex_info[index].size > 0)
{
result.rsx_vertex_inputs.push_back(
{
index,
register_vertex_info[index].size,
register_vertex_info[index].frequency,
rsx::method_registers.register_vertex_info[index].size,
rsx::method_registers.register_vertex_info[index].frequency,
!!((modulo_mask >> index) & 0x1),
false,
is_int_type(vertex_arrays_info[index].type)
is_int_type(rsx::method_registers.vertex_arrays_info[index].type)
}
);
}
@ -732,29 +730,28 @@ namespace rsx
RSXFragmentProgram thread::get_current_fragment_program() const
{
RSXFragmentProgram result = {};
u32 shader_program = rsx::method_registers[NV4097_SET_SHADER_PROGRAM];
u32 shader_program = rsx::method_registers.shader_program_address();
result.offset = shader_program & ~0x3;
result.addr = vm::base(rsx::get_address(result.offset, (shader_program & 0x3) - 1));
result.ctrl = rsx::method_registers[NV4097_SET_SHADER_CONTROL];
result.ctrl = rsx::method_registers.shader_control();
result.unnormalized_coords = 0;
result.front_back_color_enabled = !rsx::method_registers[NV4097_SET_TWO_SIDE_LIGHT_EN];
result.back_color_diffuse_output = !!(rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK] & CELL_GCM_ATTRIB_OUTPUT_MASK_BACKDIFFUSE);
result.back_color_specular_output = !!(rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK] & CELL_GCM_ATTRIB_OUTPUT_MASK_BACKSPECULAR);
result.alpha_func = to_comparaison_function(rsx::method_registers[NV4097_SET_ALPHA_FUNC]);
result.fog_equation = rsx::to_fog_mode(rsx::method_registers[NV4097_SET_FOG_MODE]);
u32 shader_window = rsx::method_registers[NV4097_SET_SHADER_WINDOW];
result.origin_mode = rsx::to_window_origin((shader_window >> 12) & 0xF);
result.pixel_center_mode = rsx::to_window_pixel_center((shader_window >> 16) & 0xF);
result.height = shader_window & 0xFFF;
result.front_back_color_enabled = !rsx::method_registers.two_side_light_en();
result.back_color_diffuse_output = !!(rsx::method_registers.vertex_attrib_output_mask() & CELL_GCM_ATTRIB_OUTPUT_MASK_BACKDIFFUSE);
result.back_color_specular_output = !!(rsx::method_registers.vertex_attrib_output_mask() & CELL_GCM_ATTRIB_OUTPUT_MASK_BACKSPECULAR);
result.alpha_func = rsx::method_registers.alpha_func();
result.fog_equation = rsx::method_registers.fog_equation();
result.origin_mode = rsx::method_registers.shader_window_origin();
result.pixel_center_mode = rsx::method_registers.shader_window_pixel();
result.height = rsx::method_registers.shader_window_height();
std::array<texture_dimension_extended, 16> texture_dimensions;
for (u32 i = 0; i < rsx::limits::textures_count; ++i)
{
if (!textures[i].enabled())
if (!rsx::method_registers.fragment_textures[i].enabled())
texture_dimensions[i] = texture_dimension_extended::texture_dimension_2d;
else
texture_dimensions[i] = textures[i].get_extended_texture_dimension();
if (textures[i].enabled() && (textures[i].format() & CELL_GCM_TEXTURE_UN))
texture_dimensions[i] = rsx::method_registers.fragment_textures[i].get_extended_texture_dimension();
if (rsx::method_registers.fragment_textures[i].enabled() && (rsx::method_registers.fragment_textures[i].format() & CELL_GCM_TEXTURE_UN))
result.unnormalized_coords |= (1 << i);
}
result.set_texture_dimension(texture_dimensions);
@ -766,29 +763,29 @@ namespace rsx
{
raw_program result{};
u32 fp_info = rsx::method_registers[NV4097_SET_SHADER_PROGRAM];
u32 fp_info = rsx::method_registers.shader_program_address();
result.state.input_attributes = rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_INPUT_MASK];
result.state.output_attributes = rsx::method_registers[NV4097_SET_VERTEX_ATTRIB_OUTPUT_MASK];
result.state.ctrl = rsx::method_registers[NV4097_SET_SHADER_CONTROL];
result.state.divider_op = rsx::method_registers[NV4097_SET_FREQUENCY_DIVIDER_OPERATION];
result.state.alpha_func = rsx::method_registers[NV4097_SET_ALPHA_FUNC];
result.state.fog_mode = (u32)rsx::to_fog_mode(rsx::method_registers[NV4097_SET_FOG_MODE]);
result.state.input_attributes = rsx::method_registers.vertex_attrib_input_mask();
result.state.output_attributes = rsx::method_registers.vertex_attrib_output_mask();
result.state.ctrl = rsx::method_registers.shader_control();
result.state.divider_op = rsx::method_registers.frequency_divider_operation_mask();
result.state.alpha_func = (u32)rsx::method_registers.alpha_func();
result.state.fog_mode = (u32)rsx::method_registers.fog_equation();
result.state.is_int = 0;
for (u8 index = 0; index < rsx::limits::vertex_count; ++index)
{
bool is_int = false;
if (vertex_arrays_info[index].size > 0)
if (rsx::method_registers.vertex_arrays_info[index].size > 0)
{
is_int = is_int_type(vertex_arrays_info[index].type);
result.state.frequency[index] = vertex_arrays_info[index].frequency;
is_int = is_int_type(rsx::method_registers.vertex_arrays_info[index].type);
result.state.frequency[index] = rsx::method_registers.vertex_arrays_info[index].frequency;
}
else if (register_vertex_info[index].size > 0)
else if (rsx::method_registers.register_vertex_info[index].size > 0)
{
is_int = is_int_type(register_vertex_info[index].type);
result.state.frequency[index] = register_vertex_info[index].frequency;
is_int = is_int_type(rsx::method_registers.register_vertex_info[index].type);
result.state.frequency[index] = rsx::method_registers.register_vertex_info[index].frequency;
}
else
{
@ -803,7 +800,7 @@ namespace rsx
for (u8 index = 0; index < rsx::limits::textures_count; ++index)
{
if (!textures[index].enabled())
if (!rsx::method_registers.fragment_textures[index].enabled())
{
result.state.textures_alpha_kill[index] = 0;
result.state.textures_zfunc[index] = 0;
@ -811,10 +808,10 @@ namespace rsx
continue;
}
result.state.textures_alpha_kill[index] = textures[index].alpha_kill_enabled() ? 1 : 0;
result.state.textures_zfunc[index] = textures[index].zfunc();
result.state.textures_alpha_kill[index] = rsx::method_registers.fragment_textures[index].alpha_kill_enabled() ? 1 : 0;
result.state.textures_zfunc[index] = rsx::method_registers.fragment_textures[index].zfunc();
switch (textures[index].get_extended_texture_dimension())
switch (rsx::method_registers.fragment_textures[index].get_extended_texture_dimension())
{
case rsx::texture_dimension_extended::texture_dimension_1d: result.state.textures[index] = rsx::texture_target::_1; break;
case rsx::texture_dimension_extended::texture_dimension_2d: result.state.textures[index] = rsx::texture_target::_2; break;
@ -829,13 +826,13 @@ namespace rsx
for (u8 index = 0; index < rsx::limits::vertex_textures_count; ++index)
{
if (!textures[index].enabled())
if (!rsx::method_registers.fragment_textures[index].enabled())
{
result.state.vertex_textures[index] = rsx::texture_target::none;
continue;
}
switch (textures[index].get_extended_texture_dimension())
switch (rsx::method_registers.fragment_textures[index].get_extended_texture_dimension())
{
case rsx::texture_dimension_extended::texture_dimension_1d: result.state.vertex_textures[index] = rsx::texture_target::_1; break;
case rsx::texture_dimension_extended::texture_dimension_2d: result.state.vertex_textures[index] = rsx::texture_target::_2; break;
@ -848,8 +845,8 @@ namespace rsx
}
}
result.vertex_shader.ucode_ptr = transform_program;
result.vertex_shader.offset = rsx::method_registers[NV4097_SET_TRANSFORM_PROGRAM_START];
result.vertex_shader.ucode_ptr = rsx::method_registers.transform_program.data();
result.vertex_shader.offset = rsx::method_registers.transform_program_start();
result.fragment_shader.ucode_ptr = vm::base(rsx::get_address(fp_info & ~0x3, (fp_info & 0x3) - 1));
result.fragment_shader.offset = 0;
@ -859,90 +856,7 @@ namespace rsx
void thread::reset()
{
//setup method registers
std::memset(method_registers, 0, sizeof(method_registers));
method_registers[NV4097_SET_COLOR_MASK] = CELL_GCM_COLOR_MASK_R | CELL_GCM_COLOR_MASK_G | CELL_GCM_COLOR_MASK_B | CELL_GCM_COLOR_MASK_A;
method_registers[NV4097_SET_SCISSOR_HORIZONTAL] = (4096 << 16) | 0;
method_registers[NV4097_SET_SCISSOR_VERTICAL] = (4096 << 16) | 0;
method_registers[NV4097_SET_ALPHA_FUNC] = CELL_GCM_ALWAYS;
method_registers[NV4097_SET_ALPHA_REF] = 0;
method_registers[NV4097_SET_BLEND_FUNC_SFACTOR] = (CELL_GCM_ONE << 16) | CELL_GCM_ONE;
method_registers[NV4097_SET_BLEND_FUNC_DFACTOR] = (CELL_GCM_ZERO << 16) | CELL_GCM_ZERO;
method_registers[NV4097_SET_BLEND_COLOR] = 0;
method_registers[NV4097_SET_BLEND_COLOR2] = 0;
method_registers[NV4097_SET_BLEND_EQUATION] = (CELL_GCM_FUNC_ADD << 16) | CELL_GCM_FUNC_ADD;
method_registers[NV4097_SET_STENCIL_MASK] = 0xff;
method_registers[NV4097_SET_STENCIL_FUNC] = CELL_GCM_ALWAYS;
method_registers[NV4097_SET_STENCIL_FUNC_REF] = 0x00;
method_registers[NV4097_SET_STENCIL_FUNC_MASK] = 0xff;
method_registers[NV4097_SET_STENCIL_OP_FAIL] = CELL_GCM_KEEP;
method_registers[NV4097_SET_STENCIL_OP_ZFAIL] = CELL_GCM_KEEP;
method_registers[NV4097_SET_STENCIL_OP_ZPASS] = CELL_GCM_KEEP;
method_registers[NV4097_SET_BACK_STENCIL_MASK] = 0xff;
method_registers[NV4097_SET_BACK_STENCIL_FUNC] = CELL_GCM_ALWAYS;
method_registers[NV4097_SET_BACK_STENCIL_FUNC_REF] = 0x00;
method_registers[NV4097_SET_BACK_STENCIL_FUNC_MASK] = 0xff;
method_registers[NV4097_SET_BACK_STENCIL_OP_FAIL] = CELL_GCM_KEEP;
method_registers[NV4097_SET_BACK_STENCIL_OP_ZFAIL] = CELL_GCM_KEEP;
method_registers[NV4097_SET_BACK_STENCIL_OP_ZPASS] = CELL_GCM_KEEP;
method_registers[NV4097_SET_SHADE_MODE] = CELL_GCM_SMOOTH;
method_registers[NV4097_SET_LOGIC_OP] = CELL_GCM_COPY;
(f32&)method_registers[NV4097_SET_DEPTH_BOUNDS_MIN] = 0.f;
(f32&)method_registers[NV4097_SET_DEPTH_BOUNDS_MAX] = 1.f;
(f32&)method_registers[NV4097_SET_CLIP_MIN] = 0.f;
(f32&)method_registers[NV4097_SET_CLIP_MAX] = 1.f;
method_registers[NV4097_SET_LINE_WIDTH] = 1 << 3;
// These defaults were found using After Burner Climax (which never set fog mode despite using fog input)
method_registers[NV4097_SET_FOG_MODE] = 0x2601; // rsx::fog_mode::linear;
(f32&)method_registers[NV4097_SET_FOG_PARAMS] = 1.;
(f32&)method_registers[NV4097_SET_FOG_PARAMS + 1] = 1.;
method_registers[NV4097_SET_DEPTH_FUNC] = CELL_GCM_LESS;
method_registers[NV4097_SET_DEPTH_MASK] = CELL_GCM_TRUE;
(f32&)method_registers[NV4097_SET_POLYGON_OFFSET_SCALE_FACTOR] = 0.f;
(f32&)method_registers[NV4097_SET_POLYGON_OFFSET_BIAS] = 0.f;
method_registers[NV4097_SET_FRONT_POLYGON_MODE] = CELL_GCM_POLYGON_MODE_FILL;
method_registers[NV4097_SET_BACK_POLYGON_MODE] = CELL_GCM_POLYGON_MODE_FILL;
method_registers[NV4097_SET_CULL_FACE] = CELL_GCM_BACK;
method_registers[NV4097_SET_FRONT_FACE] = CELL_GCM_CCW;
method_registers[NV4097_SET_RESTART_INDEX] = -1;
method_registers[NV4097_SET_CLEAR_RECT_HORIZONTAL] = (4096 << 16) | 0;
method_registers[NV4097_SET_CLEAR_RECT_VERTICAL] = (4096 << 16) | 0;
method_registers[NV4097_SET_ZSTENCIL_CLEAR_VALUE] = 0xffffffff;
method_registers[NV4097_SET_CONTEXT_DMA_REPORT] = CELL_GCM_CONTEXT_DMA_TO_MEMORY_GET_REPORT;
rsx::method_registers[NV4097_SET_TWO_SIDE_LIGHT_EN] = true;
rsx::method_registers[NV4097_SET_ALPHA_FUNC] = CELL_GCM_ALWAYS;
// Reset vertex attrib array
for (int i = 0; i < limits::vertex_count; i++)
{
vertex_arrays_info[i].size = 0;
}
// Construct Textures
for (int i = 0; i < limits::textures_count; i++)
{
textures[i].init(i);
}
for (int i = 0; i < limits::vertex_textures_count; i++)
{
vertex_textures[i].init(i);
}
rsx::method_registers.reset();
}
void thread::init(const u32 ioAddress, const u32 ioSize, const u32 ctrlAddress, const u32 localAddress)