Mirrors/yuzu-fork
1
0
Fork 0
mirror of https://github.com/yuzu-mirror/yuzu.git synced 2024-11-03 06:10:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #2386 from ReinUsesLisp/shader-manager

Browse source 
gl_shader_manager: Move code to source file and minor clean up
This commit is contained in:
bunnei 2019-04-13 22:09:27 -04:00 committed by GitHub
commit ee2206a1b7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 59 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/video_core/renderer_opengl/gl_shader_manager.cpp
View file

@ -2,12 +2,44 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "common/common_types.h"
#include "video_core/engines/maxwell_3d.h"
#include "video_core/renderer_opengl/gl_shader_manager.h" #include "video_core/renderer_opengl/gl_shader_manager.h"
namespace OpenGL::GLShader { namespace OpenGL::GLShader {
using Tegra::Engines::Maxwell3D; using Tegra::Engines::Maxwell3D;
ProgramManager::ProgramManager() {
pipeline.Create();
}
ProgramManager::~ProgramManager() = default;
void ProgramManager::ApplyTo(OpenGLState& state) {
UpdatePipeline();
state.draw.shader_program = 0;
state.draw.program_pipeline = pipeline.handle;
}
void ProgramManager::UpdatePipeline() {
// Avoid updating the pipeline when values have no changed
if (old_state == current_state) {
return;
}
// Workaround for AMD bug
constexpr GLenum all_used_stages{GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT |
GL_FRAGMENT_SHADER_BIT};
glUseProgramStages(pipeline.handle, all_used_stages, 0);
glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current_state.vertex_shader);
glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, current_state.geometry_shader);
glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current_state.fragment_shader);
old_state = current_state;
}
void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shader_stage) { void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shader_stage) {
const auto& regs = maxwell.regs; const auto& regs = maxwell.regs;
const auto& state = maxwell.state; const auto& state = maxwell.state;
@ -16,7 +48,7 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shade
viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f; viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f; viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
u32 func = static_cast<u32>(regs.alpha_test_func); auto func{static_cast<u32>(regs.alpha_test_func)};
// Normalize the gl variants of opCompare to be the same as the normal variants // Normalize the gl variants of opCompare to be the same as the normal variants
const u32 op_gl_variant_base = static_cast<u32>(Maxwell3D::Regs::ComparisonOp::Never); const u32 op_gl_variant_base = static_cast<u32>(Maxwell3D::Regs::ComparisonOp::Never);
if (func >= op_gl_variant_base) { if (func >= op_gl_variant_base) {

59
src/video_core/renderer_opengl/gl_shader_manager.h
View file

@ -4,6 +4,8 @@
#pragma once #pragma once
#include <cstddef>
#include <glad/glad.h> #include <glad/glad.h>
#include "video_core/renderer_opengl/gl_resource_manager.h" #include "video_core/renderer_opengl/gl_resource_manager.h"
@ -38,55 +40,48 @@ static_assert(sizeof(MaxwellUniformData) < 16384,
class ProgramManager { class ProgramManager {
public: public:
ProgramManager() { explicit ProgramManager();
pipeline.Create(); ~ProgramManager();
}
void ApplyTo(OpenGLState& state);
void UseProgrammableVertexShader(GLuint program) { void UseProgrammableVertexShader(GLuint program) {
vs = program; current_state.vertex_shader = program;
} }
void UseProgrammableGeometryShader(GLuint program) { void UseProgrammableGeometryShader(GLuint program) {
gs = program; current_state.geometry_shader = program;
} }
void UseProgrammableFragmentShader(GLuint program) { void UseProgrammableFragmentShader(GLuint program) {
fs = program; current_state.fragment_shader = program;
} }
void UseTrivialGeometryShader() { void UseTrivialGeometryShader() {
gs = 0; current_state.geometry_shader = 0;
}
void ApplyTo(OpenGLState& state) {
UpdatePipeline();
state.draw.shader_program = 0;
state.draw.program_pipeline = pipeline.handle;
} }
private: private:
void UpdatePipeline() { struct PipelineState {
// Avoid updating the pipeline when values have no changed bool operator==(const PipelineState& rhs) const {
if (old_vs == vs && old_fs == fs && old_gs == gs) return vertex_shader == rhs.vertex_shader && fragment_shader == rhs.fragment_shader &&
return; geometry_shader == rhs.geometry_shader;
// Workaround for AMD bug
glUseProgramStages(pipeline.handle,
GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT | GL_FRAGMENT_SHADER_BIT,
0);
glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, vs);
glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, gs);
glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, fs);
// Update the old values
old_vs = vs;
old_fs = fs;
old_gs = gs;
} }
bool operator!=(const PipelineState& rhs) const {
return !operator==(rhs);
}
GLuint vertex_shader{};
GLuint fragment_shader{};
GLuint geometry_shader{};
};
void UpdatePipeline();
OGLPipeline pipeline; OGLPipeline pipeline;
GLuint vs{}, fs{}, gs{}; PipelineState current_state;
GLuint old_vs{}, old_fs{}, old_gs{}; PipelineState old_state;
}; };
} // namespace OpenGL::GLShader } // namespace OpenGL::GLShader