//========= 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 ); 
}