2019-09-12 02:53:04 +00:00
|
|
|
#include "gpu_hw_opengl.h"
|
|
|
|
#include "YBaseLib/Assert.h"
|
|
|
|
#include "YBaseLib/Log.h"
|
2019-09-12 14:18:13 +00:00
|
|
|
#include "host_interface.h"
|
2019-09-26 04:03:32 +00:00
|
|
|
#include "imgui.h"
|
2019-09-12 14:18:13 +00:00
|
|
|
#include "system.h"
|
2019-09-12 02:53:04 +00:00
|
|
|
Log_SetChannel(GPU_HW_OpenGL);
|
|
|
|
|
|
|
|
GPU_HW_OpenGL::GPU_HW_OpenGL() : GPU_HW() {}
|
|
|
|
|
|
|
|
GPU_HW_OpenGL::~GPU_HW_OpenGL()
|
|
|
|
{
|
|
|
|
DestroyFramebuffer();
|
|
|
|
}
|
|
|
|
|
2019-09-20 13:40:19 +00:00
|
|
|
bool GPU_HW_OpenGL::Initialize(System* system, DMA* dma, InterruptController* interrupt_controller, Timers* timers)
|
2019-09-12 02:53:04 +00:00
|
|
|
{
|
2019-09-20 13:40:19 +00:00
|
|
|
if (!GPU_HW::Initialize(system, dma, interrupt_controller, timers))
|
2019-09-12 02:53:04 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
CreateFramebuffer();
|
2019-09-12 14:18:13 +00:00
|
|
|
CreateVertexBuffer();
|
|
|
|
if (!CompilePrograms())
|
|
|
|
return false;
|
|
|
|
|
2019-09-12 02:53:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GPU_HW_OpenGL::Reset()
|
|
|
|
{
|
|
|
|
GPU_HW::Reset();
|
|
|
|
|
|
|
|
ClearFramebuffer();
|
|
|
|
}
|
|
|
|
|
2019-09-26 04:03:32 +00:00
|
|
|
void GPU_HW_OpenGL::RenderUI()
|
|
|
|
{
|
|
|
|
GPU_HW::RenderUI();
|
|
|
|
|
2019-09-27 12:02:13 +00:00
|
|
|
ImGui::SetNextWindowSize(ImVec2(300.0f, 130.0f), ImGuiCond_Once);
|
2019-09-27 11:16:06 +00:00
|
|
|
|
|
|
|
const bool is_null_frame = m_stats.num_batches == 0;
|
|
|
|
if (!is_null_frame)
|
|
|
|
{
|
|
|
|
m_last_stats = m_stats;
|
|
|
|
m_stats = {};
|
|
|
|
}
|
|
|
|
|
2019-09-26 04:03:32 +00:00
|
|
|
if (ImGui::Begin("GL Render Statistics"))
|
|
|
|
{
|
|
|
|
ImGui::Columns(2);
|
2019-09-27 11:16:06 +00:00
|
|
|
ImGui::SetColumnWidth(0, 200.0f);
|
2019-09-26 04:03:32 +00:00
|
|
|
|
2019-09-27 11:16:06 +00:00
|
|
|
ImGui::TextUnformatted("VRAM Read Texture Updates:");
|
2019-09-26 04:03:32 +00:00
|
|
|
ImGui::NextColumn();
|
2019-09-27 11:16:06 +00:00
|
|
|
ImGui::Text("%u", m_last_stats.num_vram_read_texture_updates);
|
2019-09-26 04:03:32 +00:00
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
ImGui::TextUnformatted("Batches Drawn:");
|
|
|
|
ImGui::NextColumn();
|
2019-09-27 11:16:06 +00:00
|
|
|
ImGui::Text("%u", m_last_stats.num_batches);
|
2019-09-26 04:03:32 +00:00
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
ImGui::TextUnformatted("Vertices Drawn: ");
|
|
|
|
ImGui::NextColumn();
|
2019-09-27 11:16:06 +00:00
|
|
|
ImGui::Text("%u", m_last_stats.num_vertices);
|
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
ImGui::TextUnformatted("GPU Active In This Frame: ");
|
|
|
|
ImGui::NextColumn();
|
|
|
|
ImGui::Text("%s", is_null_frame ? "Yes" : "No");
|
2019-09-26 04:03:32 +00:00
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
ImGui::Columns(1);
|
2019-09-27 12:02:13 +00:00
|
|
|
|
|
|
|
ImGui::Checkbox("Show VRAM##gpu_gl_show_vram", &m_show_vram);
|
2019-09-26 04:03:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ImGui::End();
|
|
|
|
}
|
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
void GPU_HW_OpenGL::InvalidateVRAMReadCache()
|
|
|
|
{
|
|
|
|
m_vram_read_texture_dirty = true;
|
|
|
|
}
|
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
std::tuple<s32, s32> GPU_HW_OpenGL::ConvertToFramebufferCoordinates(s32 x, s32 y)
|
|
|
|
{
|
|
|
|
return std::make_tuple(x, static_cast<s32>(static_cast<s32>(VRAM_HEIGHT) - y));
|
|
|
|
}
|
|
|
|
|
2019-09-12 02:53:04 +00:00
|
|
|
void GPU_HW_OpenGL::CreateFramebuffer()
|
|
|
|
{
|
2019-09-12 14:18:13 +00:00
|
|
|
m_framebuffer_texture =
|
|
|
|
std::make_unique<GL::Texture>(VRAM_WIDTH, VRAM_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, nullptr, false);
|
2019-09-12 02:53:04 +00:00
|
|
|
|
|
|
|
glGenFramebuffers(1, &m_framebuffer_fbo_id);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
|
2019-09-12 14:18:13 +00:00
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_framebuffer_texture->GetGLId(), 0);
|
2019-09-12 02:53:04 +00:00
|
|
|
Assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
|
2019-09-13 16:07:31 +00:00
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
m_vram_read_texture =
|
|
|
|
std::make_unique<GL::Texture>(VRAM_WIDTH, VRAM_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, nullptr, false);
|
|
|
|
glGenFramebuffers(1, &m_vram_read_fbo_id);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_vram_read_fbo_id);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_vram_read_texture->GetGLId(), 0);
|
2019-09-13 16:07:31 +00:00
|
|
|
Assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
|
2019-09-27 12:02:13 +00:00
|
|
|
|
|
|
|
m_display_texture = std::make_unique<GL::Texture>(VRAM_WIDTH, VRAM_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, nullptr, false);
|
|
|
|
m_display_texture->Bind();
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glGenFramebuffers(1, &m_display_fbo_id);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_display_fbo_id);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_display_texture->GetGLId(), 0);
|
|
|
|
Assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GPU_HW_OpenGL::ClearFramebuffer()
|
|
|
|
{
|
|
|
|
// TODO: get rid of the FBO switches
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
|
|
|
|
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
2019-09-12 14:18:13 +00:00
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
m_system->GetHostInterface()->SetDisplayTexture(m_framebuffer_texture.get(), 0, 0, VRAM_WIDTH, VRAM_HEIGHT);
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GPU_HW_OpenGL::DestroyFramebuffer()
|
|
|
|
{
|
2019-09-26 13:33:20 +00:00
|
|
|
glDeleteFramebuffers(1, &m_vram_read_fbo_id);
|
|
|
|
m_vram_read_fbo_id = 0;
|
|
|
|
m_vram_read_texture.reset();
|
2019-09-13 16:07:31 +00:00
|
|
|
|
2019-09-12 02:53:04 +00:00
|
|
|
glDeleteFramebuffers(1, &m_framebuffer_fbo_id);
|
|
|
|
m_framebuffer_fbo_id = 0;
|
2019-09-12 14:18:13 +00:00
|
|
|
m_framebuffer_texture.reset();
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
void GPU_HW_OpenGL::CreateVertexBuffer()
|
2019-09-12 02:53:04 +00:00
|
|
|
{
|
2019-09-12 14:18:13 +00:00
|
|
|
glGenBuffers(1, &m_vertex_buffer);
|
2019-09-12 02:53:04 +00:00
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
|
2019-09-14 15:18:58 +00:00
|
|
|
glBufferData(GL_ARRAY_BUFFER, VERTEX_BUFFER_SIZE, nullptr, GL_STREAM_DRAW);
|
2019-09-12 14:18:13 +00:00
|
|
|
|
|
|
|
glGenVertexArrays(1, &m_vao_id);
|
|
|
|
glBindVertexArray(m_vao_id);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
|
|
glEnableVertexAttribArray(1);
|
|
|
|
glEnableVertexAttribArray(2);
|
2019-09-27 11:20:35 +00:00
|
|
|
glEnableVertexAttribArray(3);
|
2019-09-13 16:07:31 +00:00
|
|
|
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)));
|
|
|
|
glVertexAttribPointer(2, 2, GL_UNSIGNED_BYTE, true, sizeof(HWVertex),
|
|
|
|
reinterpret_cast<void*>(offsetof(HWVertex, texcoord)));
|
2019-09-27 11:20:35 +00:00
|
|
|
glVertexAttribIPointer(3, 1, GL_INT, sizeof(HWVertex), reinterpret_cast<void*>(offsetof(HWVertex, texpage)));
|
2019-09-12 14:18:13 +00:00
|
|
|
glBindVertexArray(0);
|
2019-09-13 16:07:31 +00:00
|
|
|
|
|
|
|
glGenVertexArrays(1, &m_attributeless_vao_id);
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
bool GPU_HW_OpenGL::CompilePrograms()
|
2019-09-12 02:53:04 +00:00
|
|
|
{
|
2019-09-26 13:33:20 +00:00
|
|
|
for (u32 textured = 0; textured < 2; textured++)
|
2019-09-12 14:18:13 +00:00
|
|
|
{
|
2019-09-26 13:33:20 +00:00
|
|
|
for (u32 blending = 0; blending < 2; blending++)
|
|
|
|
{
|
2019-09-27 07:40:26 +00:00
|
|
|
for (u32 transparent = 0; transparent < 2; transparent++)
|
2019-09-26 13:33:20 +00:00
|
|
|
{
|
2019-09-27 07:40:26 +00:00
|
|
|
for (u32 format = 0; format < 3; format++)
|
2019-09-26 13:33:20 +00:00
|
|
|
{
|
2019-09-27 07:40:26 +00:00
|
|
|
// TODO: eliminate duplicate shaders here
|
|
|
|
if (!CompileProgram(m_render_programs[textured][blending][transparent][format],
|
|
|
|
ConvertToBoolUnchecked(textured), ConvertToBoolUnchecked(blending),
|
|
|
|
ConvertToBoolUnchecked(transparent), static_cast<TextureColorMode>(format)))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2019-09-26 13:33:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-09-12 14:18:13 +00:00
|
|
|
}
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
return true;
|
|
|
|
}
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-27 07:40:26 +00:00
|
|
|
bool GPU_HW_OpenGL::CompileProgram(GL::Program& prog, bool textured, bool blending, bool transparent,
|
|
|
|
TextureColorMode texture_color_mode)
|
2019-09-12 14:18:13 +00:00
|
|
|
{
|
2019-09-13 16:07:31 +00:00
|
|
|
const std::string vs = GenerateVertexShader(textured);
|
2019-09-27 07:40:26 +00:00
|
|
|
const std::string fs = GenerateFragmentShader(textured, blending, transparent, texture_color_mode);
|
2019-09-13 16:07:31 +00:00
|
|
|
if (!prog.Compile(vs.c_str(), fs.c_str()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
prog.BindAttribute(0, "a_pos");
|
|
|
|
prog.BindAttribute(1, "a_col0");
|
|
|
|
if (textured)
|
2019-09-27 11:20:35 +00:00
|
|
|
{
|
2019-09-13 16:07:31 +00:00
|
|
|
prog.BindAttribute(2, "a_tex0");
|
2019-09-27 11:20:35 +00:00
|
|
|
prog.BindAttribute(3, "a_texpage");
|
|
|
|
}
|
2019-09-13 16:07:31 +00:00
|
|
|
|
|
|
|
prog.BindFragData(0, "o_col0");
|
|
|
|
|
|
|
|
if (!prog.Link())
|
2019-09-12 14:18:13 +00:00
|
|
|
return false;
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-25 14:15:21 +00:00
|
|
|
prog.Bind();
|
|
|
|
prog.RegisterUniform("u_pos_offset");
|
2019-09-27 07:40:26 +00:00
|
|
|
prog.RegisterUniform("u_transparent_alpha");
|
2019-09-25 14:15:21 +00:00
|
|
|
prog.Uniform2i(0, 0, 0);
|
2019-09-27 07:40:26 +00:00
|
|
|
prog.Uniform2f(1, 1.0f, 0.0f);
|
2019-09-25 14:15:21 +00:00
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
if (textured)
|
|
|
|
{
|
|
|
|
prog.RegisterUniform("samp0");
|
2019-09-27 07:40:26 +00:00
|
|
|
prog.Uniform1i(2, 0);
|
2019-09-13 16:07:31 +00:00
|
|
|
}
|
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
return true;
|
|
|
|
}
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
void GPU_HW_OpenGL::SetProgram()
|
2019-09-13 16:07:31 +00:00
|
|
|
{
|
2019-09-26 13:33:20 +00:00
|
|
|
const GL::Program& prog =
|
|
|
|
m_render_programs[BoolToUInt32(m_batch.texture_enable)][BoolToUInt32(m_batch.texture_blending_enable)]
|
2019-09-27 07:40:26 +00:00
|
|
|
[BoolToUInt32(m_batch.transparency_enable)][static_cast<u32>(m_batch.texture_color_mode)];
|
2019-09-13 16:07:31 +00:00
|
|
|
prog.Bind();
|
2019-09-14 12:47:20 +00:00
|
|
|
|
2019-09-25 14:15:21 +00:00
|
|
|
prog.Uniform2i(0, m_drawing_offset.x, m_drawing_offset.y);
|
2019-09-27 07:40:26 +00:00
|
|
|
if (m_batch.transparency_enable)
|
|
|
|
{
|
|
|
|
static constexpr float transparent_alpha[4][2] = {{0.5f, 0.5f}, {1.0f, 1.0f}, {1.0f, 1.0f}, {0.25f, 1.0f}};
|
|
|
|
prog.Uniform2fv(1, transparent_alpha[static_cast<u32>(m_batch.transparency_mode)]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
static constexpr float disabled_alpha[2] = {1.0f, 0.0f};
|
|
|
|
prog.Uniform2fv(1, disabled_alpha);
|
|
|
|
}
|
2019-09-26 13:33:20 +00:00
|
|
|
|
|
|
|
if (m_batch.texture_enable)
|
|
|
|
m_vram_read_texture->Bind();
|
2019-09-13 16:07:31 +00:00
|
|
|
}
|
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
void GPU_HW_OpenGL::SetViewport()
|
|
|
|
{
|
2019-09-25 14:15:21 +00:00
|
|
|
glViewport(0, 0, VRAM_WIDTH, VRAM_HEIGHT);
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|
|
|
|
|
2019-09-14 11:54:58 +00:00
|
|
|
void GPU_HW_OpenGL::SetScissor()
|
|
|
|
{
|
|
|
|
int left, top, right, bottom;
|
|
|
|
CalcScissorRect(&left, &top, &right, &bottom);
|
|
|
|
|
|
|
|
const int width = right - left;
|
|
|
|
const int height = bottom - top;
|
|
|
|
const int x = left;
|
|
|
|
const int y = VRAM_HEIGHT - bottom;
|
|
|
|
|
|
|
|
Log_DebugPrintf("SetScissor: (%d-%d, %d-%d)", x, x + width, y, y + height);
|
|
|
|
glScissor(x, y, width, height);
|
|
|
|
}
|
2019-09-12 14:18:13 +00:00
|
|
|
|
2019-09-18 14:55:06 +00:00
|
|
|
void GPU_HW_OpenGL::SetBlendState()
|
|
|
|
{
|
2019-09-25 14:15:21 +00:00
|
|
|
if (!m_batch.transparency_enable)
|
2019-09-18 14:55:06 +00:00
|
|
|
{
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
glEnable(GL_BLEND);
|
2019-09-27 07:40:26 +00:00
|
|
|
glBlendEquationSeparate(m_batch.transparency_mode == GPU::TransparencyMode::BackgroundMinusForeground ?
|
|
|
|
GL_FUNC_REVERSE_SUBTRACT :
|
|
|
|
GL_FUNC_ADD,
|
|
|
|
GL_FUNC_ADD);
|
|
|
|
glBlendFuncSeparate(GL_ONE, GL_SRC_ALPHA, GL_ONE, GL_ZERO);
|
2019-09-18 14:55:06 +00:00
|
|
|
}
|
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
void GPU_HW_OpenGL::UpdateDisplay()
|
|
|
|
{
|
|
|
|
GPU_HW::UpdateDisplay();
|
2019-09-27 12:02:13 +00:00
|
|
|
|
|
|
|
// TODO: 24-bit support.
|
|
|
|
if (m_show_vram)
|
|
|
|
{
|
|
|
|
m_system->GetHostInterface()->SetDisplayTexture(m_framebuffer_texture.get(), 0, 0, VRAM_WIDTH, VRAM_HEIGHT);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const u32 display_width = m_crtc_state.horizontal_resolution;
|
|
|
|
const u32 display_height = m_crtc_state.vertical_resolution;
|
|
|
|
const u32 vram_offset_x = m_crtc_state.regs.X;
|
|
|
|
const u32 vram_offset_y = m_crtc_state.regs.Y;
|
|
|
|
const u32 copy_width =
|
|
|
|
((vram_offset_x + display_width) > VRAM_WIDTH) ? (VRAM_WIDTH - vram_offset_x) : display_width;
|
|
|
|
const u32 copy_height =
|
|
|
|
((vram_offset_y + display_height) > VRAM_HEIGHT) ? (VRAM_HEIGHT - vram_offset_y) : display_height;
|
|
|
|
glCopyImageSubData(m_framebuffer_texture->GetGLId(), GL_TEXTURE_2D, 0, vram_offset_x,
|
|
|
|
VRAM_HEIGHT - vram_offset_y - copy_height, 0, m_display_texture->GetGLId(), GL_TEXTURE_2D, 0, 0,
|
|
|
|
0, 0, copy_width, copy_height, 1);
|
|
|
|
|
|
|
|
m_system->GetHostInterface()->SetDisplayTexture(m_display_texture.get(), 0, 0, copy_width, copy_height);
|
|
|
|
}
|
2019-09-13 16:07:31 +00:00
|
|
|
}
|
|
|
|
|
2019-09-14 10:45:26 +00:00
|
|
|
void GPU_HW_OpenGL::ReadVRAM(u32 x, u32 y, u32 width, u32 height, void* buffer)
|
|
|
|
{
|
|
|
|
// we need to convert RGBA8 -> RGBA5551
|
|
|
|
std::vector<u32> temp_buffer(width * height);
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_framebuffer_fbo_id);
|
2019-09-14 11:34:55 +00:00
|
|
|
glReadPixels(x, VRAM_HEIGHT - y - height, width, height, GL_RGBA, GL_UNSIGNED_BYTE, temp_buffer.data());
|
2019-09-14 10:45:26 +00:00
|
|
|
|
|
|
|
// reverse copy because of lower-left origin
|
|
|
|
const u32 source_stride = width * sizeof(u32);
|
|
|
|
const u8* source_ptr = reinterpret_cast<const u8*>(temp_buffer.data()) + (source_stride * (height - 1));
|
|
|
|
const u32 dst_stride = width * sizeof(u16);
|
|
|
|
u8* dst_ptr = static_cast<u8*>(buffer);
|
|
|
|
for (u32 row = 0; row < height; row++)
|
|
|
|
{
|
|
|
|
const u8* source_row_ptr = source_ptr;
|
|
|
|
u8* dst_row_ptr = dst_ptr;
|
|
|
|
|
|
|
|
for (u32 col = 0; col < width; col++)
|
|
|
|
{
|
|
|
|
u32 src_col;
|
|
|
|
std::memcpy(&src_col, source_row_ptr, sizeof(src_col));
|
|
|
|
source_row_ptr += sizeof(src_col);
|
|
|
|
|
2019-09-18 05:43:25 +00:00
|
|
|
const u16 dst_col = RGBA8888ToRGBA5551(src_col);
|
2019-09-14 10:45:26 +00:00
|
|
|
std::memcpy(dst_row_ptr, &dst_col, sizeof(dst_col));
|
|
|
|
dst_row_ptr += sizeof(dst_col);
|
|
|
|
}
|
|
|
|
|
|
|
|
source_ptr -= source_stride;
|
|
|
|
dst_ptr += dst_stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-18 05:54:57 +00:00
|
|
|
void GPU_HW_OpenGL::FillVRAM(u32 x, u32 y, u32 width, u32 height, u16 color)
|
2019-09-14 06:43:39 +00:00
|
|
|
{
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
|
|
|
|
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
glScissor(x, VRAM_HEIGHT - y - height, width, height);
|
|
|
|
|
2019-09-18 05:54:57 +00:00
|
|
|
const auto [r, g, b, a] = RGBA8ToFloat(RGBA5551ToRGBA8888(color));
|
2019-09-14 06:43:39 +00:00
|
|
|
glClearColor(r, g, b, a);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
2019-09-26 13:33:20 +00:00
|
|
|
|
|
|
|
InvalidateVRAMReadCache();
|
2019-09-14 06:43:39 +00:00
|
|
|
}
|
|
|
|
|
2019-09-12 15:10:08 +00:00
|
|
|
void GPU_HW_OpenGL::UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data)
|
|
|
|
{
|
|
|
|
std::vector<u32> rgba_data;
|
2019-09-13 16:07:31 +00:00
|
|
|
rgba_data.reserve(width * height);
|
2019-09-12 15:10:08 +00:00
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
// reverse copy the rows so it matches opengl's lower-left origin
|
|
|
|
const u32 source_stride = width * sizeof(u16);
|
|
|
|
const u8* source_ptr = static_cast<const u8*>(data) + (source_stride * (height - 1));
|
|
|
|
for (u32 row = 0; row < height; row++)
|
2019-09-12 15:10:08 +00:00
|
|
|
{
|
2019-09-13 16:07:31 +00:00
|
|
|
const u8* source_row_ptr = source_ptr;
|
|
|
|
|
|
|
|
for (u32 col = 0; col < width; col++)
|
|
|
|
{
|
|
|
|
u16 src_col;
|
|
|
|
std::memcpy(&src_col, source_row_ptr, sizeof(src_col));
|
|
|
|
source_row_ptr += sizeof(src_col);
|
|
|
|
|
2019-09-18 05:43:25 +00:00
|
|
|
const u32 dst_col = RGBA5551ToRGBA8888(src_col);
|
2019-09-13 16:07:31 +00:00
|
|
|
rgba_data.push_back(dst_col);
|
|
|
|
}
|
2019-09-12 15:10:08 +00:00
|
|
|
|
2019-09-13 16:07:31 +00:00
|
|
|
source_ptr -= source_stride;
|
2019-09-12 15:10:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
m_framebuffer_texture->Bind();
|
2019-09-13 16:07:31 +00:00
|
|
|
|
|
|
|
// lower-left origin flip happens here
|
|
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, x, VRAM_HEIGHT - y - height, width, height, GL_RGBA, GL_UNSIGNED_BYTE,
|
2019-09-12 15:10:08 +00:00
|
|
|
rgba_data.data());
|
2019-09-26 13:33:20 +00:00
|
|
|
|
|
|
|
InvalidateVRAMReadCache();
|
2019-09-12 15:10:08 +00:00
|
|
|
}
|
|
|
|
|
2019-09-17 14:58:30 +00:00
|
|
|
void GPU_HW_OpenGL::CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height)
|
|
|
|
{
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
|
|
|
|
// lower-left origin flip
|
|
|
|
src_y = VRAM_HEIGHT - src_y - height;
|
|
|
|
dst_y = VRAM_HEIGHT - dst_y - height;
|
|
|
|
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
|
|
|
|
glBlitFramebuffer(src_x, src_y, src_x + width, src_y + height, dst_x, dst_y, dst_x + width, dst_y + height,
|
|
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
2019-09-26 13:33:20 +00:00
|
|
|
|
|
|
|
InvalidateVRAMReadCache();
|
2019-09-17 14:58:30 +00:00
|
|
|
}
|
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
void GPU_HW_OpenGL::UpdateVRAMReadTexture()
|
2019-09-12 02:53:04 +00:00
|
|
|
{
|
2019-09-26 13:33:20 +00:00
|
|
|
m_stats.num_vram_read_texture_updates++;
|
|
|
|
m_vram_read_texture_dirty = false;
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
// TODO: Fallback blit path, and partial updates.
|
|
|
|
glCopyImageSubData(m_framebuffer_texture->GetGLId(), GL_TEXTURE_2D, 0, 0, 0, 0, m_vram_read_texture->GetGLId(),
|
|
|
|
GL_TEXTURE_2D, 0, 0, 0, 0, VRAM_WIDTH, VRAM_HEIGHT, 1);
|
2019-09-13 16:07:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GPU_HW_OpenGL::FlushRender()
|
|
|
|
{
|
2019-09-25 14:15:21 +00:00
|
|
|
if (m_batch.vertices.empty())
|
2019-09-13 16:07:31 +00:00
|
|
|
return;
|
|
|
|
|
2019-09-26 13:33:20 +00:00
|
|
|
if (m_vram_read_texture_dirty)
|
|
|
|
UpdateVRAMReadTexture();
|
|
|
|
|
2019-09-26 04:03:32 +00:00
|
|
|
m_stats.num_batches++;
|
|
|
|
m_stats.num_vertices += static_cast<u32>(m_batch.vertices.size());
|
|
|
|
|
2019-09-14 11:54:58 +00:00
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
glDepthMask(GL_FALSE);
|
2019-09-26 13:33:20 +00:00
|
|
|
SetProgram();
|
2019-09-12 14:18:13 +00:00
|
|
|
SetViewport();
|
2019-09-14 11:54:58 +00:00
|
|
|
SetScissor();
|
2019-09-18 14:55:06 +00:00
|
|
|
SetBlendState();
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_fbo_id);
|
|
|
|
glBindVertexArray(m_vao_id);
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-25 14:15:21 +00:00
|
|
|
Assert((m_batch.vertices.size() * sizeof(HWVertex)) <= VERTEX_BUFFER_SIZE);
|
2019-09-12 14:18:13 +00:00
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
|
2019-09-25 14:15:21 +00:00
|
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizei>(sizeof(HWVertex) * m_batch.vertices.size()),
|
|
|
|
m_batch.vertices.data());
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-27 12:45:57 +00:00
|
|
|
static constexpr std::array<GLenum, 4> gl_primitives = {{GL_LINES, GL_LINE_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP}};
|
2019-09-25 14:15:21 +00:00
|
|
|
glDrawArrays(gl_primitives[static_cast<u8>(m_batch.primitive)], 0, static_cast<GLsizei>(m_batch.vertices.size()));
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-25 14:15:21 +00:00
|
|
|
m_batch.vertices.clear();
|
2019-09-12 14:18:13 +00:00
|
|
|
}
|
2019-09-12 02:53:04 +00:00
|
|
|
|
2019-09-12 14:18:13 +00:00
|
|
|
std::unique_ptr<GPU> GPU::CreateHardwareOpenGLRenderer()
|
|
|
|
{
|
|
|
|
return std::make_unique<GPU_HW_OpenGL>();
|
2019-09-12 02:53:04 +00:00
|
|
|
}
|