yuzu-emu
/
yuzu
Archived
1
0
Fork 0
Code

gl_rasterizer: Use shader program manager, remove test shader.

This commit is contained in:
bunnei 2018-04-07 05:22:08 -04:00
parent 459826a705
commit 5617831d5f
2 changed files with 31 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
src/video_core/renderer_opengl/gl_rasterizer.cpp
View File

@ -34,33 +34,7 @@ MICROPROFILE_DEFINE(OpenGL_Drawing, "OpenGL", "Drawing", MP_RGB(128, 128, 192));
MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255)); MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255));
MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100)); MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
enum class UniformBindings : GLuint { Common, VS, FS };
static void SetShaderUniformBlockBinding(GLuint shader, const char* name, UniformBindings binding,
size_t expected_size) {
GLuint ub_index = glGetUniformBlockIndex(shader, name);
if (ub_index != GL_INVALID_INDEX) {
GLint ub_size = 0;
glGetActiveUniformBlockiv(shader, ub_index, GL_UNIFORM_BLOCK_DATA_SIZE, &ub_size);
ASSERT_MSG(ub_size == expected_size,
"Uniform block size did not match! Got %d, expected %zu",
static_cast<int>(ub_size), expected_size);
glUniformBlockBinding(shader, ub_index, static_cast<GLuint>(binding));
}
}
static void SetShaderUniformBlockBindings(GLuint shader) {
SetShaderUniformBlockBinding(shader, "shader_data", UniformBindings::Common,
sizeof(RasterizerOpenGL::UniformData));
SetShaderUniformBlockBinding(shader, "vs_config", UniformBindings::VS,
sizeof(RasterizerOpenGL::VSUniformData));
SetShaderUniformBlockBinding(shader, "fs_config", UniformBindings::FS,
sizeof(RasterizerOpenGL::FSUniformData));
}
RasterizerOpenGL::RasterizerOpenGL() { RasterizerOpenGL::RasterizerOpenGL() {
shader_dirty = true;
has_ARB_buffer_storage = false; has_ARB_buffer_storage = false;
has_ARB_direct_state_access = false; has_ARB_direct_state_access = false;
has_ARB_separate_shader_objects = false; has_ARB_separate_shader_objects = false;
@ -88,6 +62,8 @@ RasterizerOpenGL::RasterizerOpenGL() {
} }
} }
ASSERT_MSG(has_ARB_separate_shader_objects, "has_ARB_separate_shader_objects is unsupported");
// Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0 // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
state.clip_distance[0] = true; state.clip_distance[0] = true;
@ -102,37 +78,28 @@ RasterizerOpenGL::RasterizerOpenGL() {
state.draw.uniform_buffer = uniform_buffer.handle; state.draw.uniform_buffer = uniform_buffer.handle;
state.Apply(); state.Apply();
glBufferData(GL_UNIFORM_BUFFER, sizeof(UniformData), nullptr, GL_STATIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, uniform_buffer.handle);
uniform_block_data.dirty = true;
// Create render framebuffer // Create render framebuffer
framebuffer.Create(); framebuffer.Create();
if (has_ARB_separate_shader_objects) { hw_vao.Create();
hw_vao.Create(); hw_vao_enabled_attributes.fill(false);
hw_vao_enabled_attributes.fill(false);
stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER); stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2); stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
state.draw.vertex_buffer = stream_buffer->GetHandle(); state.draw.vertex_buffer = stream_buffer->GetHandle();
pipeline.Create(); shader_program_manager = std::make_unique<GLShader::ProgramManager>();
state.draw.program_pipeline = pipeline.handle;
state.draw.shader_program = 0;
state.draw.vertex_array = hw_vao.handle;
state.Apply();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle()); state.draw.shader_program = 0;
state.draw.vertex_array = hw_vao.handle;
state.Apply();
vs_uniform_buffer.Create(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, stream_buffer->GetHandle());
glBindBuffer(GL_UNIFORM_BUFFER, vs_uniform_buffer.handle);
glBufferData(GL_UNIFORM_BUFFER, sizeof(VSUniformData), nullptr, GL_STREAM_COPY); vs_uniform_buffer.Create();
glBindBufferBase(GL_UNIFORM_BUFFER, 1, vs_uniform_buffer.handle); glBindBuffer(GL_UNIFORM_BUFFER, vs_uniform_buffer.handle);
} else { glBufferData(GL_UNIFORM_BUFFER, sizeof(GLShader::VSUniformData), nullptr, GL_STREAM_COPY);
UNREACHABLE(); glBindBufferBase(GL_UNIFORM_BUFFER, 1, vs_uniform_buffer.handle);
}
accelerate_draw = AccelDraw::Disabled; accelerate_draw = AccelDraw::Disabled;
@ -200,26 +167,20 @@ void RasterizerOpenGL::SetupVertexArray(u8* array_ptr, GLintptr buffer_offset) {
buffer_offset += data_size; buffer_offset += data_size;
} }
void RasterizerOpenGL::SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset) { void RasterizerOpenGL::SetupVertexShader(GLShader::VSUniformData* ub_ptr, GLintptr buffer_offset) {
MICROPROFILE_SCOPE(OpenGL_VS); MICROPROFILE_SCOPE(OpenGL_VS);
LOG_CRITICAL(Render_OpenGL, "Emulated shaders are not supported! Using a passthrough shader."); UNREACHABLE();
glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current_shader->shader.handle);
} }
void RasterizerOpenGL::SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset) { void RasterizerOpenGL::SetupFragmentShader(GLShader::FSUniformData* ub_ptr,
GLintptr buffer_offset) {
MICROPROFILE_SCOPE(OpenGL_FS); MICROPROFILE_SCOPE(OpenGL_FS);
UNREACHABLE(); UNREACHABLE();
} }
bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) { bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
if (!has_ARB_separate_shader_objects) {
UNREACHABLE();
return false;
}
accelerate_draw = is_indexed ? AccelDraw::Indexed : AccelDraw::Arrays; accelerate_draw = is_indexed ? AccelDraw::Indexed : AccelDraw::Arrays;
DrawArrays(); DrawArrays();
return true; return true;
} }
@ -280,18 +241,6 @@ void RasterizerOpenGL::DrawArrays() {
// Sync and bind the texture surfaces // Sync and bind the texture surfaces
BindTextures(); BindTextures();
// Sync and bind the shader
if (shader_dirty) {
SetShader();
shader_dirty = false;
}
// Sync the uniform data
if (uniform_block_data.dirty) {
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(UniformData), &uniform_block_data.data);
uniform_block_data.dirty = false;
}
// Viewport can have negative offsets or larger dimensions than our framebuffer sub-rect. Enable // Viewport can have negative offsets or larger dimensions than our framebuffer sub-rect. Enable
// scissor test to prevent drawing outside of the framebuffer region // scissor test to prevent drawing outside of the framebuffer region
state.scissor.enabled = true; state.scissor.enabled = true;
@ -311,7 +260,7 @@ void RasterizerOpenGL::DrawArrays() {
if (is_indexed) { if (is_indexed) {
UNREACHABLE(); UNREACHABLE();
} }
buffer_size += sizeof(VSUniformData); buffer_size += sizeof(GLShader::VSUniformData);
size_t ptr_pos = 0; size_t ptr_pos = 0;
u8* buffer_ptr; u8* buffer_ptr;
@ -327,10 +276,10 @@ void RasterizerOpenGL::DrawArrays() {
UNREACHABLE(); UNREACHABLE();
} }
SetupVertexShader(reinterpret_cast<VSUniformData*>(&buffer_ptr[ptr_pos]), SetupVertexShader(reinterpret_cast<GLShader::VSUniformData*>(&buffer_ptr[ptr_pos]),
buffer_offset + static_cast<GLintptr>(ptr_pos)); buffer_offset + static_cast<GLintptr>(ptr_pos));
const GLintptr vs_ubo_offset = buffer_offset + static_cast<GLintptr>(ptr_pos); const GLintptr vs_ubo_offset = buffer_offset + static_cast<GLintptr>(ptr_pos);
ptr_pos += sizeof(VSUniformData); ptr_pos += sizeof(GLShader::VSUniformData);
stream_buffer->Unmap(); stream_buffer->Unmap();
@ -343,9 +292,10 @@ void RasterizerOpenGL::DrawArrays() {
} }
}; };
copy_buffer(vs_uniform_buffer.handle, vs_ubo_offset, sizeof(VSUniformData)); copy_buffer(vs_uniform_buffer.handle, vs_ubo_offset, sizeof(GLShader::VSUniformData));
glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current_shader->shader.handle); shader_program_manager->ApplyTo(state);
state.Apply();
if (is_indexed) { if (is_indexed) {
UNREACHABLE(); UNREACHABLE();
@ -531,72 +481,6 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
} }
} }
void RasterizerOpenGL::SetShader() {
// TODO(bunnei): The below sets up a static test shader for passing untransformed vertices to
// OpenGL for rendering. This should be removed/replaced when we start emulating Maxwell
// shaders.
static constexpr char vertex_shader[] = R"(
#version 150 core
in vec2 vert_position;
in vec2 vert_tex_coord;
out vec2 frag_tex_coord;
void main() {
// Multiply input position by the rotscale part of the matrix and then manually translate by
// the last column. This is equivalent to using a full 3x3 matrix and expanding the vector
// to `vec3(vert_position.xy, 1.0)`
gl_Position = vec4(mat2(mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)) * vert_position + mat3x2(0.0015625f, 0.0, 0.0, -0.0027778, -1.0, 1.0)[2], 0.0, 1.0);
frag_tex_coord = vert_tex_coord;
}
)";
static constexpr char fragment_shader[] = R"(
#version 150 core
in vec2 frag_tex_coord;
out vec4 color;
uniform sampler2D tex[32];
void main() {
color = texture(tex[0], frag_tex_coord);
}
)";
if (current_shader) {
return;
}
LOG_CRITICAL(Render_OpenGL, "Emulated shaders are not supported! Using a passthrough shader.");
current_shader = &test_shader;
if (has_ARB_separate_shader_objects) {
test_shader.shader.CreateFromSource(vertex_shader, nullptr, fragment_shader, true);
glActiveShaderProgram(pipeline.handle, test_shader.shader.handle);
} else {
UNREACHABLE();
}
state.draw.shader_program = test_shader.shader.handle;
state.Apply();
for (u32 texture = 0; texture < texture_samplers.size(); ++texture) {
// Set the texture samplers to correspond to different texture units
std::string uniform_name = "tex[" + std::to_string(texture) + "]";
GLint uniform_tex = glGetUniformLocation(test_shader.shader.handle, uniform_name.c_str());
if (uniform_tex != -1) {
glUniform1i(uniform_tex, TextureUnits::MaxwellTexture(texture).id);
}
}
if (has_ARB_separate_shader_objects) {
state.draw.shader_program = 0;
state.Apply();
}
}
void RasterizerOpenGL::BindFramebufferSurfaces(const Surface& color_surface, void RasterizerOpenGL::BindFramebufferSurfaces(const Surface& color_surface,
const Surface& depth_surface, bool has_stencil) { const Surface& depth_surface, bool has_stencil) {
state.draw.draw_framebuffer = framebuffer.handle; state.draw.draw_framebuffer = framebuffer.handle;

57
src/video_core/renderer_opengl/gl_rasterizer.h
View File

@ -19,6 +19,7 @@
#include "video_core/renderer_opengl/gl_rasterizer_cache.h" #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
#include "video_core/renderer_opengl/gl_resource_manager.h" #include "video_core/renderer_opengl/gl_resource_manager.h"
#include "video_core/renderer_opengl/gl_shader_gen.h" #include "video_core/renderer_opengl/gl_shader_gen.h"
#include "video_core/renderer_opengl/gl_shader_manager.h"
#include "video_core/renderer_opengl/gl_state.h" #include "video_core/renderer_opengl/gl_state.h"
#include "video_core/renderer_opengl/gl_stream_buffer.h" #include "video_core/renderer_opengl/gl_stream_buffer.h"
@ -56,34 +57,6 @@ public:
OGLShader shader; OGLShader shader;
}; };
/// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned
// NOTE: Always keep a vec4 at the end. The GL spec is not clear wether the alignment at
// the end of a uniform block is included in UNIFORM_BLOCK_DATA_SIZE or not.
// Not following that rule will cause problems on some AMD drivers.
struct UniformData {};
// static_assert(
// sizeof(UniformData) == 0x460,
// "The size of the UniformData structure has changed, update the structure in the shader");
static_assert(sizeof(UniformData) < 16384,
"UniformData structure must be less than 16kb as per the OpenGL spec");
struct VSUniformData {};
// static_assert(
// sizeof(VSUniformData) == 1856,
// "The size of the VSUniformData structure has changed, update the structure in the
// shader");
static_assert(sizeof(VSUniformData) < 16384,
"VSUniformData structure must be less than 16kb as per the OpenGL spec");
struct FSUniformData {};
// static_assert(
// sizeof(FSUniformData) == 1856,
// "The size of the FSUniformData structure has changed, update the structure in the
// shader");
static_assert(sizeof(FSUniformData) < 16384,
"FSUniformData structure must be less than 16kb as per the OpenGL spec");
private: private:
class SamplerInfo { class SamplerInfo {
public: public:
@ -122,9 +95,6 @@ private:
/// Syncs the clip coefficients to match the guest state /// Syncs the clip coefficients to match the guest state
void SyncClipCoef(); void SyncClipCoef();
/// Sets the OpenGL shader in accordance with the current guest state
void SetShader();
/// Syncs the cull mode to match the guest state /// Syncs the cull mode to match the guest state
void SyncCullMode(); void SyncCullMode();
@ -152,18 +122,7 @@ private:
RasterizerCacheOpenGL res_cache; RasterizerCacheOpenGL res_cache;
/// Shader used for test renderering - to be removed once we have emulated shaders std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
MaxwellShader test_shader{};
const MaxwellShader* current_shader{};
bool shader_dirty{};
struct {
UniformData data;
bool dirty;
} uniform_block_data = {};
OGLPipeline pipeline;
OGLVertexArray sw_vao; OGLVertexArray sw_vao;
OGLVertexArray hw_vao; OGLVertexArray hw_vao;
std::array<bool, 16> hw_vao_enabled_attributes; std::array<bool, 16> hw_vao_enabled_attributes;
@ -183,18 +142,10 @@ private:
void SetupVertexArray(u8* array_ptr, GLintptr buffer_offset); void SetupVertexArray(u8* array_ptr, GLintptr buffer_offset);
OGLBuffer vs_uniform_buffer; OGLBuffer vs_uniform_buffer;
std::unordered_map<GLShader::MaxwellVSConfig, VertexShader*> vs_shader_map;
std::unordered_map<std::string, VertexShader> vs_shader_cache;
OGLShader vs_default_shader;
void SetupVertexShader(VSUniformData* ub_ptr, GLintptr buffer_offset); void SetupVertexShader(GLShader::VSUniformData* ub_ptr, GLintptr buffer_offset);
OGLBuffer fs_uniform_buffer; void SetupFragmentShader(GLShader::FSUniformData* ub_ptr, GLintptr buffer_offset);
std::unordered_map<GLShader::MaxwellFSConfig, FragmentShader*> fs_shader_map;
std::unordered_map<std::string, FragmentShader> fs_shader_cache;
OGLShader fs_default_shader;
void SetupFragmentShader(FSUniformData* ub_ptr, GLintptr buffer_offset);
enum class AccelDraw { Disabled, Arrays, Indexed }; enum class AccelDraw { Disabled, Arrays, Indexed };
AccelDraw accelerate_draw; AccelDraw accelerate_draw;