void OpenGLPostProcessing::ApplyShader()
{
// shader didn't changed
if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
return;
m_shader.Destroy();
m_uniform_bindings.clear();
// load shader code
std::string code = m_config.LoadShader();
code = LoadShaderOptions(code);
// and compile it
if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code))
{
ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
g_ActiveConfig.sPostProcessingShader.clear();
code = m_config.LoadShader();
ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code);
}
// read uniform locations
m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
m_uniform_src_rect = glGetUniformLocation(m_shader.glprogid, "src_rect");
m_uniform_layer = glGetUniformLocation(m_shader.glprogid, "layer");
for (const auto& it : m_config.GetOptions())
{
std::string glsl_name = "option_" + it.first;
m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
}
m_initialized = true;
}
void OpenGLPostProcessing::ApplyShader()
{
// shader didn't changed
if (m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
return;
m_enable = false;
m_shader.Destroy();
m_uniform_bindings.clear();
// shader disabled
if (g_ActiveConfig.sPostProcessingShader == "")
return;
// so need to compile shader
std::string code = m_config.LoadShader();
if (code == "")
return;
code = LoadShaderOptions(code);
// and compile it
if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str()))
{
ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
return;
}
// read uniform locations
m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
for (const auto& it : m_config.GetOptions())
{
std::string glsl_name = "option_" + it.first;
m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
}
// successful
m_enable = true;
}
void OpenGLPostProcessing::ApplyShader()
{
// shader didn't changed
if (m_initialized
&& m_config.GetShader() == g_ActiveConfig.sPostProcessingShader
&& !m_config.NeedRecompile())
return;
if (m_config.NeedRecompile())
{
m_config.SaveOptionsConfiguration();
m_config.SetRecompile(false);
}
DestroyStageOutput();
m_stageOutput.resize(0);
for (auto& shader : m_shaders)
{
shader.shader.Destroy();
}
// load shader code
std::string code = m_config.LoadShader();
code = LoadShaderOptions(code);
const char* vertex_shader = s_vertex_shader;
m_initialized = true;
const auto& stages = m_config.GetStages();
m_shaders.resize(stages.size());
// and compile it
const char* macros[1];
for (size_t i = 0; i < stages.size(); i++)
{
// and compile it
std::string entry_point = "#define ";
entry_point += stages[i].m_stage_entry_point;
entry_point += " main\n";
macros[0] = entry_point.c_str();
if (!ProgramShaderCache::CompileShader(m_shaders[i].shader, vertex_shader, code.c_str(), nullptr, macros, 1))
{
ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
m_initialized = false;
break;
}
}
// and compile it
if (!m_initialized)
{
g_Config.sPostProcessingShader.clear();
g_ActiveConfig.sPostProcessingShader.clear();
for (auto& shader : m_shaders)
{
shader.shader.Destroy();
}
m_shaders.resize(1);
code = m_config.LoadShader();
code = LoadShaderOptions(code);
ProgramShaderCache::CompileShader(m_shaders[0].shader, vertex_shader, code.c_str());
}
for (auto& shader : m_shaders)
{
shader.m_uniform_resolution = glGetUniformLocation(shader.shader.glprogid, "resolution");
shader.m_uniform_gamma = glGetUniformLocation(shader.shader.glprogid, "native_gamma");
shader.m_uniform_time = glGetUniformLocation(shader.shader.glprogid, "time");
shader.m_uniform_src_rect = glGetUniformLocation(shader.shader.glprogid, "src_rect");
shader.m_uniform_layer = glGetUniformLocation(shader.shader.glprogid, "layer");
shader.m_uniform_dstscale = glGetUniformLocation(shader.shader.glprogid, "dst_scale");
shader.m_uniform_ScalingFilter = glGetUniformLocation(shader.shader.glprogid, "scaling_filter");
shader.m_uniform_bindings.clear();
for (const auto& it : m_config.GetOptions())
{
std::string glsl_name = "option_" + it.first;
shader.m_uniform_bindings[it.first] = glGetUniformLocation(shader.shader.glprogid, glsl_name.c_str());
}
}
m_initialized = true;
}
void OpenGLPostProcessing::ApplyShader()
{
// shader didn't changed
if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader &&
((g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH) == m_anaglyph))
return;
m_shader.Destroy();
m_uniform_bindings.clear();
// load shader code
std::string code = "";
std::string default_shader = "void main() { SetOutput(Sample()); }\n";
if (g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH)
code = "void main() { SetOutput(float4(pow(0.7 * SampleLayer(0).g + 0.3 * SampleLayer(0).b, 1.5), SampleLayer(1).gba)); }\n";
else if (g_ActiveConfig.sPostProcessingShader != "")
code = m_config.LoadShader();
if (code == "")
code = default_shader;
code = LoadShaderOptions(code);
const char* vertex_shader = s_vertex_shader;
if (m_attribute_workaround)
vertex_shader = s_vertex_workaround_shader;
// and compile it
if (!ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str()))
{
ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
code = LoadShaderOptions(default_shader);
ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str());
}
// read uniform locations
m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
m_uniform_src_rect = glGetUniformLocation(m_shader.glprogid, "src_rect");
m_uniform_layer = glGetUniformLocation(m_shader.glprogid, "layer");
if (m_attribute_workaround)
{
GLfloat vertices[] = {
-1.f, -1.f, 0.f, 0.f,
1.f, -1.f, 1.f, 0.f,
-1.f, 1.f, 0.f, 1.f,
1.f, 1.f, 1.f, 1.f,
};
glBindBuffer(GL_ARRAY_BUFFER, m_attribute_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindVertexArray(m_attribute_vao);
glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
glVertexAttribPointer(SHADER_POSITION_ATTRIB, 4, GL_FLOAT, 0, 0, nullptr);
}
for (const auto& it : m_config.GetOptions())
{
std::string glsl_name = "option_" + it.first;
m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
}
m_anaglyph = g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH;
m_initialized = true;
}
