diff options
| author | Shawn Hoffman <godisgovernment@gmail.com> | 2020-09-15 05:00:24 -0700 |
|---|---|---|
| committer | Shawn Hoffman <godisgovernment@gmail.com> | 2021-01-27 14:29:48 -0800 |
| commit | ff4f67492bff68d8b34aebc9ea6c85ca34e02b71 (patch) | |
| tree | f5274db377aa0af509a3095ecfbae266b008d6ae /Source/Core/VideoBackends/OGL/OGLVertexManager.cpp | |
| parent | 3193f3d5c4c699ac5396a587ac782ef014bad49e (diff) | |
normalize common filenames in VideoBackends/OGL
Diffstat (limited to 'Source/Core/VideoBackends/OGL/OGLVertexManager.cpp')
| -rw-r--r-- | Source/Core/VideoBackends/OGL/OGLVertexManager.cpp | 192 |
1 files changed, 192 insertions, 0 deletions
diff --git a/Source/Core/VideoBackends/OGL/OGLVertexManager.cpp b/Source/Core/VideoBackends/OGL/OGLVertexManager.cpp new file mode 100644 index 0000000000..5436938524 --- /dev/null +++ b/Source/Core/VideoBackends/OGL/OGLVertexManager.cpp @@ -0,0 +1,192 @@ +// Copyright 2008 Dolphin Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +#include "VideoBackends/OGL/OGLVertexManager.h" + +#include <fstream> +#include <memory> +#include <string> +#include <vector> + +#include "Common/Align.h" +#include "Common/CommonTypes.h" +#include "Common/GL/GLExtensions/GLExtensions.h" + +#include "VideoBackends/OGL/OGLPipeline.h" +#include "VideoBackends/OGL/OGLRender.h" +#include "VideoBackends/OGL/OGLStreamBuffer.h" +#include "VideoBackends/OGL/ProgramShaderCache.h" + +#include "VideoCommon/IndexGenerator.h" +#include "VideoCommon/Statistics.h" +#include "VideoCommon/VertexLoaderManager.h" +#include "VideoCommon/VideoConfig.h" + +namespace OGL +{ +static void CheckBufferBinding() +{ + // The index buffer is part of the VAO state, therefore we need to bind it first. + if (!ProgramShaderCache::IsValidVertexFormatBound()) + { + ProgramShaderCache::BindVertexFormat( + static_cast<GLVertexFormat*>(VertexLoaderManager::GetCurrentVertexFormat())); + } +} + +VertexManager::VertexManager() = default; + +VertexManager::~VertexManager() +{ + if (g_ActiveConfig.backend_info.bSupportsPaletteConversion) + { + glDeleteTextures(static_cast<GLsizei>(m_texel_buffer_views.size()), + m_texel_buffer_views.data()); + } + + // VAO must be found when destroying the index buffer. + CheckBufferBinding(); + m_texel_buffer.reset(); + m_index_buffer.reset(); + m_vertex_buffer.reset(); +} + +bool VertexManager::Initialize() +{ + if (!VertexManagerBase::Initialize()) + return false; + + m_vertex_buffer = StreamBuffer::Create(GL_ARRAY_BUFFER, VERTEX_STREAM_BUFFER_SIZE); + m_index_buffer = StreamBuffer::Create(GL_ELEMENT_ARRAY_BUFFER, INDEX_STREAM_BUFFER_SIZE); + + if (g_ActiveConfig.backend_info.bSupportsPaletteConversion) + { + // The minimum MAX_TEXTURE_BUFFER_SIZE that the spec mandates is 65KB, we are asking for a 1MB + // buffer here. This buffer is also used as storage for undecoded textures when compute shader + // texture decoding is enabled, in which case the requested size is 32MB. + GLint max_buffer_size; + glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &max_buffer_size); + m_texel_buffer = StreamBuffer::Create( + GL_TEXTURE_BUFFER, std::min(max_buffer_size, static_cast<GLint>(TEXEL_STREAM_BUFFER_SIZE))); + + // Allocate texture views backed by buffer. + static constexpr std::array<std::pair<TexelBufferFormat, GLenum>, NUM_TEXEL_BUFFER_FORMATS> + format_mapping = {{ + {TEXEL_BUFFER_FORMAT_R8_UINT, GL_R8UI}, + {TEXEL_BUFFER_FORMAT_R16_UINT, GL_R16UI}, + {TEXEL_BUFFER_FORMAT_RGBA8_UINT, GL_RGBA8UI}, + {TEXEL_BUFFER_FORMAT_R32G32_UINT, GL_RG32UI}, + }}; + glGenTextures(static_cast<GLsizei>(m_texel_buffer_views.size()), m_texel_buffer_views.data()); + glActiveTexture(GL_MUTABLE_TEXTURE_INDEX); + for (const auto& it : format_mapping) + { + glBindTexture(GL_TEXTURE_BUFFER, m_texel_buffer_views[it.first]); + glTexBuffer(GL_TEXTURE_BUFFER, it.second, m_texel_buffer->GetGLBufferId()); + } + } + + return true; +} + +void VertexManager::UploadUtilityUniforms(const void* uniforms, u32 uniforms_size) +{ + InvalidateConstants(); + ProgramShaderCache::UploadConstants(uniforms, uniforms_size); +} + +bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format, + u32* out_offset) +{ + if (data_size > m_texel_buffer->GetSize()) + return false; + + const u32 elem_size = GetTexelBufferElementSize(format); + const auto dst = m_texel_buffer->Map(data_size, elem_size); + std::memcpy(dst.first, data, data_size); + ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, data_size); + *out_offset = dst.second / elem_size; + m_texel_buffer->Unmap(data_size); + + // Bind the correct view to the texel buffer slot. + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_BUFFER, m_texel_buffer_views[static_cast<u32>(format)]); + Renderer::GetInstance()->InvalidateTextureBinding(0); + return true; +} + +bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format, + u32* out_offset, const void* palette_data, u32 palette_size, + TexelBufferFormat palette_format, u32* out_palette_offset) +{ + const u32 elem_size = GetTexelBufferElementSize(format); + const u32 palette_elem_size = GetTexelBufferElementSize(palette_format); + const u32 reserve_size = data_size + palette_size + palette_elem_size; + if (reserve_size > m_texel_buffer->GetSize()) + return false; + + const auto dst = m_texel_buffer->Map(reserve_size, elem_size); + const u32 palette_byte_offset = Common::AlignUp(data_size, palette_elem_size); + std::memcpy(dst.first, data, data_size); + std::memcpy(dst.first + palette_byte_offset, palette_data, palette_size); + ADDSTAT(g_stats.this_frame.bytes_uniform_streamed, palette_byte_offset + palette_size); + *out_offset = dst.second / elem_size; + *out_palette_offset = (dst.second + palette_byte_offset) / palette_elem_size; + m_texel_buffer->Unmap(palette_byte_offset + palette_size); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_BUFFER, m_texel_buffer_views[static_cast<u32>(format)]); + Renderer::GetInstance()->InvalidateTextureBinding(0); + + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_BUFFER, m_texel_buffer_views[static_cast<u32>(palette_format)]); + Renderer::GetInstance()->InvalidateTextureBinding(1); + + return true; +} + +GLuint VertexManager::GetVertexBufferHandle() const +{ + return m_vertex_buffer->m_buffer; +} + +GLuint VertexManager::GetIndexBufferHandle() const +{ + return m_index_buffer->m_buffer; +} + +void VertexManager::ResetBuffer(u32 vertex_stride) +{ + CheckBufferBinding(); + + auto buffer = m_vertex_buffer->Map(MAXVBUFFERSIZE, vertex_stride); + m_cur_buffer_pointer = m_base_buffer_pointer = buffer.first; + m_end_buffer_pointer = buffer.first + MAXVBUFFERSIZE; + + buffer = m_index_buffer->Map(MAXIBUFFERSIZE * sizeof(u16)); + m_index_generator.Start(reinterpret_cast<u16*>(buffer.first)); +} + +void VertexManager::CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_indices, + u32* out_base_vertex, u32* out_base_index) +{ + u32 vertex_data_size = num_vertices * vertex_stride; + u32 index_data_size = num_indices * sizeof(u16); + + *out_base_vertex = vertex_stride > 0 ? (m_vertex_buffer->GetCurrentOffset() / vertex_stride) : 0; + *out_base_index = m_index_buffer->GetCurrentOffset() / sizeof(u16); + + CheckBufferBinding(); + m_vertex_buffer->Unmap(vertex_data_size); + m_index_buffer->Unmap(index_data_size); + + ADDSTAT(g_stats.this_frame.bytes_vertex_streamed, vertex_data_size); + ADDSTAT(g_stats.this_frame.bytes_index_streamed, index_data_size); +} + +void VertexManager::UploadUniforms() +{ + ProgramShaderCache::UploadConstants(); +} +} // namespace OGL |
