From ac60b1204584599f3ef9cd2d4495cd774e7120cb Mon Sep 17 00:00:00 2001 From: vladislavbelov Date: Wed, 27 Apr 2022 20:04:56 +0000 Subject: [PATCH] Replaces occurrences of "VBO" in comments by "backend buffer". Refs cff79b421a This was SVN commit r26835. --- source/renderer/OverlayRenderer.cpp | 19 ++++++++--------- source/renderer/OverlayRenderer.h | 2 +- source/renderer/TexturedLineRData.cpp | 6 ++++-- source/renderer/VertexArray.cpp | 6 +++--- source/renderer/VertexBuffer.cpp | 16 +++++++-------- source/renderer/VertexBuffer.h | 27 +++++++++++++------------ source/renderer/VertexBufferManager.cpp | 3 +-- 7 files changed, 41 insertions(+), 38 deletions(-) diff --git a/source/renderer/OverlayRenderer.cpp b/source/renderer/OverlayRenderer.cpp index 439324b9d0..201f2323d2 100644 --- a/source/renderer/OverlayRenderer.cpp +++ b/source/renderer/OverlayRenderer.cpp @@ -128,11 +128,11 @@ struct OverlayRendererInternals VertexArray::Attribute quadAttributeUV; VertexIndexArray quadIndices; - /// Maximum amount of quad overlays we support for rendering. This limit is set to be able to - /// render all quads from a single dedicated VB without having to reallocate it, which is much - /// faster in the typical case of rendering only a handful of quads. When modifying this value, - /// you must take care for the new amount of quads to fit in a single VBO (which is not likely - /// to be a problem). + // Maximum amount of quad overlays we support for rendering. This limit is set to be able to + // render all quads from a single dedicated VB without having to reallocate it, which is much + // faster in the typical case of rendering only a handful of quads. When modifying this value, + // you must take care for the new amount of quads to fit in a single backend buffer (which is + // not likely to be a problem). static const size_t MAX_QUAD_OVERLAYS = 1024; // Sets of commonly-(re)used shader defines. @@ -145,9 +145,10 @@ struct OverlayRendererInternals std::vector sphereIndexes; void GenerateSphere(); - /// Performs one-time setup. Called from CRenderer::Open, after graphics capabilities have - /// been detected. Note that no VBOs must be created before this is called, since the shader - /// path and graphics capabilities are not guaranteed to be stable before this point. + // Performs one-time setup. Called from CRenderer::Open, after graphics capabilities have + // been detected. Note that no backend buffer must be created before this is called, since + // the shader path and graphics capabilities are not guaranteed to be stable before this + // point. void Initialize(); }; @@ -178,7 +179,7 @@ OverlayRendererInternals::OverlayRendererInternals() void OverlayRendererInternals::Initialize() { // Perform any initialization after graphics capabilities have been detected. Notably, - // only at this point can we safely allocate VBOs (in contrast to e.g. in the constructor), + // only at this point can we safely allocate backend buffer (in contrast to e.g. in the constructor), // because their creation depends on the shader path, which is not reliably set before this point. quadVertices.SetNumberOfVertices(MAX_QUAD_OVERLAYS * 4); diff --git a/source/renderer/OverlayRenderer.h b/source/renderer/OverlayRenderer.h index 4c4f68dc8e..60a15f92cf 100644 --- a/source/renderer/OverlayRenderer.h +++ b/source/renderer/OverlayRenderer.h @@ -44,7 +44,7 @@ public: /** * Performs one-time initialization. Called by CRenderer::Open after graphics - * capabilities and the shader path have been determined (notably VBO support). + * capabilities and the shader path have been determined. */ void Initialize(); diff --git a/source/renderer/TexturedLineRData.cpp b/source/renderer/TexturedLineRData.cpp index b3912dc0e9..257733e143 100644 --- a/source/renderer/TexturedLineRData.cpp +++ b/source/renderer/TexturedLineRData.cpp @@ -320,9 +320,11 @@ void CTexturedLineRData::Update(const SOverlayTexturedLine& line) m_VB = g_VBMan.AllocateChunk( sizeof(SVertex), vertices.size(), Renderer::Backend::GL::CBuffer::Type::VERTEX, false); - if (m_VB) // allocation might fail (e.g. due to too many vertices) + // Allocation might fail (e.g. due to too many vertices). + if (m_VB) { - m_VB->m_Owner->UpdateChunkVertices(m_VB.Get(), &vertices[0]); // copy data into VBO + // Copy data into backend buffer. + m_VB->m_Owner->UpdateChunkVertices(m_VB.Get(), &vertices[0]); for (size_t k = 0; k < indices.size(); ++k) indices[k] += static_cast(m_VB->m_Index); diff --git a/source/renderer/VertexArray.cpp b/source/renderer/VertexArray.cpp index f2f5bd8d99..97fc96c683 100644 --- a/source/renderer/VertexArray.cpp +++ b/source/renderer/VertexArray.cpp @@ -225,7 +225,7 @@ static size_t RoundStride(size_t stride) // Re-layout by assigning offsets on a first-come first-serve basis, // then round up to a reasonable stride. -// Backing store is also created here, VBOs are created on upload. +// Backing store is also created here, backend buffers are created on upload. void VertexArray::Layout() { Free(); @@ -262,7 +262,7 @@ void VertexArray::PrepareForRendering() } // (Re-)Upload the attributes. -// Create the VBO if necessary. +// Create the backend buffer if necessary. void VertexArray::Upload() { ENSURE(m_BackingStore); @@ -275,7 +275,7 @@ void VertexArray::Upload() if (!m_VB) { - LOGERROR("Failed to allocate VBO for vertex array"); + LOGERROR("Failed to allocate backend buffer for vertex array"); return; } diff --git a/source/renderer/VertexBuffer.cpp b/source/renderer/VertexBuffer.cpp index 481ba30d18..43a2eed553 100644 --- a/source/renderer/VertexBuffer.cpp +++ b/source/renderer/VertexBuffer.cpp @@ -211,11 +211,11 @@ void CVertexBuffer::UpdateChunkVertices(VBChunk* chunk, void* data) ENSURE(m_Buffer); if (UseStreaming(m_Buffer->IsDynamic())) { - // The VBO is now out of sync with the backing store + // The backend buffer is now out of sync with the backing store. chunk->m_Dirty = true; // Sanity check: Make sure the caller hasn't tried to reallocate - // their backing store + // their backing store. ENSURE(data == chunk->m_BackingStore); } else @@ -234,8 +234,8 @@ void CVertexBuffer::UploadIfNeeded( if (!m_HasNeededChunks) return; - // If any chunks are out of sync with the current VBO, and are - // needed for rendering this frame, we'll need to re-upload the VBO + // If any chunks are out of sync with the current backend buffer, and are + // needed for rendering this frame, we'll need to re-upload the backend buffer. bool needUpload = false; for (VBChunk* const& chunk : m_AllocList) { @@ -258,16 +258,16 @@ void CVertexBuffer::UploadIfNeeded( #endif // Copy only the chunks we need. (This condition is helpful when - // the VBO contains data for every unit in the world, but only a - // handful are visible on screen and we don't need to bother copying - // the rest.) + // the backend buffer contains data for every unit in the world, + // but only a handful are visible on screen and we don't need to + // bother copying the rest.) for (VBChunk* const& chunk : m_AllocList) if (chunk->m_Needed) std::memcpy(mappedData + chunk->m_Index * m_VertexSize, chunk->m_BackingStore, chunk->m_Count * m_VertexSize); }); // Anything we just uploaded is clean; anything else is dirty - // since the rest of the VBO content is now undefined + // since the rest of the backend buffer content is now undefined for (VBChunk* const& chunk : m_AllocList) { if (chunk->m_Needed) diff --git a/source/renderer/VertexBuffer.h b/source/renderer/VertexBuffer.h index bc6a9fd6b4..46fc09a64b 100644 --- a/source/renderer/VertexBuffer.h +++ b/source/renderer/VertexBuffer.h @@ -16,7 +16,7 @@ */ /* - * encapsulation of VBOs with batching and sharing + * Encapsulation of backend buffers with batching and sharing. */ #ifndef INCLUDED_VERTEXBUFFER @@ -29,14 +29,14 @@ #include /** - * CVertexBuffer: encapsulation of ARB_vertex_buffer_object, also supplying + * CVertexBuffer: encapsulation of backend buffers, also supplying * some additional functionality for sharing buffers between multiple objects. * * The class can be used in two modes, depending on the usage parameter: * * Static buffer: Call Allocate() with backingStore = nullptr. Then call * UpdateChunkVertices() with any pointer - the data will be immediately copied - * to the VBO. This should be used for vertex data that rarely changes. + * to the buffer. This should be used for vertex data that rarely changes. * * Dynamic buffer: Call Allocate() with backingStore pointing * at some memory that will remain valid for the lifetime of the CVertexBuffer. @@ -59,29 +59,30 @@ class CVertexBuffer public: - /// VBChunk: describes a portion of this vertex buffer + // VBChunk: describes a portion of this vertex buffer struct VBChunk { - /// Owning (parent) vertex buffer + // Owning (parent) vertex buffer CVertexBuffer* m_Owner; - /// Start index of this chunk in owner + // Start index of this chunk in owner size_t m_Index; - /// Number of vertices used by chunk + // Number of vertices used by chunk size_t m_Count; - /// If UseStreaming() is true, points at the data for this chunk + // If UseStreaming() is true, points at the data for this chunk void* m_BackingStore; - /// If true, the VBO is not consistent with the chunk's backing store - /// (and will need to be re-uploaded before rendering with this chunk) + // If true, the backend buffer is not consistent with the chunk's + // backing store (and will need to be re-uploaded before rendering with + // this chunk). bool m_Dirty; - /// If true, we have been told this chunk is going to be used for - /// rendering in the next uploading phase and will need to be uploaded + // If true, we have been told this chunk is going to be used for + // rendering in the next uploading phase and will need to be uploaded bool m_Needed; private: // Only CVertexBuffer can construct/delete these - // (Other people should use g_VBMan.Allocate, g_VBMan.Release) + // (Other people should use g_VBMan.AllocateChunk) friend class CVertexBuffer; VBChunk() {} ~VBChunk() {} diff --git a/source/renderer/VertexBufferManager.cpp b/source/renderer/VertexBufferManager.cpp index d6025e766e..c883a50674 100644 --- a/source/renderer/VertexBufferManager.cpp +++ b/source/renderer/VertexBufferManager.cpp @@ -21,7 +21,6 @@ #include "lib/ogl.h" #include "ps/CLogger.h" -#include "ps/CStr.h" #define DUMP_VB_STATS 0 // for debugging @@ -174,7 +173,7 @@ CVertexBufferManager::Handle CVertexBufferManager::AllocateChunk( if (!result) { - LOGERROR("Failed to create VBOs (%zu*%zu)", vertexSize, numberOfVertices); + LOGERROR("Failed to create backend buffer (%zu*%zu)", vertexSize, numberOfVertices); return Handle(); }