tf2/tf2_src/hammer/tooldisplace.cpp

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

#include <stdafx.h>
#include "hammer.h"
#include "ToolDisplace.h"
#include "MainFrm.h"
#include "FaceEditSheet.h"
#include "GlobalFunctions.h"
#include "MapAtom.h"
#include "MapSolid.h"
#include "MapView3D.h"
#include "History.h"
#include "Camera.h"
#include "MapDoc.h"
#include "ChunkFile.h"
#include "ToolManager.h"
#include "SculptOptions.h"

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

//=============================================================================


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CToolDisplace::CToolDisplace()
{
    m_uiTool = DISPTOOL_SELECT;
	m_uiEffect = DISPPAINT_EFFECT_RAISELOWER;
	m_uiBrushType = DISPPAINT_BRUSHTYPE_SOFT;

	m_iPaintChannel = DISPPAINT_CHANNEL_POSITION;
	m_flPaintValueGeo = 5.0f;
	m_flPaintValueData = 25.0f;
	m_iPaintAxis = DISPPAINT_AXIS_FACE;
	m_vecPaintAxis.Init( 0.0f, 0.0f, 1.0f );

	m_bAutoSew = false;
	m_bSpatial = false;
	m_flSpatialRadius = 15.0f;
	m_bSpatialRadius = false;

	m_bSelectMaskTool = true;
	m_bGridMaskTool = false;

	m_bLMBDown = false;
	m_bRMBDown = false;

	m_bNudge = false;
	m_bNudgeInit = false;
	m_EditDispHandle = EDITDISPHANDLE_INVALID;

	// load filters from file
	static char szProgramDir[MAX_PATH];
	APP()->GetDirectory( DIR_PROGRAM, szProgramDir );
	strcat( szProgramDir, "filters\\dispfilters.txt" );
	LoadFilters( szProgramDir );
	AddFiltersToManagers();

	m_SculptTool = NULL;
	m_MousePoint.Init( 0.0f, 0.0f );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CToolDisplace::~CToolDisplace()
{
	// destroy filters
	m_FilterRaiseLowerMgr.Destroy();
	m_FilterRaiseToMgr.Destroy();
	m_FilterSmoothMgr.Destroy();
}


//-----------------------------------------------------------------------------
// Purpose: Called when the tool is activated.
// Input  : eOldTool - The ID of the previously active tool.
//-----------------------------------------------------------------------------
void CToolDisplace::OnActivate()
{
	//
	// initialize masks
	//
	CMapDisp::SetSelectMask( m_bSelectMaskTool );
	CMapDisp::SetGridMask( m_bGridMaskTool );
}
 
   
//-----------------------------------------------------------------------------
// Purpose: Called when the tool is deactivated.
// Input  : eNewTool - The ID of the tool that is being activated.
//-----------------------------------------------------------------------------
void CToolDisplace::OnDeactivate()
{
	//
	// reset masks
	//
	CMapDisp::SetSelectMask( false );
	CMapDisp::SetGridMask( false );
	
	if ( m_pDocument->GetTools()->GetActiveToolID() != TOOL_FACEEDIT_MATERIAL )
	{
		// Clear the selected faces when we are deactivated.
		m_pDocument->SelectFace(NULL, 0, scClear );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CToolDisplace::UpdateMapViews( CMapView3D *pView )
{
	CMapDoc *pDoc = pView->GetMapDoc();
	if( pDoc )
	{
		pDoc->SetModifiedFlag();
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CToolDisplace::CalcViewCenter( CMapView3D *pView )
{
	CRect windowRect;
	pView->GetWindowRect( windowRect );
	m_viewCenter = windowRect.CenterPoint();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnLMouseDown3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	// Set down flags
	m_bLMBDown = true;

	if( m_uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->OnLMouseDown3D( pView, nFlags, vPoint );
		m_SculptTool->BeginPaint( pView, vPoint );
		ApplySculptSpatialPaintTool( pView, nFlags, vPoint );

		// update
		UpdateMapViews( pView );

		return true;
	}

	// Selection.
	if( m_uiTool == DISPTOOL_SELECT || ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) )
	{
		// handle selection at point
		HandleSelection( pView, vPoint );

		// update
		UpdateMapViews( pView );
		return true;
	}

	// Tagging.
	if ( m_uiTool == DISPTOOL_TAG_WALKABLE || m_uiTool == DISPTOOL_TAG_BUILDABLE || m_uiTool == DISPTOOL_TAG_REMOVE )
	{
		// Do tagging.
		HandleTagging( pView, vPoint );
		return true;
	}

	// Resize the spatial painting sphere.
	if( ( m_uiTool == DISPTOOL_PAINT ) && ( IsSpatialPainting() ) &&
		( GetAsyncKeyState( VK_MENU ) & 0x8000 ) )
	{
		ResizeSpatialRadius_Activate( pView );
		return true;
	}

	// Nudging.
	if( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) )
	{
		// is the current effect raise/lower (nudge only works in raise/lower mode)
		if( m_uiEffect == DISPPAINT_EFFECT_RAISELOWER )
		{
			EditDispHandle_t handle = GetHitPos( pView, vPoint );
			if( handle != EDITDISPHANDLE_INVALID )
			{
				m_EditDispHandle = handle;

				Nudge_Activate( pView, handle );
				UpdateMapViews( pView );
				return true;
			}
		}
	}

	// Painting.
	if( m_uiTool == DISPTOOL_PAINT )
	{
		// get hit info
		EditDispHandle_t handle = GetHitPos( pView, vPoint );
		if( handle == EDITDISPHANDLE_INVALID )
			return false;
		m_EditDispHandle = handle;

		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
		if( !pDispMgr )
			return false;

		pDispMgr->PreUndo( "Displacement Modifier" );

		// Paint using the correct mode.
		if ( m_bSpatial )
		{
			int nDispCount = pDispMgr->SelectCount();
			for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
			{
				CMapDisp *pDispSelect = pDispMgr->GetFromSelect( iDisp );
				if ( pDispSelect )
				{
					pDispSelect->Paint_Init( DISPPAINT_CHANNEL_POSITION );
				}
			}

			// setup for undo - modifying the displacement (painting)
			ApplySpatialPaintTool( nFlags, vPoint, pDisp );
		}
		else
		{
			// setup for undo - modifying the displacement (painting)
			pDispMgr->Undo( handle, true );
			pDisp = EditDispMgr()->GetDisp( handle );
			ApplyPaintTool( nFlags, vPoint, pDisp );    
		}

		// update
		UpdateMapViews( pView );
	}

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnLMouseUp3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	// left button up
	m_bLMBDown = false;

	if( m_uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->OnLMouseUp3D( pView, nFlags, vPoint );
		return true;
	}

	if ( m_bNudge )
	{
		Nudge_Deactivate();
	}

	if ( m_bSpatialRadius )
	{
		ResizeSpatialRadius_Deactivate();
	}

	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( pDispMgr )
	{
		pDispMgr->PostUndo();
	}

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnRMouseDown3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	// left button down
    m_bRMBDown = true;

	if( m_uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->OnRMouseDown3D( pView, nFlags, vPoint );
		m_SculptTool->BeginPaint( pView, vPoint );
		ApplySculptSpatialPaintTool( pView, nFlags, vPoint );

		// update
		UpdateMapViews( pView );

		return true;
	}

	//
	// lifting the face normal - painting with the axis set to "Face Normal"
	//
	if( ( m_uiTool == DISPTOOL_PAINT ) && ( m_iPaintAxis == DISPPAINT_AXIS_FACE ) &&
		( GetAsyncKeyState( VK_MENU ) & 0x8000 ) )
	{
		LiftFaceNormal( pView, vPoint );
		return true;
	}

	// Tagging.
	if ( m_uiTool == DISPTOOL_TAG_WALKABLE || m_uiTool == DISPTOOL_TAG_BUILDABLE || m_uiTool == DISPTOOL_TAG_REMOVE )
	{
		// Do tagging.
		HandleTaggingReset( pView, vPoint );
		return true;
	}

	//
	// handle the normal paint procedure
	//
	if( m_uiTool == DISPTOOL_PAINT )
	{
		// get hit info
		EditDispHandle_t handle = GetHitPos( pView, vPoint );
		if( handle == EDITDISPHANDLE_INVALID )
			return false;
		m_EditDispHandle = handle;

		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
		if( !pDispMgr )
			return false;

		pDispMgr->PreUndo( "Displacement Modifier" );

		// apply the current displacement tool
		if ( m_bSpatial )
		{
			int nDispCount = pDispMgr->SelectCount();
			for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
			{
				CMapDisp *pDispSelect = pDispMgr->GetFromSelect( iDisp );
				if ( pDispSelect )
				{
					pDispSelect->Paint_Init( DISPPAINT_CHANNEL_POSITION );
				}
			}

			ApplySpatialPaintTool( nFlags, vPoint, pDisp );
		}
		else
		{
			// setup for undo
			pDispMgr->Undo( handle, true );
			pDisp = EditDispMgr()->GetDisp( handle );
			ApplyPaintTool( nFlags, vPoint, pDisp );    
		}

		// update
		UpdateMapViews( pView );
	}

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnRMouseUp3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	// left button up
	m_bRMBDown = false;

	if( m_uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->OnRMouseUp3D( pView, nFlags, vPoint );
		return true;
	}

	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( pDispMgr )
	{
		pDispMgr->PostUndo();
	}

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnMouseMove3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	m_MousePoint = vPoint;

	if( m_uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->OnMouseMove3D( pView, nFlags, vPoint );

		if( ( m_bLMBDown || m_bRMBDown ) )
		{	
			ApplySculptSpatialPaintTool( pView, nFlags, vPoint );
		}

		// update
		UpdateMapViews( pView );

		return true;
	}

	// nudging
	if ( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) && 
		m_bLMBDown && m_bNudge )
	{
		Nudge_Do();
	}
	// Resizing the spatial sphere.
	else if ( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_MENU ) & 0x8000 ) &&
		      m_bLMBDown && m_bSpatialRadius )
	{
		ResizeSpatialRadius_Do();
	}
	// painting
	else
	{
		// get hit info
		EditDispHandle_t handle = GetHitPos( pView, vPoint );
		if( handle == EDITDISPHANDLE_INVALID )
			return false;
		m_EditDispHandle = handle;

		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		//
		// continue with tool operation?!
		//
		if( ( m_bLMBDown || m_bRMBDown ) && !( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) &&
			( m_uiTool == DISPTOOL_PAINT ) )
		{	
			if ( m_bSpatial )
			{
				ApplySpatialPaintTool( nFlags, vPoint, pDisp );
			}
			else
			{
				ApplyPaintTool( nFlags, vPoint, pDisp );
			}
		}

		// not nudging anymore -- if we were
		if( m_bNudge )
		{
			Nudge_Deactivate();
		}

		if ( m_bSpatialRadius )
		{
			ResizeSpatialRadius_Deactivate();
		}
	}

	// update
	UpdateMapViews( pView );

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::LiftFaceNormal( CMapView3D *pView, const Vector2D &vPoint )
{
	//
	// check for closest solid object
	//
	ULONG		ulFace;
	CMapClass	*pObject;

	if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
	{
		if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
		{
			// get the solid
			CMapSolid *pSolid = ( CMapSolid* )pObject;
			if( !pSolid )
				return;

			// trace a line and get the normal -- will get a displacement normal
			// if one exists
			CMapFace *pFace = pSolid->GetFace( ulFace );
			if( !pFace )
				return;

			Vector vRayStart, vRayEnd;
			pView->GetCamera()->BuildRay( vPoint, vRayStart, vRayEnd );

			Vector vHitPos, vHitNormal;
			if( pFace->TraceLine( vHitPos, vHitNormal, vRayStart, vRayEnd ) )
			{
				// set the paint direction
				m_vecPaintAxis = vHitNormal;
			}
			else
			{
				// will default to z if no normal found
				m_vecPaintAxis.Init( 0.0f, 0.0f, 1.0f );
			}
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Activate( CMapView3D *pView, EditDispHandle_t dispHandle )
{
	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( !pDispMgr )
		return;

	pDispMgr->PreUndo( "Displacement Nudge" );

	// Setup paint (nudge) using the correct mode.
	if ( m_bSpatial )
	{
		int nDispCount = pDispMgr->SelectCount();
		for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
		{
			CMapDisp *pDisp = pDispMgr->GetFromSelect( iDisp );
			if ( pDisp )
			{
				pDisp->Paint_Init( DISPPAINT_CHANNEL_POSITION );
			}
		}
	}
	else
	{
		// setup for undo
		pDispMgr->Undo( dispHandle, true );
	}

	// setup the cursor for "nudging"
	CalcViewCenter( pView );
	SetCursorPos( m_viewCenter.x, m_viewCenter.y );
	pView->SetCapture();

	// set nudging
	m_bNudge = true;
	m_bNudgeInit = true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Deactivate( void )
{
	ReleaseCapture();
	m_bNudge = false;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Do( void )
{
	CMapDisp *pNudgeDisp = GetEditDisp();
	if (pNudgeDisp == NULL)
	{
		return;
	}

	//
	// find the greatest delta and "nudge"
	//
	// NOTE: using get cursor position, because it is different than the 
	//       "point" incoming into mouse move????
	//
	CPoint nudgePos;
	GetCursorPos( &nudgePos );

	CPoint nudgeDelta;
	nudgeDelta.x = nudgePos.x - m_viewCenter.x;
	nudgeDelta.y = nudgePos.y - m_viewCenter.y;

	float delta;
	if( abs( nudgeDelta.x ) < abs( nudgeDelta.y ) )
	{
		delta = nudgeDelta.y;
	}
	else
	{
		delta = nudgeDelta.x;
	}
	delta = -delta;

	if ( !IsSpatialPainting() )
	{
		CDispMapImageFilter *pFilter = m_FilterRaiseLowerMgr.GetActiveFilter();
		if( !pFilter )
			return;
		
		// set the dynamic filter data
		pFilter->m_DataType = DISPPAINT_CHANNEL_POSITION;
		pFilter->m_Scale = ( delta * 0.25 ) * ( float )( ( int )( m_flPaintValueGeo / 10.0f ) + 1 ) ;
		
		// apply the filter to the displacement surface(s)
		m_FilterRaiseLowerMgr.Apply( pFilter, pNudgeDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
	}
	else
	{
		// Get the hit index and check for validity.
		int iHit = pNudgeDisp->GetTexelHitIndex();
		if ( iHit != -1 )
		{
			// Initialize the spatial paint data.
			SpatialPaintData_t spatialData;
			spatialData.m_nEffect = DISPPAINT_EFFECT_RAISELOWER;
			spatialData.m_uiBrushType = m_uiBrushType;
			spatialData.m_flRadius = m_flSpatialRadius;
			spatialData.m_flScalar = delta;
			spatialData.m_bNudge = true;
			spatialData.m_bNudgeInit = m_bNudgeInit;
			pNudgeDisp->GetVert( iHit, spatialData.m_vCenter );
			VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );
			
			m_DispPaintMgr.Paint( spatialData, m_bAutoSew );

			// Done with the init.
			m_bNudgeInit = false;
		}
	}

	// reset the cursor pos
	SetCursorPos( m_viewCenter.x, m_viewCenter.y );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplyPaintTool( UINT nFlags, const Vector2D &vPoint, CMapDisp *pDisp )
{
	switch( m_uiEffect )
	{ 
	case DISPPAINT_EFFECT_RAISELOWER:
		{
			CDispMapImageFilter *pFilter = m_FilterRaiseLowerMgr.GetActiveFilter();
			if( pFilter )
			{
				pFilter->m_DataType = m_iPaintChannel;
				if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
				{
					pFilter->m_Scale = m_flPaintValueGeo;
				}
				else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
				{
					pFilter->m_Scale = m_flPaintValueData;
				}

				if( m_bRMBDown )
				{
					pFilter->m_Scale = -pFilter->m_Scale;
				}
				
				// apply the filter to the displacement surface(s)
				m_FilterRaiseLowerMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
			}
			return;
		}
	case DISPPAINT_EFFECT_MODULATE:
		{
			// no modulate filters or filter manager currently!
			return;
		}
	case DISPPAINT_EFFECT_SMOOTH:
		{
			CDispMapImageFilter *pFilter = m_FilterSmoothMgr.GetActiveFilter();
			if( pFilter )
			{
				pFilter->m_DataType = m_iPaintChannel;
				pFilter->m_Scale = 1.0f;
				
				int areaValue = 3;
				if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
				{
					areaValue = ( m_flPaintValueGeo * 2 ) + 1;
				}
				else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
				{
					areaValue = ( m_flPaintValueData * 2 ) + 1;
				}				
				if( areaValue < 3 ) { areaValue = 3; }
				if( areaValue > 7 ) { areaValue = 7; }
				
				pFilter->m_AreaHeight = areaValue;
				pFilter->m_AreaWidth = areaValue;

				// apply the filter to the displacement surface(s)
				m_FilterSmoothMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
			}
			return;
		}
	case DISPPAINT_EFFECT_RAISETO:
		{
			CDispMapImageFilter *pFilter = m_FilterRaiseToMgr.GetActiveFilter();
			if( pFilter )
			{
				pFilter->m_DataType = m_iPaintChannel;
				if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
				{
					pFilter->m_Scale = m_flPaintValueGeo;
				}
				else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
				{
					pFilter->m_Scale = m_flPaintValueData;
				}

				// apply the filter to the displacement surface(s)
				m_FilterRaiseToMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
			}
			return;
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplySpatialPaintTool( UINT nFlags, const Vector2D &vPoint, CMapDisp *pDisp )
{
	// Right mouse button only used to paint in a Raise/Lower situation.
	if ( ( m_uiEffect != DISPPAINT_EFFECT_RAISELOWER ) && m_bRMBDown )
		return;

	// Get the hit index and check for validity.
	int iHit = pDisp->GetTexelHitIndex();
	if ( iHit == -1 )
		return;

	// Initialize the spatial paint data.
	SpatialPaintData_t spatialData;
	spatialData.m_nEffect = m_uiEffect;
	spatialData.m_uiBrushType = m_uiBrushType;
	spatialData.m_flRadius = m_flSpatialRadius;
	spatialData.m_flScalar = m_flPaintValueGeo;
	spatialData.m_bNudge = false;
	if ( m_bRMBDown )
	{
		spatialData.m_flScalar = -spatialData.m_flScalar;
	}
	pDisp->GetVert( iHit, spatialData.m_vCenter );
	VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );

	m_DispPaintMgr.Paint( spatialData, m_bAutoSew );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplySculptSpatialPaintTool( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
	// Initialize the spatial paint data.
	SpatialPaintData_t spatialData;

	spatialData.m_vCenter.Init();

	// get hit info
	EditDispHandle_t handle = GetHitPos( pView, vPoint );
	if( handle != EDITDISPHANDLE_INVALID )
	{
		m_EditDispHandle = handle;
		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		// Get the hit index and check for validity.
		int iHit = pDisp->GetTexelHitIndex();
		if ( iHit != -1 )
		{
			pDisp->GetVert( iHit, spatialData.m_vCenter );
		}
	}

	spatialData.m_nEffect = m_uiEffect;
	spatialData.m_uiBrushType = m_uiBrushType;
	spatialData.m_flRadius = m_flSpatialRadius;
	spatialData.m_flScalar = m_flPaintValueGeo;
	spatialData.m_bNudge = false;
	if ( m_bRMBDown )
	{
		spatialData.m_flScalar = -spatialData.m_flScalar;
	}
	VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );

	m_SculptTool->Paint( pView, vPoint, spatialData );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Activate( CMapView3D *pView )
{
	// Calculate the center of the view and capture the mouse cursor.
	CalcViewCenter( pView );
	SetCursorPos( m_viewCenter.x, m_viewCenter.y );
	pView->SetCapture();

	m_bSpatialRadius = true;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Deactivate( void )
{
	ReleaseCapture();
	m_bSpatialRadius = false;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Do( void )
{
	CPoint cursorPos;
	GetCursorPos( &cursorPos );

	// Calculate the delta between the cursor from last frame and this one.
	CPoint cursorDelta;
	cursorDelta.x = cursorPos.x - m_viewCenter.x;
	cursorDelta.y = cursorPos.y - m_viewCenter.y;

	float flDelta;
	if( abs( cursorDelta.x ) < abs( cursorDelta.y ) )
	{
		flDelta = cursorDelta.y;
	}
	else
	{
		flDelta = cursorDelta.x;
	}
	flDelta = -flDelta;

	// Adjust the sphere radius.
	m_flSpatialRadius += flDelta;

	// reset the cursor pos
	SetCursorPos( m_viewCenter.x, m_viewCenter.y );

	//
	// Update the paint dialog.
	//
	CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
	if( pSheet )
	{
		pSheet->m_DispPage.UpdatePaintDialogs();
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::HandleSelection( CMapView3D *pView, const Vector2D &vPoint )
{
	//
	// check for closest solid object
	//
	ULONG		ulFace;
	CMapClass	*pObject;

	bool bShift = ( ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) != 0 );

	if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
	{
		if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
		{
			// get the solid
			CMapSolid *pSolid = ( CMapSolid* )pObject;
			
			// setup initial command state
			int cmd = scToggle | scClear;
			
			//
			// don't "clear" if CTRL is pressed
			//
			if( GetAsyncKeyState( VK_CONTROL ) & 0x8000 )
			{
				cmd &= ~scClear;
			}
			
			CMapDoc *pDoc = pView->GetMapDoc();
			if( !pDoc )
				return;
			
			// If they are holding down SHIFT, select the entire solid.
			if ( bShift )
			{
				pDoc->SelectFace( pSolid, -1, cmd );
			}
			// Otherwise, select a single face.
			else
			{
				pDoc->SelectFace( pSolid, ulFace, cmd );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle the overriding of displacement triangle tag.
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTagging( CMapView3D *pView, const Vector2D &vPoint )
{
	// Get the displacement face (if any) at the 2d point.
	ULONG ulFace;
	CMapClass *pObject = NULL;

	if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
	{
		if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
		{
			// Get the face and check for a displacement.
			CMapSolid *pSolid = ( CMapSolid* )pObject;
			CMapFace *pFace = pSolid->GetFace( ( int )ulFace );
			if ( pFace && pFace->HasDisp() )
			{
				EditDispHandle_t hDisp = pFace->GetDisp();
				CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );

				Vector vecStart, vecEnd;
				pView->GetCamera()->BuildRay( vPoint, vecStart, vecEnd );

				float flFraction;
				int iTri = pDisp->CollideWithDispTri( vecStart, vecEnd, flFraction );
				if ( iTri != -1 )
				{
					if ( m_uiTool == DISPTOOL_TAG_WALKABLE )
					{
						if ( pDisp->IsTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT ) )
						{
							pDisp->ToggleTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
						}
						else
						{
							pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT );
							if ( !pDisp->IsTriTag( iTri, COREDISPTRI_TAG_WALKABLE ) )
							{
								pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
							}
							else
							{
								pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
							}
						}

						pDisp->UpdateWalkable();
					}
					else if ( m_uiTool == DISPTOOL_TAG_BUILDABLE )
					{
						if ( pDisp->IsTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT ) )
						{
							pDisp->ToggleTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
						}
						else
						{
							pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT );
							if ( !pDisp->IsTriTag( iTri, COREDISPTRI_TAG_BUILDABLE ) )
							{
								pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
							}
							else
							{
								pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
							}
						}

						pDisp->UpdateBuildable();
					}
					else if ( m_uiTool == DISPTOOL_TAG_REMOVE )
					{
						HandleTaggingRemove( pDisp, iTri );
					}
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTaggingRemove( CMapDisp *pDisp, int nTriIndex )
{
	pDisp->ToggleTriTag( nTriIndex, COREDISPTRI_TAG_FORCE_REMOVE_BIT );
	pDisp->UpdateTriRemove();
}


//-----------------------------------------------------------------------------
// Purpose: Handle the overriding of displacement triangle tag.
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTaggingReset( CMapView3D *pView, const Vector2D &vPoint )
{
	// Get the displacement face (if any) at the 2d point.
	ULONG ulFace;
	CMapClass *pObject = NULL;

	if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
	{
		if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
		{
			// Get the face and check for a displacement.
			CMapSolid *pSolid = ( CMapSolid* )pObject;
			CMapFace *pFace = pSolid->GetFace( ( int )ulFace );
			if ( pFace && pFace->HasDisp() )
			{
				EditDispHandle_t hDisp = pFace->GetDisp();
				CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );

				Vector vecStart, vecEnd;
				pView->GetCamera()->BuildRay( vPoint, vecStart, vecEnd );

				float flFraction;
				int iTri = pDisp->CollideWithDispTri( vecStart, vecEnd, flFraction );
				if ( iTri != -1 )
				{
					if ( m_uiTool == DISPTOOL_TAG_WALKABLE )
					{
						pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT );
						pDisp->UpdateWalkable();
					}
					else if ( m_uiTool == DISPTOOL_TAG_BUILDABLE )
					{
						pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT );
						pDisp->UpdateBuildable();
					}
					else if ( m_uiTool == DISPTOOL_TAG_REMOVE )
					{
						pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_REMOVE_BIT );
						pDisp->UpdateBuildable();
					}
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
EditDispHandle_t CToolDisplace::GetHitPos( CMapView3D *pView, const Vector2D &vPoint )
{
	//
	// get ray info
	//
	Vector rayStart, rayEnd;
	pView->GetCamera()->BuildRay( vPoint, rayStart, rayEnd );

	// generate selected displacement list
	int dispCount = GetSelectedDisps();
	if( dispCount == 0 )
		return NULL;

	// collide against all "active" displacements and set texel hit data
	return CollideWithSelectedDisps( rayStart, rayEnd );	
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CToolDisplace::GetSelectedDisps( void )
{
	//
	// get a valid displacement manager
	//
	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( !pDispMgr )
		return 0;

	// clear the selection list
	pDispMgr->SelectClear();

	//
	// add all selected displacements to "displacement manager"'s selection list
	//
	CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
	if( !pSheet )
		return 0;

	int faceCount = pSheet->GetFaceListCount();
	for( int i = 0; i < faceCount; i++ )
	{
		CMapFace *pFace = pSheet->GetFaceListDataFace( i );
		if( !pFace )
			continue;

		if( pFace->HasDisp() )
		{
			EditDispHandle_t handle = pFace->GetDisp();
			CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
			pDisp->ResetTexelHitIndex();
			pDispMgr->AddToSelect( handle );
		}
	}

	// return the number of displacements in list
	return pDispMgr->SelectCount();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
EditDispHandle_t CToolDisplace::CollideWithSelectedDisps( const Vector &rayStart, const Vector &rayEnd )
{
	EditDispHandle_t handle = EDITDISPHANDLE_INVALID;
	float			 minDist = 99999.9f;
	int				 minIndex = -1;

	//
	// get a valid displacement manager
	//
	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( !pDispMgr )
		return NULL;

	int dispCount = pDispMgr->SelectCount();
	for( int i = 0; i < dispCount; i++ )
	{
		// get the current displacement
		CMapDisp *pDisp = pDispMgr->GetFromSelect( i );
		if( !pDisp )
			continue;

		bool bCollide = RayAABBTest( pDisp, rayStart, rayEnd );
		if( bCollide )
		{
			Vector point;
			int size = pDisp->GetSize();
			for( int j = 0; j < size; j++ )
			{
				// get current point
				pDisp->GetVert( j, point );

				// find point closest to ray
				float dist = DistFromPointToRay( rayStart, rayEnd, point );
				if( dist < minDist )
				{
					CMapFace *pFace = ( CMapFace* )pDisp->GetParent();
					handle = pFace->GetDisp();
					minDist = dist;
					minIndex = j;
				}
			}
		}
	}

	//
	// set the texel hit index
	//
	if( handle != EDITDISPHANDLE_INVALID )
	{
		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
		pDisp->SetTexelHitIndex( minIndex );
	}

	return handle;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::RayAABBTest( CMapDisp *pDisp, const Vector &rayStart, const Vector &rayEnd )
{
	//
	// make planes
	//
	PLANE planes[6];
	Vector boxMin, boxMax;
	pDisp->GetBoundingBox( boxMin, boxMax );
	BuildParallelepiped( boxMin, boxMax, planes );

	bool bCollide = false;
	for( int planeIndex = 0; planeIndex < 6; planeIndex++ )
	{
		bCollide = RayPlaneTest( &planes[planeIndex], rayStart, rayEnd );
		if( !bCollide )
			return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::BuildParallelepiped( const Vector &boxMin, const Vector &boxMax,
							             PLANE planes[6] )
{
	int planeIndex = 0;
	for( int axis = 0; axis < 3; axis++ )
	{
		for( int direction = -1; direction < 2; direction += 2 )
		{
			// clear the current plane info
			VectorClear( planes[planeIndex].normal );
			planes[planeIndex].normal[axis] = direction;
			if( direction == 1 )
			{
				planes[planeIndex].dist = boxMax[axis];
			}
			else
			{
				planes[planeIndex].dist = -boxMin[axis];
			}

			planeIndex++;
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::RayPlaneTest( PLANE *pPlane, const Vector& rayStart, const Vector& rayEnd /*, float *fraction*/ )
{
	//
	// get the distances both trace start and end from the bloated plane
	//
	float distStart = DotProduct( rayStart, pPlane->normal ) - pPlane->dist;
	float distEnd = DotProduct( rayEnd, pPlane->normal ) - pPlane->dist;

	//
	// no collision - both points are in front or behind of the given plane
	//
	if( ( distStart > 0.0f ) && ( distEnd > 0.0f ) )
		return false;

	if( ( distStart > 0.0f ) && ( distEnd > 0.0f ) )
		return false;

	// calculate the parameterized "t" component along the ray
	//*fraction = distStart / ( distStart - distEnd );

	// collision
	return true;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CToolDisplace::DistFromPointToRay( const Vector& rayStart, const Vector& rayEnd,
										 const Vector& point )
{
	//
	// calculate the ray
	//
	Vector ray;
	VectorSubtract( rayEnd, rayStart, ray );
	VectorNormalize( ray );

	//
	// get a ray to point
	//
	Vector seg;
	VectorSubtract( point, rayStart, seg );

	//
	// project point segment onto ray - get perpendicular point
	//
	float value = DotProduct( ray, seg );
	VectorScale( ray, value, ray );
	VectorAdd( rayStart, ray, ray );

	//
	// find the distance between the perpendicular point and point
	//
	VectorSubtract( ray, point, seg );
	float dist = VectorLength( seg );

	return dist;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::AddFiltersToManagers( void )
{
	int count = m_FilterLoaderMgr.GetFilterCount();
	for( int ndxFilter = 0; ndxFilter < count; ndxFilter++ )
	{
		CDispMapImageFilter *pFilter = m_FilterLoaderMgr.GetFilter( ndxFilter );
		if( pFilter )
		{
			switch( pFilter->m_Type )
			{
			case DISPPAINT_EFFECT_RAISELOWER:
				{
					m_FilterRaiseLowerMgr.Add( pFilter );
					break;
				}
			case DISPPAINT_EFFECT_RAISETO:
				{
					m_FilterRaiseToMgr.Add( pFilter );
					break;
				}
			case DISPPAINT_EFFECT_SMOOTH:
				{
					m_FilterSmoothMgr.Add( pFilter );
					break;
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::LoadFilters( const char *filename )
{
	//
	// Open the file.
	//
	CChunkFile File;
	ChunkFileResult_t eResult = File.Open( filename, ChunkFile_Read );
	
	if( eResult != ChunkFile_Ok )
	{
		Msg( mwError, "Couldn't load filter file %s!\n", filename );
	}

	//
	// Read the file.
	//
	if (eResult == ChunkFile_Ok)
	{
		//
		// Set up handlers for the subchunks that we are interested in.
		//
		CChunkHandlerMap Handlers;
		Handlers.AddHandler( "Filter", ( ChunkHandler_t )CToolDisplace::LoadFiltersCallback, this );
		File.PushHandlers( &Handlers );

		//
		// Read the sub-chunks. We ignore keys in the root of the file, so we don't pass a
		// key value callback to ReadChunk.
		//
		while (eResult == ChunkFile_Ok)
		{
			eResult = File.ReadChunk();
		}

		if (eResult == ChunkFile_EOF)
		{
			eResult = ChunkFile_Ok;
		}

		File.PopHandlers();
	}

	return( eResult == ChunkFile_Ok );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ChunkFileResult_t CToolDisplace::LoadFiltersCallback( CChunkFile *pFile, CToolDisplace *pDisplaceTool )
{
	//
	// allocate a new filter
	//
	CDispMapImageFilter *pFilter = pDisplaceTool->m_FilterLoaderMgr.Create();
	if( !pFilter )
		return ChunkFile_Fail;

	// load the filter data
	ChunkFileResult_t eResult = pFilter->LoadFilter( pFile );
	return( eResult );	
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pRender - 
//			*pTool - 
//-----------------------------------------------------------------------------
void CToolDisplace::RenderPaintSphere( CRender3D *pRender )
{
	CMapDisp *pDisp = GetEditDisp();
	if (pDisp == NULL)
		return;
	
	// Get the sphere center.
	int iHit = pDisp->GetTexelHitIndex();
	if ( iHit == -1 )
		return;

	// Get the sphere center and radius.
	Vector vCenter;
	pDisp->GetVert( iHit, vCenter );
	float flRadius = GetSpatialRadius();

	int size = ( int )( flRadius * 0.05f );
	if ( size < 6 ) { size = 6; }
	if ( size > 12 ) { size = 12; }

	// Render the sphere.
	if ( !IsNudging() )
	{
		pRender->RenderWireframeSphere( vCenter, flRadius, size, size, 0, 255, 0 );
	}
	else
	{
		pRender->RenderWireframeSphere( vCenter, flRadius, size, size, 255, 255, 0 );
	}

	// Render the displacement axis (as an arrow).
	int nPaintAxis;
	Vector vPaintAxis;
	GetPaintAxis( nPaintAxis, vPaintAxis );
	if( nPaintAxis == DISPPAINT_AXIS_SUBDIV )
	{
		pDisp->GetSubdivNormal( iHit, vPaintAxis );
	}
	float flBloat = flRadius * 0.15f;
	pRender->RenderArrow( vCenter, vCenter + ( vPaintAxis * ( flRadius + flBloat ) ), 255, 255, 0 );

	// Render cube at center point.
 	Vector	vBoxMin, vBoxMax;
	for ( int iAxis = 0; iAxis < 3; iAxis++ )
	{
		vBoxMin[iAxis] = vCenter[iAxis] - ( flBloat * 0.25f );
		vBoxMax[iAxis] = vCenter[iAxis] + ( flBloat * 0.25f );
	}
	pRender->RenderBox( vBoxMin, vBoxMax, 255, 255, 0, SELECT_NONE );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pRender - 
//			bNudge - 
//-----------------------------------------------------------------------------
void CToolDisplace::RenderHitBox( CRender3D *pRender )
{
	CMapDisp *pDisp = GetEditDisp();
	if (pDisp == NULL)
		return;

    //
    // get selection
    //
    int index = pDisp->GetTexelHitIndex();
    if( index == -1 )
        return;

    //
    // get the displacement map width and height
    //
    int width = pDisp->GetWidth();
    int height = pDisp->GetHeight();

	Vector seg[2];
	Vector points[2];

	pDisp->GetVert( 0, points[0] );
	pDisp->GetVert( ( width - 1 ), points[1] );
	VectorSubtract( points[1], points[0], seg[0] );
	pDisp->GetVert( ( ( width - 1 ) * height ), points[1] );
	VectorSubtract( points[1], points[0], seg[1] );

	VectorAdd( seg[0], seg[1], seg[0] );
	VectorScale( seg[0], 0.5f, seg[0] );
    
    //
    // determine a good size to make the "box" surrounding the selected point
    //
	float length = VectorLength( seg[0] );
    length *= 0.025f;

    //
    // render the box
    //
	pDisp->GetVert( index, points[0] );

 	Vector	minb, maxb;
    minb[0] = points[0][0] - length;
    minb[1] = points[0][1] - length;
    minb[2] = points[0][2] - length;

    maxb[0] = points[0][0] + length;
    maxb[1] = points[0][1] + length;
    maxb[2] = points[0][2] + length;

	if( !IsNudging() )
	{
	    pRender->RenderWireframeBox( minb, maxb, 0, 255, 0 );
	}
	else
	{
	    pRender->RenderWireframeBox( minb, maxb, 255, 255, 0 );
	}

	//
	// render the normal
	//
	// get hit box origin
	Vector hbOrigin;
	pDisp->GetVert( index, hbOrigin );

	// get 4x length
	float length4 = length * 4.0f;

	int paintAxis;
	Vector vecPaint;
	GetPaintAxis( paintAxis, vecPaint );
	if( paintAxis == DISPPAINT_AXIS_SUBDIV )
	{
		pDisp->GetSubdivNormal( index, vecPaint );
	}

	//
	// render the normal -- just a yellow line at this point
	//
	pRender->RenderArrow( hbOrigin, hbOrigin + ( vecPaint * length4 ), 255, 255, 0 );
#if 0
	CMeshBuilder meshBuilder;
	IMesh *pMesh = MaterialSystemInterface()->GetDynamicMesh();
	
	meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
	meshBuilder.Position3f( hbOrigin.x, hbOrigin.y, hbOrigin.z );
	meshBuilder.Color3ub( 255, 255, 0 );
	meshBuilder.AdvanceVertex();
	meshBuilder.Position3f( hbOrigin.x + ( normal.x * length4 ), 
		                    hbOrigin.y + ( normal.y * length4 ), 
							hbOrigin.z + ( normal.z * length4 ) );
	meshBuilder.Color3ub( 255, 255, 0 );
	meshBuilder.AdvanceVertex();
	meshBuilder.End();
	
	pMesh->Draw();
#endif
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pRender - 
//-----------------------------------------------------------------------------
void CToolDisplace::RenderTool3D(CRender3D *pRender)
{
	unsigned int uiTool = GetTool();
	if ( uiTool == DISPTOOL_PAINT )
	{
		if ( IsSpatialPainting() )
		{
			RenderPaintSphere( pRender );
		}
		else
		{
			RenderHitBox( pRender );
		}
	}

	if ( uiTool == DISPTOOL_PAINT_SCULPT )
	{
		m_SculptTool->RenderTool3D( pRender );
	}
}