history-museum/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2025-06-15 21:25:45 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

GPU: More work on OpenGL renderer

Browse Source
This commit is contained in:
Connor McLaughlin
2019-09-13 00:18:13 +10:00
parent 4706a906d5
commit aea7a18ac2
20 changed files with 655 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
src/pse/gpu_hw_opengl.cpp
View File

@ -1,6 +1,8 @@
#include "gpu_hw_opengl.h"
#include "YBaseLib/Assert.h"
#include "YBaseLib/Log.h"
#include "host_interface.h"
#include "system.h"
Log_SetChannel(GPU_HW_OpenGL);
GPU_HW_OpenGL::GPU_HW_OpenGL() : GPU_HW() {}
@ -10,12 +12,16 @@ GPU_HW_OpenGL::~GPU_HW_OpenGL()
DestroyFramebuffer();
}
bool GPU_HW_OpenGL::Initialize(Bus* bus, DMA* dma)
bool GPU_HW_OpenGL::Initialize(System* system, Bus* bus, DMA* dma)
{
if (!GPU_HW::Initialize(bus, dma))
if (!GPU_HW::Initialize(system, bus, dma))
return false;
CreateFramebuffer();
CreateVertexBuffer();
if (!CompilePrograms())
return false;
return true;
}
@ -28,16 +34,12 @@ void GPU_HW_OpenGL::Reset()
void GPU_HW_OpenGL::CreateFramebuffer()
{
glGenTextures(1, &m_framebuffer_texture_id);
glBindTexture(GL_TEXTURE_2D, m_framebuffer_texture_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VRAM_WIDTH, VRAM_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
m_framebuffer_texture =
std::make_unique<GL::Texture>(VRAM_WIDTH, VRAM_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, nullptr, false);
glGenFramebuffers(1, &m_framebuffer_fbo_id);
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_framebuffer_texture_id, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_framebuffer_texture->GetGLId(), 0);
Assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
}
@ -48,6 +50,8 @@ void GPU_HW_OpenGL::ClearFramebuffer()
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
m_system->GetHostInterface()->SetDisplayTexture(m_framebuffer_texture.get(), 0, 0, VRAM_WIDTH, VRAM_HEIGHT);
}
void GPU_HW_OpenGL::DestroyFramebuffer()
@ -55,27 +59,108 @@ void GPU_HW_OpenGL::DestroyFramebuffer()
glDeleteFramebuffers(1, &m_framebuffer_fbo_id);
m_framebuffer_fbo_id = 0;
glDeleteTextures(1, &m_framebuffer_texture_id);
m_framebuffer_texture_id = 0;
m_framebuffer_texture.reset();
}
void GPU_HW_OpenGL::CreateVertexBuffer()
{
glGenBuffers(1, &m_vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, 128, nullptr, GL_STREAM_DRAW);
glGenVertexArrays(1, &m_vao_id);
glBindVertexArray(m_vao_id);
glVertexAttribIPointer(0, 2, GL_INT, sizeof(HWVertex), reinterpret_cast<void*>(offsetof(HWVertex, x)));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(HWVertex),
reinterpret_cast<void*>(offsetof(HWVertex, color)));
glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(HWVertex), reinterpret_cast<void*>(offsetof(HWVertex, color)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glBindVertexArray(0);
}
bool GPU_HW_OpenGL::CompilePrograms()
{
for (u32 texture_enable_i = 0; texture_enable_i < 2; texture_enable_i++)
{
const bool texture_enable = ConvertToBool(texture_enable_i);
const std::string vs = GenerateVertexShader(texture_enable);
const std::string fs = GenerateFragmentShader(texture_enable);
GL::Program& prog = texture_enable ? m_texture_program : m_color_program;
if (!prog.Compile(vs.c_str(), fs.c_str()))
return false;
prog.BindAttribute(0, "a_position");
prog.BindAttribute(1, "a_color");
if (texture_enable)
prog.BindAttribute(2, "a_texcoord");
prog.BindFragData(0, "ocol0");
if (!prog.Link())
return false;
}
return true;
}
bool GPU_HW_OpenGL::SetProgram(bool texture_enable)
{
GL::Program& prog = texture_enable ? m_texture_program : m_color_program;
if (!prog.IsVaild())
return false;
prog.Bind();
return true;
}
void GPU_HW_OpenGL::SetViewport()
{
int x, y, width, height;
CalcViewport(&x, &y, &width, &height);
y = VRAM_HEIGHT - y - height;
Log_DebugPrintf("SetViewport: Offset (%d,%d) Size (%d, %d)", x, y, width, height);
glViewport(x, y, width, height);
}
void GPU_HW_OpenGL::SetScissor() {}
void GPU_HW_OpenGL::DispatchRenderCommand(RenderCommand rc, u32 num_vertices)
{
LoadVertices(rc, num_vertices);
if (m_vertex_staging.empty())
return;
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
if (!SetProgram(rc.texture_enable))
{
Log_ErrorPrintf("Failed to set GL program");
m_vertex_staging.clear();
return;
}
if (rc.texture_enable)
m_texture_program.Bind();
else
m_color_program.Bind();
SetViewport();
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
glBindVertexArray(m_vao_id);
glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizei>(sizeof(HWVertex) * m_vertex_staging.size()),
m_vertex_staging.data(), GL_STREAM_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribIPointer(0, 2, GL_INT, sizeof(HWVertex), reinterpret_cast<void*>(offsetof(HWVertex, x)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(HWVertex),
reinterpret_cast<void*>(offsetof(HWVertex, color)));
glEnableVertexAttribArray(2);
glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, sizeof(HWVertex), reinterpret_cast<void*>(offsetof(HWVertex, color)));
glDrawArrays(rc.quad_polygon ? GL_TRIANGLE_STRIP : GL_TRIANGLES, 0, static_cast<GLsizei>(m_vertex_staging.size()));
m_system->GetHostInterface()->SetDisplayTexture(m_framebuffer_texture.get(), 0, 0, VRAM_WIDTH, VRAM_HEIGHT);
m_vertex_staging.clear();
}
void GPU_HW_OpenGL::FlushRender()
@ -90,98 +175,3 @@ std::unique_ptr<GPU> GPU::CreateHardwareOpenGLRenderer()
{
return std::make_unique<GPU_HW_OpenGL>();
}
void GPU_HW_OpenGL::Program::Bind()
{
glUseProgram(program_id);
}
static GLuint CompileShader(GLenum type, const std::string& source)
{
GLuint id = glCreateShader(type);
std::array<const GLchar*, 1> sources = {{source.c_str()}};
std::array<GLint, 1> source_lengths = {{static_cast<GLint>(source.size())}};
glShaderSource(id, static_cast<GLsizei>(source.size()), sources.data(), source_lengths.data());
GLint status = GL_FALSE;
glGetShaderiv(id, GL_COMPILE_STATUS, &status);
GLint info_log_length = 0;
glGetShaderiv(id, GL_INFO_LOG_LENGTH, &info_log_length);
if (status == GL_FALSE || info_log_length > 0)
{
std::string info_log;
info_log.resize(info_log_length + 1);
glGetShaderInfoLog(id, info_log_length, &info_log_length, info_log.data());
if (status == GL_TRUE)
{
Log_ErrorPrintf("Shader compiled with warnings:\n%s", info_log.c_str());
}
else
{
Log_ErrorPrintf("Shader failed to compile:\n%s", info_log.c_str());
glDeleteShader(id);
return 0;
}
}
return id;
}
bool GPU_HW_OpenGL::Program::Compile(const std::string& vertex_shader, const std::string& fragment_shader)
{
GLuint vertex_shader_id = CompileShader(GL_VERTEX_SHADER, vertex_shader);
if (vertex_shader_id == 0)
return false;
GLuint fragment_shader_id = CompileShader(GL_FRAGMENT_SHADER, fragment_shader);
if (fragment_shader_id == 0)
{
glDeleteShader(vertex_shader_id);
return false;
}
program_id = glCreateProgram();
glAttachShader(program_id, vertex_shader_id);
glAttachShader(program_id, fragment_shader_id);
glBindAttribLocation(program_id, 0, "a_position");
glBindAttribLocation(program_id, 1, "a_texcoord");
glBindAttribLocation(program_id, 2, "a_color");
glBindFragDataLocation(program_id, 0, "ocol0");
glLinkProgram(program_id);
glDeleteShader(vertex_shader_id);
glDeleteShader(fragment_shader_id);
GLint status = GL_FALSE;
glGetProgramiv(program_id, GL_LINK_STATUS, &status);
GLint info_log_length = 0;
glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_log_length);
if (status == GL_FALSE || info_log_length > 0)
{
std::string info_log;
info_log.resize(info_log_length + 1);
glGetProgramInfoLog(program_id, info_log_length, &info_log_length, info_log.data());
if (status == GL_TRUE)
{
Log_ErrorPrintf("Program linked with warnings:\n%s", info_log.c_str());
}
else
{
Log_ErrorPrintf("Program failed to link:\n%s", info_log.c_str());
glDeleteProgram(program_id);
program_id = 0;
return false;
}
}
return true;
}