source-engine/hammer/dispmanager.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $Workfile:     $
// $Date:         $
// $NoKeywords: $
//=============================================================================//

#include <stdafx.h>
#include "UtlLinkedList.h"
//#include "DispManager.h"
#include "MapFace.h"
#include "MapDisp.h"
#include "DispSubdiv.h"
#include "History.h"
#include "tier0/minidump.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

//=============================================================================
//
// Global Displacement Manager
//
class CEditDispMgr : public IEditDispMgr
{
public: // functions

	CEditDispMgr();
	virtual ~CEditDispMgr();

	EditDispHandle_t Create( void );
	void Destroy( EditDispHandle_t handle );

	CMapDisp *GetDisp( EditDispHandle_t handle );

private: // variables

	CUtlLinkedList<CMapDisp, EditDispHandle_t>	m_AllocList;
};



//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditDispMgr* EditDispMgr( void )
{
	static CEditDispMgr s_EditDispMgr;
	return &s_EditDispMgr;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditDispMgr::CEditDispMgr()
{
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditDispMgr::~CEditDispMgr()
{
	m_AllocList.Purge();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
EditDispHandle_t CEditDispMgr::Create( void )
{
	EditDispHandle_t handle = m_AllocList.AddToTail();
	if( handle != EDITDISPHANDLE_INVALID )
	{
		CMapDisp *pDisp = &m_AllocList.Element( handle );
		pDisp->SetEditHandle( handle );
	}

	return handle;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditDispMgr::Destroy( EditDispHandle_t handle )
{
	if ( m_AllocList.IsValidIndex( handle ) )
	{
		m_AllocList.Remove( handle );
	}
	else
	{
		static bool bNoToAll = false;
		if ( !bNoToAll )
		{
			int result = AfxMessageBox( 
				"CEditDispMgr::Destroy - invalid handle.\n"
				"Write minidump?\n",
				MB_YESNO );
			
			if ( result == IDYES )
			{
				// Generate a minidump.
				WriteMiniDump();
			}
			else
			{
				bNoToAll = true;
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CMapDisp *CEditDispMgr::GetDisp( EditDispHandle_t handle )
{
	if( m_AllocList.IsValidIndex( handle ) )
	{
		return &m_AllocList.Element( handle );
	}

	return NULL;
}


//=============================================================================
//
// World Displacement Manager(s)
//
class CWorldEditDispMgr : public IWorldEditDispMgr
{
public: // functions

	// construction/deconstruction
	CWorldEditDispMgr();
	virtual ~CWorldEditDispMgr();

	// world list functionals
	int WorldCount( void );
	CMapDisp *GetFromWorld( int iWorldList );
	CMapDisp *GetFromWorld( EditDispHandle_t handle );

	void AddToWorld( EditDispHandle_t handle );	
	void RemoveFromWorld( EditDispHandle_t handle );
	
	void FindWorldNeighbors( EditDispHandle_t handle );

	// selection list functions
	int SelectCount( void );
	void SelectClear( void );
	CMapDisp *GetFromSelect( int iSelectList );

	void AddToSelect( EditDispHandle_t handle );
	void RemoveFromSelect( EditDispHandle_t handle );
	bool IsInSelect( EditDispHandle_t handle );

	void CatmullClarkSubdivide( void );

	void PreUndo( const char *pszMarkName );
	void Undo( EditDispHandle_t handle, bool bAddNeighbors );
	void PostUndo( void );

	virtual int NumSharedPoints( CMapDisp *pDisp, CMapDisp *pNeighborDisp, int *edge1, int *edge2 );

private: // functions

	void TestNeighbors( CMapDisp *pDisp, CMapDisp *pNeighborDisp );
	int GetCornerIndex( int index );
	int GetEdgeIndex( int *edge );

	bool IsInKeptList( CMapClass *pObject );

private: // variables

	CUtlVector<EditDispHandle_t>	m_WorldList;
	CUtlVector<EditDispHandle_t>	m_SelectList;

	IEditDispSubdivMesh				*m_pSubdivMesh;			// pointer to the subdivision mesh

	CUtlVector<CMapClass*>			m_aKeptList;
};


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IWorldEditDispMgr *CreateWorldEditDispMgr( void )
{
	return new CWorldEditDispMgr;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void DestroyWorldEditDispMgr( IWorldEditDispMgr **pDispMgr )
{
	if( *pDispMgr )
	{
		delete *pDispMgr;
		*pDispMgr = NULL;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CWorldEditDispMgr::CWorldEditDispMgr()
{
	// allocate the subdivision mesh
	m_pSubdivMesh = CreateEditDispSubdivMesh();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CWorldEditDispMgr::~CWorldEditDispMgr()
{
	// clear the displacement manager lists
	m_WorldList.Purge();
	m_SelectList.Purge();

	// de-allocate the subdivision mesh
	DestroyEditDispSubdivMesh( &m_pSubdivMesh );

	m_aKeptList.Purge();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CWorldEditDispMgr::WorldCount( void )
{
	return m_WorldList.Count();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CMapDisp *CWorldEditDispMgr::GetFromWorld( int iWorldList )
{
	// no assert because the .Element( ) takes care of that!
	EditDispHandle_t handle = m_WorldList.Element( iWorldList );
	return EditDispMgr()->GetDisp( handle );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CMapDisp *CWorldEditDispMgr::GetFromWorld( EditDispHandle_t handle )
{
	int ndx = m_WorldList.Find( handle );
	if( ndx != -1 )
	{
		return EditDispMgr()->GetDisp( handle );
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::AddToWorld( EditDispHandle_t handle )
{
	int ndx = m_WorldList.Find( handle );
	if( ndx == -1 )
	{
		ndx = m_WorldList.AddToTail();
		m_WorldList[ndx] = handle;
	}

	// Update itself when it gets added to the world.
	CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
	if ( pDisp )
	{
		pDisp->UpdateData();
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::RemoveFromWorld( EditDispHandle_t handle )
{
	int ndx = m_WorldList.Find( handle );
	if( ndx != -1 )
	{
		m_WorldList.Remove( ndx );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
// NOTE: this will be in the common code soon!!!!!!!!!
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::FindWorldNeighbors( EditDispHandle_t handle )
{
	// get the current displacement
	CMapDisp *pDisp = GetFromWorld( handle );
	if( !pDisp )
		return;

	//
	// compare against all of the displacements in the world
	//
	int count = WorldCount();
	for( int ndx = 0; ndx < count; ndx++ )
	{
		// get the potential neighbor surface
		CMapDisp *pNeighborDisp = GetFromWorld( ndx );

		// check for valid neighbor and don't compare against self
		if( !pNeighborDisp || ( pNeighborDisp == pDisp ) )
			continue;

		// displacements at different resolutions are not considered neighbors
		// regardless of edge connectivity
		if( pDisp->GetPower() != pNeighborDisp->GetPower() )
			continue;

		// test for neighboring edge/corner properties
		TestNeighbors( pDisp, pNeighborDisp );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::TestNeighbors( CMapDisp *pDisp, CMapDisp *pNeighborDisp )
{
	//
	// find the number of shared points between the two displacements (corners, edges)
	// NOTE: should use only 2, but face may be right on top of one another
	//
	int edge1[4], edge2[4];
	int sharedPointCount = NumSharedPoints( pDisp, pNeighborDisp, edge1, edge2 );

	//
	// set the neighboring info
	//
	if( sharedPointCount == 1 )
	{
		int cornerIndex = GetCornerIndex( edge1[0] );
		int neighborCornerIndex = GetCornerIndex( edge2[0] );

		if ( ( cornerIndex != -1 ) && ( neighborCornerIndex != -1 ) )
		{
			CMapFace *pNeighborFace = ( CMapFace* )pNeighborDisp->GetParent();
			pDisp->AddCornerNeighbor( cornerIndex, pNeighborFace->GetDisp(), neighborCornerIndex );
		}
	}
	else if( sharedPointCount == 2 )
	{
		//
		// get edge indices
		//
		int edgeIndex = GetEdgeIndex( edge1 );
		int neighborEdgeIndex = GetEdgeIndex( edge2 );

		if ( ( edgeIndex != -1 ) && ( neighborEdgeIndex != -1 ) )
		{
			CMapFace *pNeighborFace = ( CMapFace* )pNeighborDisp->GetParent();
			pDisp->SetEdgeNeighbor( edgeIndex, pNeighborFace->GetDisp(), neighborEdgeIndex );
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool ComparePoints( const Vector& v1, const Vector& v2, float tolerance )
{
	for( int axis = 0; axis < 3; axis++ )
	{
		if( fabs( v1[axis] - v2[axis] ) > tolerance )
			return false;
	}
	
	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CWorldEditDispMgr::NumSharedPoints( CMapDisp *pDisp, CMapDisp *pNeighborDisp,
								      int *edge1, int *edge2 )
{
	int ptCount = 0;

	for( int i = 0; i < 4; i++ )
	{
		int j;
		for( j = 0; j < 4; j++ )
		{
			Vector pt1, pt2;
			pDisp->GetSurfPoint( i, pt1 );
			pNeighborDisp->GetSurfPoint( j, pt2 );
			if( ComparePoints( pt1, pt2, 0.01f ) )
				break;
		}

		if( j == 4 )
			continue;

		edge1[ptCount] = i;
		edge2[ptCount] = j;
		ptCount++;
	}

	return ptCount;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CWorldEditDispMgr::GetCornerIndex( int index )
{
	switch( index )
	{
	case 0: return 0;
	case 1: return 2;
	case 2: return 3;
	case 3: return 1;
	default: return -1;
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CWorldEditDispMgr::GetEdgeIndex( int *edge )
{
	if( ( edge[0] == 0 && edge[1] == 1 ) || ( edge[0] == 1 && edge[1] == 0 ) )
		return 0;

    if( ( edge[0] == 1 && edge[1] == 2 ) || ( edge[0] == 2 && edge[1] == 1 ) )
        return 1;
    
    if( ( edge[0] == 2 && edge[1] == 3 ) || ( edge[0] == 3 && edge[1] == 2 ) )
        return 2;

    if( ( edge[0] == 3 && edge[1] == 0 ) || ( edge[0] == 0 && edge[1] == 3 ) )
        return 3;

    return -1;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CWorldEditDispMgr::SelectCount( void )
{
	return m_SelectList.Count();
}

	
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::SelectClear( void )
{
	m_SelectList.RemoveAll();
}

	
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CMapDisp *CWorldEditDispMgr::GetFromSelect( int iSelectList )
{
	// no assert because the .Element( ) takes care of that!
	EditDispHandle_t handle = m_SelectList.Element( iSelectList );
	return EditDispMgr()->GetDisp( handle );	
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::AddToSelect( EditDispHandle_t handle )
{
	int ndx = m_SelectList.Find( handle );
	if( ndx == -1 )
	{
		ndx = m_SelectList.AddToTail();
		m_SelectList[ndx] = handle;
	}
}
	
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::RemoveFromSelect( EditDispHandle_t handle )
{
	int ndx = m_SelectList.Find( handle );
	if( ndx != -1 )
	{
		m_SelectList.Remove( handle );
	}
}

	
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWorldEditDispMgr::IsInSelect( EditDispHandle_t handle )
{
	int ndx = m_SelectList.Find( handle );
	return ( ndx != -1 );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::CatmullClarkSubdivide( void )
{
	// change the mouse to hourglass, so level designers know something is
	// happening
	HCURSOR oldCursor = SetCursor( LoadCursor( NULL, IDC_WAIT ) );

	//
	// add all of the displacements in the selection list into the UNDO
	// system
	//
	PreUndo( "Subdivision" );

	int selectCount = m_SelectList.Count();
	for( int ndxSelect = 0; ndxSelect < selectCount; ndxSelect++ )
	{
		// get the current displacement surface
		CMapDisp *pDisp = GetFromSelect( ndxSelect );
		if( pDisp )
		{
			Undo( pDisp->GetEditHandle(), false );
		}
	}

	PostUndo();

	// initialize the subdivision mesh
	m_pSubdivMesh->Init();
	
	//
	// add all of the displacements in the selection list into the 
	// subdivision mesh
	//
	for( int ndxSelect = 0; ndxSelect < selectCount; ndxSelect++ )
	{
		// get the current displacement surface
		CMapDisp *pDisp = GetFromSelect( ndxSelect );
		if( pDisp )
		{
			m_pSubdivMesh->AddDispTo( pDisp );
		}
	}

	// subdivision
	m_pSubdivMesh->DoCatmullClarkSubdivision();

	//
	// get back subdivided data for all displacement surfaces in the
	// selection list
	//
	for( int ndxSelect = 0; ndxSelect < selectCount; ndxSelect++ )
	{
		// get the current displacement surface
		CMapDisp *pDisp = GetFromSelect( ndxSelect );
		if( pDisp )
		{
			m_pSubdivMesh->GetDispFrom( pDisp );
		}
	}

	m_pSubdivMesh->Shutdown();

	// set the cursor back
	SetCursor( oldCursor );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWorldEditDispMgr::IsInKeptList( CMapClass *pObject )
{
	if ( m_aKeptList.Find( pObject ) == -1 )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::PreUndo( const char *pszMarkName )
{
	GetHistory()->MarkUndoPosition( NULL, pszMarkName );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::Undo( EditDispHandle_t hDisp, bool bAddNeighbors )
{
	// Check the handle.
	Assert( hDisp != EDITDISPHANDLE_INVALID );
	if( hDisp == EDITDISPHANDLE_INVALID )
		return;

	// Get the map class object that contains the displacement surface.
	CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );
	if ( !pDisp )
		return;

	CMapFace *pFace = ( CMapFace* )pDisp->GetParent();
	CMapSolid *pSolid = ( CMapSolid* )pFace->GetParent();
	CMapClass *pObject = ( CMapClass* )pSolid;
	if ( !pObject )
		return;

	// Keep the map class object for undo.
	if ( !IsInKeptList( pObject ) )
	{
		m_aKeptList.AddToTail( pObject );
		GetHistory()->Keep( pObject );
	}

	// Keep the map class (displacement parent) neighbor objects for undo.
	if ( bAddNeighbors )
	{
		int					nNeighborOrient;
		EditDispHandle_t	hNeighbor;

		for ( int iNeighbor = 0; iNeighbor < 4; ++iNeighbor )
		{
			pDisp = EditDispMgr()->GetDisp( hDisp );
			if ( pDisp )
			{
				//
				// Edge Neighbors.
				//
				pDisp->GetEdgeNeighbor( iNeighbor, hNeighbor, nNeighborOrient );
				if( hNeighbor != EDITDISPHANDLE_INVALID )
				{
					CMapDisp *pNeighborDisp = EditDispMgr()->GetDisp( hNeighbor );
					CMapFace *pNeighborFace = ( CMapFace* )pNeighborDisp->GetParent();
					CMapSolid *pNeighborSolid = ( CMapSolid* )pNeighborFace->GetParent();
					CMapClass *pNeighborObject = ( CMapClass* )pNeighborSolid;
					if ( !IsInKeptList( pNeighborObject ) )
					{
						m_aKeptList.AddToTail( pNeighborObject );
						GetHistory()->Keep( pNeighborObject );
					}					
				}
			}
			
			pDisp = EditDispMgr()->GetDisp( hDisp );
			if ( pDisp )
			{
				//
				// Corner Neighbors.
				//
				int nCornerCount = pDisp->GetCornerNeighborCount( iNeighbor );
				for( int iCorner = 0; iCorner < nCornerCount; ++iCorner )
				{
					pDisp = EditDispMgr()->GetDisp( hDisp );
					if ( pDisp )
					{
						pDisp->GetCornerNeighbor( iNeighbor, iCorner, hNeighbor, nNeighborOrient );
						
						CMapDisp *pNeighborDisp = EditDispMgr()->GetDisp( hNeighbor );
						if ( pNeighborDisp )
						{
							CMapFace *pNeighborFace = ( CMapFace* )pNeighborDisp->GetParent();
							CMapSolid *pNeighborSolid = ( CMapSolid* )pNeighborFace->GetParent();
							CMapClass *pNeighborObject = ( CMapClass* )pNeighborSolid;	
							if ( !IsInKeptList( pNeighborObject ) )
							{
								m_aKeptList.AddToTail( pNeighborObject );
								GetHistory()->Keep( pNeighborObject );
							}
						}
					}
				}
			}			
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWorldEditDispMgr::PostUndo( void )
{
	// Clear the kept list.
	m_aKeptList.RemoveAll();
}