source-engine/togl/linuxwin/cglmbuffer.cpp

1216 lines
35 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
// TOGL CODE LICENSE
//
// Copyright 2011-2014 Valve Corporation
// All Rights Reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// cglmbuffer.cpp
//
//===============================================================================
#include "togl/rendermechanism.h"
// memdbgon -must- be the last include file in a .cpp file.
#include "tier0/memdbgon.h"
// 7LS TODO : took out cmdline here
bool g_bUsePseudoBufs = false; //( Plat_GetCommandLineA() ) ? ( strstr( Plat_GetCommandLineA(), "-gl_enable_pseudobufs" ) != NULL ) : false;
#ifdef OSX
// Significant perf degradation on some OSX parts if static buffers not disabled
bool g_bDisableStaticBuffer = true;
#else
bool g_bDisableStaticBuffer = false; //( Plat_GetCommandLineA() ) ? ( strstr( Plat_GetCommandLineA(), "-gl_disable_static_buffer" ) != NULL ) : false;
#endif
// http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
// http://www.opengl.org/registry/specs/ARB/pixel_buffer_object.txt
// gl_bufmode: zero means we mark all vertex/index buffers static
// non zero means buffers are initially marked static..
// ->but can shift to dynamic upon first 'discard' (orphaning)
// #define REPORT_LOCK_TIME 0
ConVar gl_bufmode( "gl_bufmode", "1" );
char ALIGN16 CGLMBuffer::m_StaticBuffers[ GL_MAX_STATIC_BUFFERS ][ GL_STATIC_BUFFER_SIZE ] ALIGN16_POST;
bool CGLMBuffer::m_bStaticBufferUsed[ GL_MAX_STATIC_BUFFERS ];
extern bool g_bNullD3DDevice;
//===========================================================================//
static uint gMaxPersistentOffset[kGLMNumBufferTypes] =
{
0,
0,
0,
0
};
CON_COMMAND( gl_persistent_buffer_max_offset, "" )
{
ConMsg( "OpenGL Persistent buffer max offset :\n" );
ConMsg( " Vertex buffer : %d bytes (%f MB) \n", gMaxPersistentOffset[kGLMVertexBuffer], gMaxPersistentOffset[kGLMVertexBuffer] / (1024.0f*1024.0f) );
ConMsg( " Index buffer : %d bytes (%f MB) \n", gMaxPersistentOffset[kGLMIndexBuffer], gMaxPersistentOffset[kGLMIndexBuffer] / (1024.0f*1024.0f) );
ConMsg( " Uniform buffer : %d bytes (%f MB) \n", gMaxPersistentOffset[kGLMUniformBuffer], gMaxPersistentOffset[kGLMUniformBuffer] / (1024.0f*1024.0f) );
ConMsg( " Pixel buffer : %d bytes (%f MB) \n", gMaxPersistentOffset[kGLMPixelBuffer], gMaxPersistentOffset[kGLMPixelBuffer] / (1024.0f*1024.0f) );
}
CPersistentBuffer::CPersistentBuffer()
:
m_nSize( 0 )
, m_nHandle( 0 )
, m_pImmutablePersistentBuf( NULL )
, m_nOffset( 0 )
#ifdef HAVE_GL_ARB_SYNC
, m_nSyncObj( 0 )
#endif
{}
CPersistentBuffer::~CPersistentBuffer()
{
Deinit();
}
void CPersistentBuffer::Init( EGLMBufferType type,uint nSize )
{
Assert( gGL->m_bHave_GL_ARB_buffer_storage );
Assert( gGL->m_bHave_GL_ARB_map_buffer_range );
m_nSize = nSize;
m_nOffset = 0;
m_type = type;
switch ( type )
{
case kGLMVertexBuffer: m_buffGLTarget = GL_ARRAY_BUFFER_ARB; break;
case kGLMIndexBuffer: m_buffGLTarget = GL_ELEMENT_ARRAY_BUFFER_ARB; break;
default: Assert( nSize == 0 );
}
if ( m_nSize > 0 )
{
gGL->glGenBuffersARB( 1, &m_nHandle );
gGL->glBindBufferARB( m_buffGLTarget, m_nHandle );
// Create persistent immutable buffer that we will permanently map. This buffer can be written from any thread (not just
// the renderthread)
gGL->glBufferStorage( m_buffGLTarget, m_nSize, (const GLvoid *)NULL, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT ); // V_GL_REQ: GL_ARB_buffer_storage, GL_ARB_map_buffer_range, GL_VERSION_4_4
// Map the buffer for all of eternity. Pointer can be used from multiple threads.
m_pImmutablePersistentBuf = gGL->glMapBufferRange( m_buffGLTarget, 0, m_nSize, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT ); // V_GL_REQ: GL_ARB_map_buffer_range, GL_ARB_buffer_storage, GL_VERSION_4_4
Assert( m_pImmutablePersistentBuf != NULL );
}
}
void CPersistentBuffer::Deinit()
{
if ( !m_pImmutablePersistentBuf )
{
return;
}
BlockUntilNotBusy();
gGL->glBindBufferARB( m_buffGLTarget, m_nHandle );
gGL->glUnmapBuffer( m_buffGLTarget );
gGL->glBindBufferARB( m_buffGLTarget, 0 );
gGL->glDeleteBuffersARB( 1, &m_nHandle );
m_nSize = 0;
m_nHandle = 0;
m_nOffset = 0;
m_pImmutablePersistentBuf = NULL;
}
void CPersistentBuffer::InsertFence()
{
#ifdef HAVE_GL_ARB_SYNC
if (m_nSyncObj)
{
gGL->glDeleteSync( m_nSyncObj );
}
m_nSyncObj = gGL->glFenceSync( GL_SYNC_GPU_COMMANDS_COMPLETE, 0 );
#endif
}
void CPersistentBuffer::BlockUntilNotBusy()
{
#ifdef HAVE_GL_ARB_SYNC
if (m_nSyncObj)
{
gGL->glClientWaitSync( m_nSyncObj, GL_SYNC_FLUSH_COMMANDS_BIT, 3000000000000ULL );
gGL->glDeleteSync( m_nSyncObj );
m_nSyncObj = 0;
}
#endif
m_nOffset = 0;
}
void CPersistentBuffer::Append( uint nSize )
{
m_nOffset += nSize;
Assert( m_nOffset <= m_nSize );
gMaxPersistentOffset[m_type] = Max( m_nOffset, gMaxPersistentOffset[m_type] );
}
//===========================================================================//
#if GL_ENABLE_INDEX_VERIFICATION
CGLMBufferSpanManager::CGLMBufferSpanManager() :
m_pCtx( NULL ),
m_nBufType( kGLMVertexBuffer ),
m_nBufSize( 0 ),
m_bDynamic( false ),
m_nSpanEndMax( -1 ),
m_nNumAllocatedBufs( 0 ),
m_nTotalBytesAllocated( 0 )
{
}
CGLMBufferSpanManager::~CGLMBufferSpanManager()
{
Deinit();
}
void CGLMBufferSpanManager::Init( GLMContext *pContext, EGLMBufferType nBufType, uint nInitialCapacity, uint nBufSize, bool bDynamic )
{
Assert( ( nBufType == kGLMIndexBuffer ) || ( nBufType == kGLMVertexBuffer ) );
m_pCtx = pContext;
m_nBufType = nBufType;
m_nBufSize = nBufSize;
m_bDynamic = bDynamic;
m_ActiveSpans.EnsureCapacity( nInitialCapacity );
m_DeletedSpans.EnsureCapacity( nInitialCapacity );
m_nSpanEndMax = -1;
m_nNumAllocatedBufs = 0;
m_nTotalBytesAllocated = 0;
}
bool CGLMBufferSpanManager::AllocDynamicBuf( uint nSize, GLDynamicBuf_t &buf )
{
buf.m_nGLType = GetGLBufType();
buf.m_nActualBufSize = nSize;
buf.m_nHandle = 0;
buf.m_nSize = nSize;
m_nNumAllocatedBufs++;
m_nTotalBytesAllocated += buf.m_nActualBufSize;
return true;
}
void CGLMBufferSpanManager::ReleaseDynamicBuf( GLDynamicBuf_t &buf )
{
Assert( m_nNumAllocatedBufs > 0 );
m_nNumAllocatedBufs--;
Assert( m_nTotalBytesAllocated >= (int)buf.m_nActualBufSize );
m_nTotalBytesAllocated -= buf.m_nActualBufSize;
}
void CGLMBufferSpanManager::Deinit()
{
if ( !m_pCtx )
return;
for ( int i = 0; i < m_ActiveSpans.Count(); i++ )
{
if ( m_ActiveSpans[i].m_bOriginalAlloc )
ReleaseDynamicBuf( m_ActiveSpans[i].m_buf );
}
m_ActiveSpans.SetCountNonDestructively( 0 );
for ( int i = 0; i < m_DeletedSpans.Count(); i++ )
ReleaseDynamicBuf( m_DeletedSpans[i].m_buf );
m_DeletedSpans.SetCountNonDestructively( 0 );
m_pCtx->BindGLBufferToCtx( GetGLBufType(), NULL, true );
m_nSpanEndMax = -1;
m_pCtx = NULL;
Assert( !m_nNumAllocatedBufs );
Assert( !m_nTotalBytesAllocated );
}
void CGLMBufferSpanManager::DiscardAllSpans()
{
for ( int i = 0; i < m_ActiveSpans.Count(); i++ )
{
if ( m_ActiveSpans[i].m_bOriginalAlloc )
ReleaseDynamicBuf( m_ActiveSpans[i].m_buf );
}
m_ActiveSpans.SetCountNonDestructively( 0 );
for ( int i = 0; i < m_DeletedSpans.Count(); i++ )
ReleaseDynamicBuf( m_DeletedSpans[i].m_buf );
m_DeletedSpans.SetCountNonDestructively( 0 );
m_nSpanEndMax = -1;
Assert( !m_nNumAllocatedBufs );
Assert( !m_nTotalBytesAllocated );
}
// TODO: Add logic to detect incorrect usage of bNoOverwrite.
CGLMBufferSpanManager::ActiveSpan_t *CGLMBufferSpanManager::AddSpan( uint nOffset, uint nMaxSize, uint nActualSize, bool bDiscard, bool bNoOverwrite )
{
(void)bDiscard;
(void)bNoOverwrite;
const uint nStart = nOffset;
const uint nSize = nActualSize;
const uint nEnd = nStart + nSize;
GLDynamicBuf_t newDynamicBuf;
if ( !AllocDynamicBuf( nSize, newDynamicBuf ) )
{
DXABSTRACT_BREAK_ON_ERROR();
return NULL;
}
if ( (int)nStart < m_nSpanEndMax )
{
// Lock region potentially overlaps another previously locked region (since the last discard) - this is a very rarely (if ever) taken path in Source1 games.
int i = 0;
while ( i < m_ActiveSpans.Count() )
{
ActiveSpan_t &existingSpan = m_ActiveSpans[i];
if ( ( nEnd <= existingSpan.m_nStart ) || ( nStart >= existingSpan.m_nEnd ) )
{
i++;
continue;
}
Warning( "GL performance warning: AddSpan() at offset %u max size %u actual size %u, on a %s %s buffer of total size %u, overwrites an existing active lock span at offset %u size %u!\n",
nOffset, nMaxSize, nActualSize,
m_bDynamic ? "dynamic" : "static", ( m_nBufType == kGLMVertexBuffer ) ? "vertex" : "index", m_nBufSize,
existingSpan.m_nStart, existingSpan.m_nEnd - existingSpan.m_nStart );
if ( ( nStart <= existingSpan.m_nStart ) && ( nEnd >= existingSpan.m_nEnd ) )
{
if ( existingSpan.m_bOriginalAlloc )
{
// New span totally covers existing span
// Can't immediately delete the span's buffer because it could be referred to by another (child) span.
m_DeletedSpans.AddToTail( existingSpan );
}
// Delete span
m_ActiveSpans[i] = m_ActiveSpans[ m_ActiveSpans.Count() - 1 ];
m_ActiveSpans.SetCountNonDestructively( m_ActiveSpans.Count() - 1 );
continue;
}
// New span does NOT fully cover the existing span (partial overlap)
if ( nStart < existingSpan.m_nStart )
{
// New span starts before existing span, but ends somewhere inside, so shrink it (start moves "right")
existingSpan.m_nStart = nEnd;
}
else if ( nEnd > existingSpan.m_nEnd )
{
// New span ends after existing span, but starts somewhere inside (end moves "left")
existingSpan.m_nEnd = nStart;
}
else //if ( ( nStart >= existingSpan.m_nStart ) && ( nEnd <= existingSpan.m_nEnd ) )
{
// New span lies inside of existing span
if ( nStart == existingSpan.m_nStart )
{
// New span begins inside the existing span (start moves "right")
existingSpan.m_nStart = nEnd;
}
else
{
if ( nEnd < existingSpan.m_nEnd )
{
// New span is completely inside existing span
m_ActiveSpans.AddToTail( ActiveSpan_t( nEnd, existingSpan.m_nEnd, existingSpan.m_buf, false ) );
}
existingSpan.m_nEnd = nStart;
}
}
Assert( existingSpan.m_nStart < existingSpan.m_nEnd );
i++;
}
}
newDynamicBuf.m_nLockOffset = nStart;
newDynamicBuf.m_nLockSize = nSize;
m_ActiveSpans.AddToTail( ActiveSpan_t( nStart, nEnd, newDynamicBuf, true ) );
m_nSpanEndMax = MAX( m_nSpanEndMax, (int)nEnd );
return &m_ActiveSpans.Tail();
}
bool CGLMBufferSpanManager::IsValid( uint nOffset, uint nSize ) const
{
const uint nEnd = nOffset + nSize;
int nTotalBytesRemaining = nSize;
for ( int i = m_ActiveSpans.Count() - 1; i >= 0; --i )
{
const ActiveSpan_t &span = m_ActiveSpans[i];
if ( span.m_nEnd <= nOffset )
continue;
if ( span.m_nStart >= nEnd )
continue;
uint nIntersectStart = MAX( span.m_nStart, nOffset );
uint nIntersectEnd = MIN( span.m_nEnd, nEnd );
Assert( nIntersectStart <= nIntersectEnd );
nTotalBytesRemaining -= ( nIntersectEnd - nIntersectStart );
Assert( nTotalBytesRemaining >= 0 );
if ( nTotalBytesRemaining <= 0 )
break;
}
return nTotalBytesRemaining == 0;
}
#endif // GL_ENABLE_INDEX_VERIFICATION
// glBufferSubData() with a max size limit, to work around NVidia's threaded driver limits (anything > than roughly 256KB triggers a sync with the server thread).
void glBufferSubDataMaxSize( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data, uint nMaxSizePerCall )
{
#if TOGL_SUPPORT_NULL_DEVICE
if ( g_bNullD3DDevice ) return;
#endif
uint nBytesLeft = size;
uint nOfs = 0;
while ( nBytesLeft )
{
uint nBytesToCopy = MIN( nMaxSizePerCall, nBytesLeft );
gGL->glBufferSubData( target, offset + nOfs, nBytesToCopy, static_cast<const unsigned char *>( data ) + nOfs );
nBytesLeft -= nBytesToCopy;
nOfs += nBytesToCopy;
}
}
CGLMBuffer::CGLMBuffer( GLMContext *pCtx, EGLMBufferType type, uint size, uint options )
{
m_pCtx = pCtx;
m_type = type;
m_bDynamic = ( options & GLMBufferOptionDynamic ) != 0;
switch ( m_type )
{
case kGLMVertexBuffer: m_buffGLTarget = GL_ARRAY_BUFFER_ARB; break;
case kGLMIndexBuffer: m_buffGLTarget = GL_ELEMENT_ARRAY_BUFFER_ARB; break;
case kGLMUniformBuffer: m_buffGLTarget = GL_UNIFORM_BUFFER_EXT; break;
case kGLMPixelBuffer: m_buffGLTarget = GL_PIXEL_UNPACK_BUFFER_ARB; break;
default: Assert(!"Unknown buffer type" ); DXABSTRACT_BREAK_ON_ERROR();
}
m_nSize = size;
m_nActualSize = size;
m_bMapped = false;
m_pLastMappedAddress = NULL;
m_pStaticBuffer = NULL;
m_nPinnedMemoryOfs = -1;
m_nPersistentBufferStartOffset = 0;
m_bUsingPersistentBuffer = false;
m_bEnableAsyncMap = false;
m_bEnableExplicitFlush = false;
m_dirtyMinOffset = m_dirtyMaxOffset = 0; // adjust/grow on lock, clear on unlock
m_pCtx->CheckCurrent();
m_nRevision = rand();
m_pPseudoBuf = NULL;
m_pActualPseudoBuf = NULL;
m_bPseudo = false;
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
m_bPseudo = true;
#endif
#if GL_ENABLE_INDEX_VERIFICATION
m_BufferSpanManager.Init( m_pCtx, m_type, 512, m_nSize, m_bDynamic );
if ( m_type == kGLMIndexBuffer )
m_bPseudo = true;
#endif
if ( g_bUsePseudoBufs && m_bDynamic )
{
m_bPseudo = true;
}
if ( m_bPseudo )
{
m_nHandle = 0;
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
m_nDirtyRangeStart = 0xFFFFFFFF;
m_nDirtyRangeEnd = 0;
m_nActualSize = ALIGN_VALUE( ( m_nSize + sizeof( uint32 ) ), 4096 );
m_pPseudoBuf = m_pActualPseudoBuf = (char *)VirtualAlloc( NULL, m_nActualSize, MEM_COMMIT, PAGE_READWRITE );
if ( !m_pPseudoBuf )
{
Error( "VirtualAlloc() failed!\n" );
}
for ( uint i = 0; i < m_nActualSize / sizeof( uint32 ); i++ )
{
reinterpret_cast< uint32 * >( m_pPseudoBuf )[i] = 0xDEADBEEF;
}
DWORD nOldProtect;
BOOL bResult = VirtualProtect( m_pActualPseudoBuf, m_nActualSize, PAGE_READONLY, &nOldProtect );
if ( !bResult )
{
Error( "VirtualProtect() failed!\n" );
}
#else
m_nActualSize = size + 15;
m_pActualPseudoBuf = (char*)malloc( m_nActualSize );
m_pPseudoBuf = (char*)(((intp)m_pActualPseudoBuf + 15) & ~15);
#endif
m_pCtx->BindBufferToCtx( m_type, NULL ); // exit with no buffer bound
}
else
{
gGL->glGenBuffersARB( 1, &m_nHandle );
m_pCtx->BindBufferToCtx( m_type, this ); // causes glBindBufferARB
// buffers start out static, but if they get orphaned and gl_bufmode is non zero,
// then they will get flipped to dynamic.
GLenum hint = GL_STATIC_DRAW_ARB;
switch (m_type)
{
case kGLMVertexBuffer: hint = m_bDynamic ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
case kGLMIndexBuffer: hint = m_bDynamic ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
case kGLMUniformBuffer: hint = GL_DYNAMIC_DRAW_ARB; break;
case kGLMPixelBuffer: hint = m_bDynamic ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
default: Assert(!"Unknown buffer type" ); DXABSTRACT_BREAK_ON_ERROR();
}
gGL->glBufferDataARB( m_buffGLTarget, m_nSize, (const GLvoid*)NULL, hint ); // may ultimately need more hints to set the usage correctly (esp for streaming)
SetModes( false, true, true );
m_pCtx->BindBufferToCtx( m_type, NULL ); // unbind me
}
}
CGLMBuffer::~CGLMBuffer( )
{
m_pCtx->CheckCurrent();
if ( m_bPseudo )
{
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
BOOL bResult = VirtualFree( m_pActualPseudoBuf, 0, MEM_RELEASE );
if ( !bResult )
{
Error( "VirtualFree() failed!\n" );
}
#else
free( m_pActualPseudoBuf );
#endif
m_pActualPseudoBuf = NULL;
m_pPseudoBuf = NULL;
}
else
{
gGL->glDeleteBuffersARB( 1, &m_nHandle );
}
m_pCtx = NULL;
m_nHandle = 0;
m_pLastMappedAddress = NULL;
#if GL_ENABLE_INDEX_VERIFICATION
m_BufferSpanManager.Deinit();
#endif
}
void CGLMBuffer::SetModes( bool bAsyncMap, bool bExplicitFlush, bool bForce )
{
// assumes buffer is bound. called by constructor and by Lock.
if ( m_bPseudo )
{
// ignore it...
}
else
{
if ( bForce || ( m_bEnableAsyncMap != bAsyncMap ) )
{
// note the sense of the parameter, it's TRUE if you *want* serialization, so for async you turn it to false.
if ( ( gGL->m_bHave_GL_APPLE_flush_buffer_range ) && ( !gGL->m_bHave_GL_ARB_map_buffer_range ) )
{
gGL->glBufferParameteriAPPLE( m_buffGLTarget, GL_BUFFER_SERIALIZED_MODIFY_APPLE, bAsyncMap == false );
}
m_bEnableAsyncMap = bAsyncMap;
}
if ( bForce || ( m_bEnableExplicitFlush != bExplicitFlush ) )
{
// Note that the GL_ARB_map_buffer_range path handles this in the glMapBufferRange() call in Lock().
// note the sense of the parameter, it's TRUE if you *want* auto-flush-on-unmap, so for explicit-flush, you turn it to false.
if ( ( gGL->m_bHave_GL_APPLE_flush_buffer_range ) && ( !gGL->m_bHave_GL_ARB_map_buffer_range ) )
{
gGL->glBufferParameteriAPPLE( m_buffGLTarget, GL_BUFFER_FLUSHING_UNMAP_APPLE, bExplicitFlush == false );
}
m_bEnableExplicitFlush = bExplicitFlush;
}
}
}
#if GL_ENABLE_INDEX_VERIFICATION
bool CGLMBuffer::IsSpanValid( uint nOffset, uint nSize ) const
{
return m_BufferSpanManager.IsValid( nOffset, nSize );
}
#endif
void CGLMBuffer::FlushRange( uint offset, uint size )
{
if ( m_pStaticBuffer )
{
}
else if ( m_bPseudo )
{
// nothing to do
}
else
{
#ifdef REPORT_LOCK_TIME
double flStart = Plat_FloatTime();
#endif
// assumes buffer is bound.
if ( gGL->m_bHave_GL_ARB_map_buffer_range )
{
gGL->glFlushMappedBufferRange( m_buffGLTarget, (GLintptr)( offset - m_dirtyMinOffset ), (GLsizeiptr)size );
}
else if ( gGL->m_bHave_GL_APPLE_flush_buffer_range )
{
gGL->glFlushMappedBufferRangeAPPLE( m_buffGLTarget, (GLintptr)offset, (GLsizeiptr)size );
}
#ifdef REPORT_LOCK_TIME
double flEnd = Plat_FloatTime();
if ( flEnd - flStart > 5.0 / 1000.0 )
{
int nDelta = ( int )( ( flEnd - flStart ) * 1000 );
if ( nDelta > 2 )
{
Msg( "**** " );
}
Msg( "glFlushMappedBufferRange Time %d: ( Name=%d BufSize=%d ) Target=%p Offset=%d FlushSize=%d\n", nDelta, m_nHandle, m_nSize, m_buffGLTarget, offset - m_dirtyMinOffset, size );
}
#endif
// If you don't have any extension support here, you'll flush the whole buffer on unmap. Performance loss, but it's still safe and correct.
}
}
void CGLMBuffer::Lock( GLMBuffLockParams *pParams, char **pAddressOut )
{
#if GL_TELEMETRY_GPU_ZONES
CScopedGLMPIXEvent glmPIXEvent( "CGLMBuffer::Lock" );
g_TelemetryGPUStats.m_nTotalBufferLocksAndUnlocks++;
#endif
char *resultPtr = NULL;
if ( m_bMapped )
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
m_pCtx->CheckCurrent();
Assert( pParams->m_nSize );
m_LockParams = *pParams;
if ( pParams->m_nOffset >= m_nSize )
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
if ( ( pParams->m_nOffset + pParams->m_nSize ) > m_nSize)
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
#if GL_ENABLE_INDEX_VERIFICATION
if ( pParams->m_bDiscard )
{
m_BufferSpanManager.DiscardAllSpans();
}
#endif
m_pStaticBuffer = NULL;
bool bUsingPersistentBuffer = false;
uint padding = 0;
if ( m_bDynamic && gGL->m_bHave_GL_ARB_buffer_storage )
{
// Compute padding to add to make sure the start offset is valid
CPersistentBuffer *pTempBuffer = m_pCtx->GetCurPersistentBuffer( m_type );
uint persistentBufferOffset = pTempBuffer->GetOffset();
if (pParams->m_nOffset > persistentBufferOffset)
{
// Make sure the start offset if valid (adding padding to the persistent buffer)
padding = pParams->m_nOffset - persistentBufferOffset;
}
}
if ( m_bPseudo )
{
if ( pParams->m_bDiscard )
{
m_nRevision++;
}
// async map modes are a no-op
// calc lock address
resultPtr = m_pPseudoBuf + pParams->m_nOffset;
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
BOOL bResult;
DWORD nOldProtect;
if ( pParams->m_bDiscard )
{
bResult = VirtualProtect( m_pActualPseudoBuf, m_nSize, PAGE_READWRITE, &nOldProtect );
if ( !bResult )
{
Error( "VirtualProtect() failed!\n" );
}
m_nDirtyRangeStart = 0xFFFFFFFF;
m_nDirtyRangeEnd = 0;
for ( uint i = 0; i < m_nSize / sizeof( uint32 ); i++ )
{
reinterpret_cast< uint32 * >( m_pPseudoBuf )[i] = 0xDEADBEEF;
}
bResult = VirtualProtect( m_pActualPseudoBuf, m_nSize, PAGE_READONLY, &nOldProtect );
if ( !bResult )
{
Error( "VirtualProtect() failed!\n" );
}
}
uint nProtectOfs = m_LockParams.m_nOffset & 4095;
uint nProtectEnd = ( m_LockParams.m_nOffset + m_LockParams.m_nSize + 4095 ) & ~4095;
uint nProtectSize = nProtectEnd - nProtectOfs;
bResult = VirtualProtect( m_pActualPseudoBuf + nProtectOfs, nProtectSize, PAGE_READWRITE, &nOldProtect );
if ( !bResult )
{
Error( "VirtualProtect() failed!\n" );
}
#endif
}
else if ( m_bDynamic && gGL->m_bHave_GL_ARB_buffer_storage && ( m_pCtx->GetCurPersistentBuffer( m_type )->GetBytesRemaining() >= ( pParams->m_nSize + padding ) ) )
{
CPersistentBuffer *pTempBuffer = m_pCtx->GetCurPersistentBuffer( m_type );
// Make sure the start offset if valid (adding padding to the persistent buffer)
pTempBuffer->Append( padding );
uint persistentBufferOffset = pTempBuffer->GetOffset();
uint startOffset = persistentBufferOffset - pParams->m_nOffset;
if ( pParams->m_bDiscard || ( startOffset != m_nPersistentBufferStartOffset ) )
{
m_nRevision++;
// Offset to be added to the vertex and index buffer when setting the vertex and index buffer (before drawing)
// Since we are using a immutable buffer storage, the persistent buffer is actually bigger than
// buffer size requested upon creation. We keep appending to the end of the persistent buffer
// and therefore need to keep track of the start of the actual buffer (in the persistent one)
m_nPersistentBufferStartOffset = startOffset;
//DevMsg( "Discard (%s): startOffset = %d\n", pParams->m_bDiscard ? "true" : "false", m_nPersistentBufferStartOffset );
}
resultPtr = static_cast<char*>(pTempBuffer->GetPtr()) + persistentBufferOffset;
bUsingPersistentBuffer = true;
//DevMsg( " --> buff=%x, startOffset=%d, paramsOffset=%d, persistOffset = %d\n", this, m_nPersistentBufferStartOffset, pParams->m_nOffset, persistentBufferOffset );
}
#ifndef OSX
else if ( m_bDynamic && gGL->m_bHave_GL_AMD_pinned_memory && ( m_pCtx->GetCurPinnedMemoryBuffer()->GetBytesRemaining() >= pParams->m_nSize ) )
{
if ( pParams->m_bDiscard )
{
m_nRevision++;
}
m_dirtyMinOffset = pParams->m_nOffset;
m_dirtyMaxOffset = pParams->m_nOffset + pParams->m_nSize;
CPinnedMemoryBuffer *pTempBuffer = m_pCtx->GetCurPinnedMemoryBuffer();
m_nPinnedMemoryOfs = pTempBuffer->GetOfs();
resultPtr = static_cast<char*>( pTempBuffer->GetPtr() ) + m_nPinnedMemoryOfs;
pTempBuffer->Append( pParams->m_nSize );
}
#endif // OSX
else if ( !g_bDisableStaticBuffer && ( pParams->m_bDiscard || pParams->m_bNoOverwrite ) && ( pParams->m_nSize <= GL_STATIC_BUFFER_SIZE ) )
{
#if TOGL_SUPPORT_NULL_DEVICE
if ( !g_bNullD3DDevice )
#endif
{
if ( pParams->m_bDiscard )
{
m_pCtx->BindBufferToCtx( m_type, this );
// observe gl_bufmode on any orphan event.
// if orphaned and bufmode is nonzero, flip it to dynamic.
GLenum hint = gl_bufmode.GetInt() ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB;
gGL->glBufferDataARB( m_buffGLTarget, m_nSize, (const GLvoid*)NULL, hint );
m_nRevision++; // revision grows on orphan event
}
}
m_dirtyMinOffset = pParams->m_nOffset;
m_dirtyMaxOffset = pParams->m_nOffset + pParams->m_nSize;
switch ( m_type )
{
case kGLMVertexBuffer:
{
m_pStaticBuffer = m_StaticBuffers[ 0 ];
break;
}
case kGLMIndexBuffer:
{
m_pStaticBuffer = m_StaticBuffers[ 1 ];
break;
}
default:
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
}
resultPtr = m_pStaticBuffer;
}
else
{
// bind (yes, even for pseudo - this binds name 0)
m_pCtx->BindBufferToCtx( m_type, this );
// perform discard if requested
if ( pParams->m_bDiscard )
{
// observe gl_bufmode on any orphan event.
// if orphaned and bufmode is nonzero, flip it to dynamic.
// We always want to call glBufferData( ..., NULL ) on discards, even though we're using the GL_MAP_INVALIDATE_BUFFER_BIT flag, because this flag is actually only a hint according to AMD.
GLenum hint = gl_bufmode.GetInt() ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB;
gGL->glBufferDataARB( m_buffGLTarget, m_nSize, (const GLvoid*)NULL, hint );
m_nRevision++; // revision grows on orphan event
}
// adjust async map option appropriately, leave explicit flush unchanged
SetModes( pParams->m_bNoOverwrite, m_bEnableExplicitFlush );
// map
char *mapPtr;
if ( gGL->m_bHave_GL_ARB_map_buffer_range )
{
// m_bEnableAsyncMap is actually pParams->m_bNoOverwrite
GLbitfield parms = GL_MAP_WRITE_BIT | ( m_bEnableAsyncMap ? GL_MAP_UNSYNCHRONIZED_BIT : 0 ) | ( pParams->m_bDiscard ? GL_MAP_INVALIDATE_BUFFER_BIT : 0 ) | ( m_bEnableExplicitFlush ? GL_MAP_FLUSH_EXPLICIT_BIT : 0 );
#ifdef REPORT_LOCK_TIME
double flStart = Plat_FloatTime();
#endif
mapPtr = (char*)gGL->glMapBufferRange( m_buffGLTarget, pParams->m_nOffset, pParams->m_nSize, parms);
#ifdef REPORT_LOCK_TIME
double flEnd = Plat_FloatTime();
if ( flEnd - flStart > 5.0 / 1000.0 )
{
int nDelta = ( int )( ( flEnd - flStart ) * 1000 );
if ( nDelta > 2 )
{
Msg( "**** " );
}
Msg( "glMapBufferRange Time=%d: ( Name=%d BufSize=%d ) Target=%p Offset=%d LockSize=%d ", nDelta, m_nHandle, m_nSize, m_buffGLTarget, pParams->m_nOffset, pParams->m_nSize );
if ( parms & GL_MAP_WRITE_BIT )
{
Msg( "GL_MAP_WRITE_BIT ");
}
if ( parms & GL_MAP_UNSYNCHRONIZED_BIT )
{
Msg( "GL_MAP_UNSYNCHRONIZED_BIT ");
}
if ( parms & GL_MAP_INVALIDATE_BUFFER_BIT )
{
Msg( "GL_MAP_INVALIDATE_BUFFER_BIT ");
}
if ( parms & GL_MAP_INVALIDATE_RANGE_BIT )
{
Msg( "GL_MAP_INVALIDATE_RANGE_BIT ");
}
if ( parms & GL_MAP_FLUSH_EXPLICIT_BIT )
{
Msg( "GL_MAP_FLUSH_EXPLICIT_BIT ");
}
Msg( "\n" );
}
#endif
}
else
{
mapPtr = (char*)gGL->glMapBufferARB( m_buffGLTarget, GL_WRITE_ONLY_ARB );
}
Assert( mapPtr );
// calculate offset location
resultPtr = mapPtr;
if ( !gGL->m_bHave_GL_ARB_map_buffer_range )
{
resultPtr += pParams->m_nOffset;
}
// set range
m_dirtyMinOffset = pParams->m_nOffset;
m_dirtyMaxOffset = pParams->m_nOffset + pParams->m_nSize;
}
if ( m_bUsingPersistentBuffer != bUsingPersistentBuffer )
{
// Up the revision number when switching from a persistent to a non persistent buffer (or vice versa)
// Ensure the right GL buffer is bound before drawing (and vertex attribs properly set)
m_nRevision++;
m_bUsingPersistentBuffer = bUsingPersistentBuffer;
}
m_bMapped = true;
m_pLastMappedAddress = (float*)resultPtr;
*pAddressOut = resultPtr;
}
void CGLMBuffer::Unlock( int nActualSize, const void *pActualData )
{
#if GL_TELEMETRY_GPU_ZONES
CScopedGLMPIXEvent glmPIXEvent( "CGLMBuffer::Unlock" );
g_TelemetryGPUStats.m_nTotalBufferLocksAndUnlocks++;
#endif
m_pCtx->CheckCurrent();
if ( !m_bMapped )
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
if ( nActualSize < 0 )
{
nActualSize = m_LockParams.m_nSize;
}
if ( nActualSize > (int)m_LockParams.m_nSize )
{
DXABSTRACT_BREAK_ON_ERROR();
return;
}
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
if ( m_bPseudo )
{
// Check guard DWORD to detect buffer overruns (but are still within the last 4KB page so they don't get caught via pagefaults)
if ( *reinterpret_cast< const uint32 * >( m_pPseudoBuf + m_nSize ) != 0xDEADBEEF )
{
// If this fires the client app has overwritten the guard DWORD beyond the end of the buffer.
DXABSTRACT_BREAK_ON_ERROR();
}
static const uint s_nInitialValues[4] = { 0xEF, 0xBE, 0xAD, 0xDE };
int nActualModifiedStart, nActualModifiedEnd;
for ( nActualModifiedStart = 0; nActualModifiedStart < (int)m_LockParams.m_nSize; ++nActualModifiedStart )
if ( reinterpret_cast< const uint8 * >( m_pLastMappedAddress )[nActualModifiedStart] != s_nInitialValues[ ( m_LockParams.m_nOffset + nActualModifiedStart ) & 3 ] )
break;
for ( nActualModifiedEnd = m_LockParams.m_nSize - 1; nActualModifiedEnd > nActualModifiedStart; --nActualModifiedEnd )
if ( reinterpret_cast< const uint8 * >( m_pLastMappedAddress )[nActualModifiedEnd] != s_nInitialValues[ ( m_LockParams.m_nOffset + nActualModifiedEnd ) & 3 ] )
break;
int nNumActualBytesModified = 0;
if ( nActualModifiedEnd >= nActualModifiedStart )
{
// The modified check is conservative (i.e. it should always err on the side of detecting <= actual bytes than where actually modified, never more).
// We primarily care about the case where the user lies about the actual # of modified bytes, which can lead to difficult to debug/inconsistent problems with some drivers.
// Round up/down the modified range, because the user's data may alias with the initial buffer values (0xDEADBEEF) so we may miss some bytes that where written.
if ( m_type == kGLMIndexBuffer )
{
nActualModifiedStart &= ~1;
nActualModifiedEnd = MIN( (int)m_LockParams.m_nSize, ( ( nActualModifiedEnd + 1 ) + 1 ) & ~1 ) - 1;
}
else
{
nActualModifiedStart &= ~3;
nActualModifiedEnd = MIN( (int)m_LockParams.m_nSize, ( ( nActualModifiedEnd + 1 ) + 3 ) & ~3 ) - 1;
}
nNumActualBytesModified = nActualModifiedEnd + 1;
if ( nActualSize < nNumActualBytesModified )
{
// The caller may be lying about the # of actually modified bytes in this lock.
// Has this lock region been previously locked? If so, it may have been previously overwritten before. Otherwise, the region had to be the 0xDEADBEEF fill DWORD at lock time.
if ( ( m_nDirtyRangeStart > m_nDirtyRangeEnd ) ||
( m_LockParams.m_nOffset > m_nDirtyRangeEnd ) || ( ( m_LockParams.m_nOffset + m_LockParams.m_nSize ) <= m_nDirtyRangeStart ) )
{
// If this fires the client has lied about the actual # of bytes they've modified in the buffer - this will cause unreliable rendering on AMD drivers (because AMD actually pays attention to the actual # of flushed bytes).
DXABSTRACT_BREAK_ON_ERROR();
}
}
m_nDirtyRangeStart = MIN( m_nDirtyRangeStart, m_LockParams.m_nOffset + nActualModifiedStart );
m_nDirtyRangeEnd = MAX( m_nDirtyRangeEnd, m_LockParams.m_nOffset + nActualModifiedEnd );
}
#if GL_ENABLE_INDEX_VERIFICATION
if ( nActualModifiedEnd >= nActualModifiedStart )
{
int n = nActualModifiedEnd + 1;
if ( n != nActualSize )
{
// The actual detected modified size is < than the reported size, which is common because the last few DWORD's of the vertex format may not actually be used/written (or read by the vertex shader). So just fudge it so the batch consumption checks work.
if ( ( (int)nActualSize - n ) <= 32 )
{
n = nActualSize;
}
}
m_BufferSpanManager.AddSpan( m_LockParams.m_nOffset + nActualModifiedStart, m_LockParams.m_nSize, n - nActualModifiedStart, m_LockParams.m_bDiscard, m_LockParams.m_bNoOverwrite );
}
#endif
}
#elif GL_ENABLE_INDEX_VERIFICATION
if ( nActualSize > 0 )
{
m_BufferSpanManager.AddSpan( m_LockParams.m_nOffset, m_LockParams.m_nSize, nActualSize, m_LockParams.m_bDiscard, m_LockParams.m_bNoOverwrite );
}
#endif
#if GL_BATCH_PERF_ANALYSIS
if ( m_type == kGLMIndexBuffer )
g_nTotalIBLockBytes += nActualSize;
else if ( m_type == kGLMVertexBuffer )
g_nTotalVBLockBytes += nActualSize;
#endif
#ifndef OSX
if ( m_nPinnedMemoryOfs >= 0 )
{
#if TOGL_SUPPORT_NULL_DEVICE
if ( !g_bNullD3DDevice )
{
#endif
if ( nActualSize )
{
m_pCtx->BindBufferToCtx( m_type, this );
gGL->glCopyBufferSubData(
GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD,
m_buffGLTarget,
m_nPinnedMemoryOfs,
m_dirtyMinOffset,
nActualSize );
}
#if TOGL_SUPPORT_NULL_DEVICE
}
#endif
m_nPinnedMemoryOfs = -1;
}
else
#endif // !OSX
if ( m_bUsingPersistentBuffer )
{
if ( nActualSize )
{
CPersistentBuffer *pTempBuffer = m_pCtx->GetCurPersistentBuffer( m_type );
pTempBuffer->Append( nActualSize );
//DevMsg( " <-- actualSize=%d, persistOffset = %d\n", nActualSize, pTempBuffer->GetOffset() );
}
}
else if ( m_pStaticBuffer )
{
#if TOGL_SUPPORT_NULL_DEVICE
if ( !g_bNullD3DDevice )
#endif
{
if ( nActualSize )
{
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "UnlockSubData" );
#ifdef REPORT_LOCK_TIME
double flStart = Plat_FloatTime();
#endif
m_pCtx->BindBufferToCtx( m_type, this );
Assert( nActualSize <= (int)( m_dirtyMaxOffset - m_dirtyMinOffset ) );
glBufferSubDataMaxSize( m_buffGLTarget, m_dirtyMinOffset, nActualSize, pActualData ? pActualData : m_pStaticBuffer );
#ifdef REPORT_LOCK_TIME
double flEnd = Plat_FloatTime();
if ( flEnd - flStart > 5.0 / 1000.0 )
{
int nDelta = ( int )( ( flEnd - flStart ) * 1000 );
if ( nDelta > 2 )
{
Msg( "**** " );
}
// Msg( "glBufferSubData Time=%d: ( Name=%d BufSize=%d ) Target=%p Offset=%d Size=%d\n", nDelta, m_nHandle, m_nSize, m_buffGLTarget, m_dirtyMinOffset, m_dirtyMaxOffset - m_dirtyMinOffset );
}
#endif
}
}
m_pStaticBuffer = NULL;
}
else if ( m_bPseudo )
{
if ( pActualData )
{
memcpy( m_pLastMappedAddress, pActualData, nActualSize );
}
#if GL_ENABLE_UNLOCK_BUFFER_OVERWRITE_DETECTION
uint nProtectOfs = m_LockParams.m_nOffset & 4095;
uint nProtectEnd = ( m_LockParams.m_nOffset + m_LockParams.m_nSize + 4095 ) & ~4095;
uint nProtectSize = nProtectEnd - nProtectOfs;
DWORD nOldProtect;
BOOL bResult = VirtualProtect( m_pActualPseudoBuf + nProtectOfs, nProtectSize, PAGE_READONLY, &nOldProtect );
if ( !bResult )
{
Error( "VirtualProtect() failed!\n" );
}
#endif
}
else
{
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "UnlockUnmap" );
if ( pActualData )
{
memcpy( m_pLastMappedAddress, pActualData, nActualSize );
}
m_pCtx->BindBufferToCtx( m_type, this );
Assert( nActualSize <= (int)( m_dirtyMaxOffset - m_dirtyMinOffset ) );
// time to do explicit flush (currently m_bEnableExplicitFlush is always true)
if ( m_bEnableExplicitFlush )
{
FlushRange( m_dirtyMinOffset, nActualSize );
}
// clear dirty range no matter what
m_dirtyMinOffset = m_dirtyMaxOffset = 0; // adjust/grow on lock, clear on unlock
#ifdef REPORT_LOCK_TIME
double flStart = Plat_FloatTime();
#endif
gGL->glUnmapBuffer( m_buffGLTarget );
#ifdef REPORT_LOCK_TIME
double flEnd = Plat_FloatTime();
if ( flEnd - flStart > 5.0 / 1000.0 )
{
int nDelta = ( int )( ( flEnd - flStart ) * 1000 );
if ( nDelta > 2 )
{
Msg( "**** " );
}
Msg( "glUnmapBuffer Time=%d: ( Name=%d BufSize=%d ) Target=%p\n", nDelta, m_nHandle, m_nSize, m_buffGLTarget );
}
#endif
}
m_bMapped = false;
}
GLuint CGLMBuffer::GetHandle() const
{
return ( m_bUsingPersistentBuffer ? m_pCtx->GetCurPersistentBuffer( m_type )->GetHandle() : m_nHandle );
}