1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
|
/* Copyright (C) 2016 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* 0 A.D. is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* encapsulation of VBOs with sharing
*/
#include "precompiled.h"
#include "ps/Errors.h"
#include "lib/ogl.h"
#include "lib/sysdep/cpu.h"
#include "Renderer.h"
#include "VertexBuffer.h"
#include "VertexBufferManager.h"
#include "ps/CLogger.h"
// Absolute maximum (bytewise) size of each GL vertex buffer object.
// Make it large enough for the maximum feasible mesh size (64K vertexes,
// 64 bytes per vertex in InstancingModelRenderer).
// TODO: measure what influence this has on performance
#define MAX_VB_SIZE_BYTES (4*1024*1024)
CVertexBuffer::CVertexBuffer(size_t vertexSize, GLenum usage, GLenum target)
: m_VertexSize(vertexSize), m_Handle(0), m_SysMem(0), m_Usage(usage), m_Target(target)
{
size_t size = MAX_VB_SIZE_BYTES;
if (target == GL_ARRAY_BUFFER) // vertex data buffer
{
// We want to store 16-bit indices to any vertex in a buffer, so the
// buffer must never be bigger than vertexSize*64K bytes since we can
// address at most 64K of them with 16-bit indices
size = std::min(size, vertexSize*65536);
}
// store max/free vertex counts
m_MaxVertices = m_FreeVertices = size / vertexSize;
// allocate raw buffer
if (g_Renderer.m_Caps.m_VBO)
{
pglGenBuffersARB(1, &m_Handle);
pglBindBufferARB(m_Target, m_Handle);
pglBufferDataARB(m_Target, m_MaxVertices * m_VertexSize, 0, m_Usage);
pglBindBufferARB(m_Target, 0);
}
else
{
m_SysMem = new u8[m_MaxVertices * m_VertexSize];
}
// create sole free chunk
VBChunk* chunk = new VBChunk;
chunk->m_Owner = this;
chunk->m_Count = m_FreeVertices;
chunk->m_Index = 0;
m_FreeList.push_front(chunk);
}
CVertexBuffer::~CVertexBuffer()
{
// Must have released all chunks before destroying the buffer
ENSURE(m_AllocList.empty());
if (m_Handle)
pglDeleteBuffersARB(1, &m_Handle);
delete[] m_SysMem;
typedef std::list<VBChunk*>::iterator Iter;
for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
delete *iter;
}
bool CVertexBuffer::CompatibleVertexType(size_t vertexSize, GLenum usage, GLenum target)
{
if (usage != m_Usage || target != m_Target || vertexSize != m_VertexSize)
return false;
return true;
}
///////////////////////////////////////////////////////////////////////////////
// Allocate: try to allocate a buffer of given number of vertices (each of
// given size), with the given type, and using the given texture - return null
// if no free chunks available
CVertexBuffer::VBChunk* CVertexBuffer::Allocate(size_t vertexSize, size_t numVertices, GLenum usage, GLenum target, void* backingStore)
{
// check this is the right kind of buffer
if (!CompatibleVertexType(vertexSize, usage, target))
return 0;
if (UseStreaming(usage))
ENSURE(backingStore != NULL);
// quick check there's enough vertices spare to allocate
if (numVertices > m_FreeVertices)
return 0;
// trawl free list looking for first free chunk with enough space
VBChunk* chunk = 0;
typedef std::list<VBChunk*>::iterator Iter;
for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter) {
if (numVertices <= (*iter)->m_Count) {
chunk = *iter;
// remove this chunk from the free list
m_FreeList.erase(iter);
m_FreeVertices -= chunk->m_Count;
// no need to search further ..
break;
}
}
if (!chunk) {
// no big enough spare chunk available
return 0;
}
chunk->m_BackingStore = backingStore;
chunk->m_Dirty = false;
chunk->m_Needed = false;
// split chunk into two; - allocate a new chunk using all unused vertices in the
// found chunk, and add it to the free list
if (chunk->m_Count > numVertices)
{
VBChunk* newchunk = new VBChunk;
newchunk->m_Owner = this;
newchunk->m_Count = chunk->m_Count - numVertices;
newchunk->m_Index = chunk->m_Index + numVertices;
m_FreeList.push_front(newchunk);
m_FreeVertices += newchunk->m_Count;
// resize given chunk
chunk->m_Count = numVertices;
}
// return found chunk
m_AllocList.push_back(chunk);
return chunk;
}
///////////////////////////////////////////////////////////////////////////////
// Release: return given chunk to this buffer
void CVertexBuffer::Release(VBChunk* chunk)
{
// Update total free count before potentially modifying this chunk's count
m_FreeVertices += chunk->m_Count;
m_AllocList.remove(chunk);
typedef std::list<VBChunk*>::iterator Iter;
// Coalesce with any free-list items that are adjacent to this chunk;
// merge the found chunk with the new one, and remove the old one
// from the list, and repeat until no more are found
bool coalesced;
do
{
coalesced = false;
for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
{
if ((*iter)->m_Index == chunk->m_Index + chunk->m_Count
|| (*iter)->m_Index + (*iter)->m_Count == chunk->m_Index)
{
chunk->m_Index = std::min(chunk->m_Index, (*iter)->m_Index);
chunk->m_Count += (*iter)->m_Count;
delete *iter;
m_FreeList.erase(iter);
coalesced = true;
break;
}
}
}
while (coalesced);
m_FreeList.push_front(chunk);
}
///////////////////////////////////////////////////////////////////////////////
// UpdateChunkVertices: update vertex data for given chunk
void CVertexBuffer::UpdateChunkVertices(VBChunk* chunk, void* data)
{
if (g_Renderer.m_Caps.m_VBO)
{
ENSURE(m_Handle);
if (UseStreaming(m_Usage))
{
// The VBO 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
ENSURE(data == chunk->m_BackingStore);
}
else
{
pglBindBufferARB(m_Target, m_Handle);
pglBufferSubDataARB(m_Target, chunk->m_Index * m_VertexSize, chunk->m_Count * m_VertexSize, data);
pglBindBufferARB(m_Target, 0);
}
}
else
{
ENSURE(m_SysMem);
memcpy(m_SysMem + chunk->m_Index * m_VertexSize, data, chunk->m_Count * m_VertexSize);
}
}
///////////////////////////////////////////////////////////////////////////////
// Bind: bind to this buffer; return pointer to address required as parameter
// to glVertexPointer ( + etc) calls
u8* CVertexBuffer::Bind()
{
if (!g_Renderer.m_Caps.m_VBO)
return m_SysMem;
pglBindBufferARB(m_Target, m_Handle);
if (UseStreaming(m_Usage))
{
// 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
bool needUpload = false;
for (VBChunk* const& chunk : m_AllocList)
{
if (chunk->m_Dirty && chunk->m_Needed)
{
needUpload = true;
break;
}
}
if (needUpload)
{
// Tell the driver that it can reallocate the whole VBO
pglBufferDataARB(m_Target, m_MaxVertices * m_VertexSize, NULL, m_Usage);
// (In theory, glMapBufferRange with GL_MAP_INVALIDATE_BUFFER_BIT could be used
// here instead of glBufferData(..., NULL, ...) plus glMapBuffer(), but with
// current Intel Windows GPU drivers (as of 2015-01) it's much faster if you do
// the explicit glBufferData.)
while (true)
{
void* p = pglMapBufferARB(m_Target, GL_WRITE_ONLY);
if (p == NULL)
{
// This shouldn't happen unless we run out of virtual address space
LOGERROR("glMapBuffer failed");
break;
}
#ifndef NDEBUG
// To help detect bugs where PrepareForRendering() was not called,
// force all not-needed data to 0, so things won't get rendered
// with undefined (but possibly still correct-looking) data.
memset(p, 0, m_MaxVertices * m_VertexSize);
#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.)
for (VBChunk* const& chunk : m_AllocList)
if (chunk->m_Needed)
memcpy((u8 *)p + chunk->m_Index * m_VertexSize, chunk->m_BackingStore, chunk->m_Count * m_VertexSize);
if (pglUnmapBufferARB(m_Target) == GL_TRUE)
break;
// Unmap might fail on e.g. resolution switches, so just try again
// and hope it will eventually succeed
debug_printf("glUnmapBuffer failed, trying again...\n");
}
// Anything we just uploaded is clean; anything else is dirty
// since the rest of the VBO content is now undefined
for (VBChunk* const& chunk : m_AllocList)
{
if (chunk->m_Needed)
chunk->m_Dirty = false;
else
chunk->m_Dirty = true;
}
}
// Reset the flags for the next phase
for (VBChunk* const& chunk : m_AllocList)
chunk->m_Needed = false;
}
return (u8*)0;
}
u8* CVertexBuffer::GetBindAddress()
{
if (g_Renderer.m_Caps.m_VBO)
return (u8*)0;
else
return m_SysMem;
}
void CVertexBuffer::Unbind()
{
if (g_Renderer.m_Caps.m_VBO)
{
pglBindBufferARB(GL_ARRAY_BUFFER, 0);
pglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
}
}
size_t CVertexBuffer::GetBytesReserved() const
{
return MAX_VB_SIZE_BYTES;
}
size_t CVertexBuffer::GetBytesAllocated() const
{
return (m_MaxVertices - m_FreeVertices) * m_VertexSize;
}
void CVertexBuffer::DumpStatus()
{
debug_printf("freeverts = %d\n", (int)m_FreeVertices);
size_t maxSize = 0;
typedef std::list<VBChunk*>::iterator Iter;
for (Iter iter = m_FreeList.begin(); iter != m_FreeList.end(); ++iter)
{
debug_printf("free chunk %p: size=%d\n", (void *)*iter, (int)((*iter)->m_Count));
maxSize = std::max((*iter)->m_Count, maxSize);
}
debug_printf("max size = %d\n", (int)maxSize);
}
bool CVertexBuffer::UseStreaming(GLenum usage)
{
return (usage == GL_DYNAMIC_DRAW || usage == GL_STREAM_DRAW);
}
|