RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-21 18:22:33 +01:00
Code Issues Releases Wiki Activity

GL: minor fixes (#2105)

Browse Source 
* Minor fixes

* temporary disable 2-sided lighting

* Disable user clip planes until they are properly handled
This commit is contained in:
raven02 2016-08-27 14:12:44 +08:00 committed by GitHub
parent 6e07e07cd0
commit bb66b97251
3 changed files with 30 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
View File

@ -46,15 +46,6 @@ void GLFragmentDecompilerThread::insertIntputs(std::stringstream & OS)
{ {
for (const ParamItem& PI : PT.items) for (const ParamItem& PI : PT.items)
{ {
if (m_prog.front_back_color_enabled)
{
if (PI.name == "diff_color" && m_prog.back_color_diffuse_output)
OS << "in vec4 back_diff_color;" << std::endl;
if (PI.name == "spec_color" && m_prog.back_color_specular_output)
OS << "in vec4 back_spec_color;" << std::endl;
}
//Rename fogc to fog_c to differentiate the input register from the variable //Rename fogc to fog_c to differentiate the input register from the variable
if (PI.name == "fogc") if (PI.name == "fogc")
OS << "in vec4 fog_c;" << std::endl; OS << "in vec4 fog_c;" << std::endl;
@ -62,16 +53,6 @@ void GLFragmentDecompilerThread::insertIntputs(std::stringstream & OS)
OS << "in " << PT.type << " " << PI.name << ";" << std::endl; OS << "in " << PT.type << " " << PI.name << ";" << std::endl;
} }
} }
if (m_prog.front_back_color_enabled)
{
if (m_prog.front_color_diffuse_output)
OS << "in vec4 front_diff_color;" << std::endl;
if (m_prog.front_color_specular_output)
OS << "in vec4 front_spec_color;" << std::endl;
}
} }
void GLFragmentDecompilerThread::insertOutputs(std::stringstream & OS) void GLFragmentDecompilerThread::insertOutputs(std::stringstream & OS)
@ -207,20 +188,6 @@ void GLFragmentDecompilerThread::insertMainStart(std::stringstream & OS)
{ {
for (const ParamItem& PI : PT.items) for (const ParamItem& PI : PT.items)
{ {
if (m_prog.front_back_color_enabled)
{
if (PI.name == "spec_color" && m_prog.back_color_specular_output)
{
OS << " vec4 spec_color = gl_FrontFacing ? front_spec_color : spec_color;\n";
continue;
}
if (PI.name == "diff_color" && m_prog.back_color_diffuse_output)
{
OS << " vec4 diff_color = gl_FrontFacing ? front_diff_color : diff_color;\n";
continue;
}
}
if (PI.name == "fogc") if (PI.name == "fogc")
{ {
insert_fog_declaration(OS, m_prog.fog_equation); insert_fog_declaration(OS, m_prog.fog_equation);

92
rpcs3/Emu/RSX/GL/GLGSRender.cpp
View File

@ -600,40 +600,6 @@ bool GLGSRender::do_method(u32 cmd, u32 arg)
return true; return true;
} }
struct alignas(4) glsl_scale_buffer
{
float viewport_matrix[4][4];
float window_matrix[4][4];
float normalize_matrix[4][4];
};
struct alignas(4) glsl_vertex_constants_buffer
{
float vc[468][4];
};
struct alignas(4) glsl_fragment_constants_buffer
{
float fc[2048][4];
};
struct alignas(4) glsl_fragment_state_buffer
{
float fog_param0;
float fog_param1;
uint alpha_test;
float alpha_ref;
};
static void fill_fragment_state_buffer(glsl_fragment_state_buffer *buffer)
{
const float fog_params[2] = { rsx::method_registers.fog_params_0(), rsx::method_registers.fog_params_1() };
std::memcpy(&buffer->fog_param0, fog_params, sizeof(float) * 2);
buffer->alpha_test = rsx::method_registers.alpha_test_enabled();
buffer->alpha_ref = rsx::method_registers.alpha_ref() / 255.f;
}
bool GLGSRender::load_program() bool GLGSRender::load_program()
{ {
RSXVertexProgram vertex_program = get_current_vertex_program(); RSXVertexProgram vertex_program = get_current_vertex_program();
@ -644,59 +610,53 @@ bool GLGSRender::load_program()
u32 fragment_constants_size = m_prog_buffer.get_fragment_constants_buffer_size(fragment_program); u32 fragment_constants_size = m_prog_buffer.get_fragment_constants_buffer_size(fragment_program);
fragment_constants_size = std::max(32U, fragment_constants_size); fragment_constants_size = std::max(32U, fragment_constants_size);
u32 max_buffer_sz = u32 max_buffer_sz = 512 + 8192 + align(fragment_constants_size, m_uniform_buffer_offset_align);
align(sizeof(glsl_scale_buffer), m_uniform_buffer_offset_align) + m_uniform_ring_buffer.reserve_and_map(max_buffer_sz);
align(sizeof(glsl_vertex_constants_buffer), m_uniform_buffer_offset_align) +
align(fragment_constants_size, m_uniform_buffer_offset_align) +
align(sizeof(glsl_fragment_state_buffer), m_uniform_buffer_offset_align);
u8 *buf;
u32 scale_offset_offset; u32 scale_offset_offset;
u32 vertex_constants_offset; u32 vertex_constants_offset;
u32 fragment_constants_offset; u32 fragment_constants_offset;
u32 fragment_state_offset;
m_uniform_ring_buffer.reserve_and_map(max_buffer_sz);
// Scale offset // Scale offset
{ auto mapping = m_uniform_ring_buffer.alloc_from_reserve(512);
auto mapping = m_uniform_ring_buffer.alloc_from_reserve(sizeof(glsl_scale_buffer), m_uniform_buffer_offset_align); buf = static_cast<u8*>(mapping.first);
fill_scale_offset_data((glsl_scale_buffer *)mapping.first, false); scale_offset_offset = mapping.second;
scale_offset_offset = mapping.second; fill_scale_offset_data(buf, false);
}
// Fragment state // Fragment state
{ u32 is_alpha_tested = rsx::method_registers.alpha_test_enabled();
auto mapping = m_uniform_ring_buffer.alloc_from_reserve(sizeof(glsl_fragment_state_buffer), m_uniform_buffer_offset_align); float alpha_ref = rsx::method_registers.alpha_ref() / 255.f;
fill_fragment_state_buffer((glsl_fragment_state_buffer *)mapping.first); f32 fog0 = rsx::method_registers.fog_params_0();
fragment_state_offset = mapping.second; f32 fog1 = rsx::method_registers.fog_params_1();
} memcpy(buf + 16 * sizeof(float), &fog0, sizeof(float));
memcpy(buf + 17 * sizeof(float), &fog1, sizeof(float));
memcpy(buf + 18 * sizeof(float), &is_alpha_tested, sizeof(u32));
memcpy(buf + 19 * sizeof(float), &alpha_ref, sizeof(float));
// Vertex constants // Vertex constants
{ mapping = m_uniform_ring_buffer.alloc_from_reserve(8192);
auto mapping = m_uniform_ring_buffer.alloc_from_reserve(sizeof(glsl_vertex_constants_buffer), m_uniform_buffer_offset_align); buf = static_cast<u8*>(mapping.first);
fill_vertex_program_constants_data(mapping.first); vertex_constants_offset = mapping.second;
vertex_constants_offset = mapping.second; fill_vertex_program_constants_data(buf);
}
// Fragment constants // Fragment constants
if (fragment_constants_size) if (fragment_constants_size)
{ {
auto mapping = m_uniform_ring_buffer.alloc_from_reserve(fragment_constants_size, m_uniform_buffer_offset_align); mapping = m_uniform_ring_buffer.alloc_from_reserve(fragment_constants_size);
u8 *buf = static_cast<u8*>(mapping.first); buf = static_cast<u8*>(mapping.first);
m_prog_buffer.fill_fragment_constants_buffer({ reinterpret_cast<float*>(buf), gsl::narrow<int>(fragment_constants_size) }, fragment_program);
fragment_constants_offset = mapping.second; fragment_constants_offset = mapping.second;
m_prog_buffer.fill_fragment_constants_buffer({ reinterpret_cast<float*>(buf), gsl::narrow<int>(fragment_constants_size) }, fragment_program);
} }
m_uniform_ring_buffer.unmap(); m_uniform_ring_buffer.unmap();
m_uniform_ring_buffer.bind_range(0, scale_offset_offset, sizeof(glsl_scale_buffer)); m_uniform_ring_buffer.bind_range(0, scale_offset_offset, 512);
m_uniform_ring_buffer.bind_range(1, vertex_constants_offset, sizeof(glsl_vertex_constants_buffer)); m_uniform_ring_buffer.bind_range(1, vertex_constants_offset, 8192);
if (fragment_constants_size) if (fragment_constants_size)
{ {
m_uniform_ring_buffer.bind_range(2, fragment_constants_offset, fragment_constants_size); m_uniform_ring_buffer.bind_range(2, fragment_constants_offset, fragment_constants_size);
} }
m_uniform_ring_buffer.bind_range(3, fragment_state_offset, sizeof(glsl_fragment_state_buffer));
return true; return true;
} }
@ -846,4 +806,4 @@ bool GLGSRender::on_access_violation(u32 address, bool is_writing)
{ {
if (is_writing) return m_gl_texture_cache.mark_as_dirty(address); if (is_writing) return m_gl_texture_cache.mark_as_dirty(address);
return false; return false;
} }

47
rpcs3/Emu/RSX/GL/GLVertexProgram.cpp
View File

@ -114,9 +114,10 @@ static const reg_info reg_table[] =
{ "gl_ClipDistance[1]", false, "dst_reg5", ".z", false }, { "gl_ClipDistance[1]", false, "dst_reg5", ".z", false },
{ "gl_ClipDistance[2]", false, "dst_reg5", ".w", false }, { "gl_ClipDistance[2]", false, "dst_reg5", ".w", false },
{ "gl_PointSize", false, "dst_reg6", ".x", false }, { "gl_PointSize", false, "dst_reg6", ".x", false },
{ "gl_ClipDistance[3]", false, "dst_reg6", ".y", false }, //Disable user clip planes until they are properly handled
{ "gl_ClipDistance[4]", false, "dst_reg6", ".z", false }, //{ "gl_ClipDistance[3]", false, "dst_reg6", ".y", false },
{ "gl_ClipDistance[5]", false, "dst_reg6", ".w", false }, //{ "gl_ClipDistance[4]", false, "dst_reg6", ".z", false },
//{ "gl_ClipDistance[5]", false, "dst_reg6", ".w", false },
{ "tc0", true, "dst_reg7", "", false }, { "tc0", true, "dst_reg7", "", false },
{ "tc1", true, "dst_reg8", "", false }, { "tc1", true, "dst_reg8", "", false },
{ "tc2", true, "dst_reg9", "", false }, { "tc2", true, "dst_reg9", "", false },
@ -225,53 +226,15 @@ GLVertexProgram::GLVertexProgram()
GLVertexProgram::~GLVertexProgram() GLVertexProgram::~GLVertexProgram()
{ {
//if (m_decompiler_thread)
//{
// Wait();
// if (m_decompiler_thread->IsAlive())
// {
// m_decompiler_thread->Stop();
// }
// delete m_decompiler_thread;
// m_decompiler_thread = nullptr;
//}
Delete(); Delete();
} }
//void GLVertexProgram::Wait()
//{
// if (m_decompiler_thread && m_decompiler_thread->IsAlive())
// {
// m_decompiler_thread->Join();
// }
//}
void GLVertexProgram::Decompile(const RSXVertexProgram& prog) void GLVertexProgram::Decompile(const RSXVertexProgram& prog)
{ {
GLVertexDecompilerThread decompiler(prog, shader, parr); GLVertexDecompilerThread decompiler(prog, shader, parr);
decompiler.Task(); decompiler.Task();
} }
//void GLVertexProgram::DecompileAsync(RSXVertexProgram& prog)
//{
// if (m_decompiler_thread)
// {
// Wait();
// if (m_decompiler_thread->IsAlive())
// {
// m_decompiler_thread->Stop();
// }
//
// delete m_decompiler_thread;
// m_decompiler_thread = nullptr;
// }
//
// m_decompiler_thread = new GLVertexDecompilerThread(prog.data, shader, parr);
// m_decompiler_thread->Start();
//}
void GLVertexProgram::Compile() void GLVertexProgram::Compile()
{ {
if (id) if (id)
@ -305,8 +268,6 @@ void GLVertexProgram::Compile()
LOG_NOTICE(RSX, "%s", shader.c_str()); LOG_NOTICE(RSX, "%s", shader.c_str());
Emu.Pause(); Emu.Pause();
} }
//else LOG_WARNING(RSX, "Vertex shader compiled successfully!");
} }
void GLVertexProgram::Delete() void GLVertexProgram::Delete()