1HEADmaster

1 files changed, 2161 insertions, 0 deletions

diff --git a/hammer/ToolMorph.cpp b/hammer/ToolMorph.cpp
new file mode 100644
index 0000000..75499f9
--- /dev/null
+++ b/hammer/ToolMorph.cpp
@@ -0,0 +1,2161 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "stdafx.h"
+#include "GlobalFunctions.h"
+#include "History.h"
+#include "materialsystem/imaterialsystem.h"
+#include "materialsystem/imesh.h"
+#include "MainFrm.h"
+#include "MapDefs.h"
+#include "MapDoc.h"
+#include "MapSolid.h"
+#include "MapView2D.h"
+#include "MapView3D.h"
+#include "Material.h"
+#include "ObjectProperties.h"
+#include "ToolManager.h"
+#include "ToolMorph.h"
+#include "Options.h"
+#include "Render2D.h"
+#include "StatusBarIDs.h"
+#include "hammer.h"
+#include "mathlib/vmatrix.h"
+#include "vgui/Cursor.h"
+#include "Selection.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback function to add objects to the morph selection.
+// Input  : pSolid - Solid to add.
+//			pMorph - Morph tool.
+// Output : Returns TRUE to continue enumerating.
+//-----------------------------------------------------------------------------
+static BOOL AddToMorph(CMapSolid *pSolid, Morph3D *pMorph)
+{
+	pMorph->SelectObject(pSolid, scSelect);
+	return TRUE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Morph3D::Morph3D(void)
+{
+	m_SelectedType = shtNothing;
+	m_HandleMode = hmBoth;
+	m_bBoxSelecting = false;
+	m_bScaling = false;
+	m_pOrigPosList = NULL;
+	
+	m_vLastMouseMovement.Init();
+
+	m_bHit = false;
+	m_bUpdateOrg = false;
+	m_bLButtonDownControlState = false;
+
+	SetDrawColors(Options.colors.clrToolHandle, Options.colors.clrToolMorph);
+
+	memset(&m_DragHandle, 0, sizeof(m_DragHandle));
+	m_bMorphing = false;
+	m_bMovingSelected = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Morph3D::~Morph3D(void)
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void Morph3D::OnActivate()
+{
+	if (IsActiveTool())
+	{
+		//
+		// Already active - change modes and redraw views.
+		//
+		ToggleMode();
+	}
+	else
+	{
+		//
+		// Put all selected objects into morph
+		//
+		const CMapObjectList *pSelection = m_pDocument->GetSelection()->GetList();
+		for (int i = 0; i < pSelection->Count(); i++)
+		{
+			CMapClass *pobj = pSelection->Element(i);
+			if (pobj->IsMapClass(MAPCLASS_TYPE(CMapSolid)))
+			{
+				SelectObject((CMapSolid *)pobj, scSelect);
+			}
+			pobj->EnumChildren((ENUMMAPCHILDRENPROC)AddToMorph, (DWORD)this, MAPCLASS_TYPE(CMapSolid));
+		}
+
+		m_pDocument->SelectObject(NULL, scClear|scSaveChanges );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Can we deactivate this tool.
+//-----------------------------------------------------------------------------
+bool Morph3D::CanDeactivate( void )
+{
+	return CanDeselectList();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the tool is deactivated.
+// Input  : eNewTool - The ID of the tool that is being activated.
+//-----------------------------------------------------------------------------
+void Morph3D::OnDeactivate()
+{
+	if (IsScaling())
+	{
+		OnScaleCmd();
+	}
+
+	if ( !IsEmpty() )
+	{
+		CUtlVector <CMapClass *>List;
+		GetMorphingObjects(List);
+
+		// Empty morph tool (Save contents).
+		SetEmpty();
+
+		//
+		// Select the solids that we were morphing.
+		//
+		int nObjectCount = List.Count();
+		for (int i = 0; i < nObjectCount; i++)
+		{
+			CMapClass *pSolid = List.Element(i);
+			CMapClass *pSelect = pSolid->PrepareSelection(m_pDocument->GetSelection()->GetMode());
+			if (pSelect)
+			{
+				m_pDocument->SelectObject(pSelect, scSelect);
+			}
+		}
+
+		m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if the given solid is being morphed, false if not.
+// Input  : pSolid - The solid.
+//			pStrucSolidRvl - The corresponding structured solid.
+//-----------------------------------------------------------------------------
+BOOL Morph3D::IsMorphing(CMapSolid *pSolid, CSSolid **pStrucSolidRvl)
+{
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pSSolid = m_StrucSolids.Element(pos);
+		if(pSSolid->m_pMapSolid == pSolid)
+		{
+			if(pStrucSolidRvl)
+				pStrucSolidRvl[0] = pSSolid;
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the bounding box of the objects being morphed.
+// Input  : bReset - 
+//-----------------------------------------------------------------------------
+void Morph3D::GetMorphBounds(Vector &mins, Vector &maxs, bool bReset)
+{
+	mins = m_MorphBounds.bmins;
+	maxs = m_MorphBounds.bmaxs;
+
+	if (bReset)
+	{
+		m_MorphBounds.ResetBounds();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Can we deslect the list?  All current SSolid with displacements 
+//          are valid.
+//-----------------------------------------------------------------------------
+bool Morph3D::CanDeselectList( void )
+{
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pSSolid = m_StrucSolids.Element( pos );
+		if ( pSSolid )
+		{
+			if ( !pSSolid->IsValidWithDisps() )
+			{
+				// Ask
+				if( AfxMessageBox( "Invalid solid, destroy displacement(s)?", MB_YESNO ) == IDYES )
+				{
+					// Destroy the displacement data.
+					pSSolid->DestroyDisps();
+				}
+				else
+				{
+					return false;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Selects a solid for vertex manipulation. An SSolid class is created
+//			and the CMapSolid is attached to it. The map solid is removed from
+//			the views, since it will be represented by the structured solid
+//			until vertex manipulation is finished.
+// Input  : pSolid - Map solid to select.
+//			cmd - scClear, scToggle, scUnselect
+//-----------------------------------------------------------------------------
+void Morph3D::SelectObject(CMapSolid *pSolid, UINT cmd)
+{
+	// construct temporary list to pass to document functions:
+	CMapObjectList List;
+	List.AddToTail( pSolid );
+
+	if( cmd & scClear )
+		SetEmpty();
+
+	CSSolid *pStrucSolid;
+	if ( IsMorphing( pSolid, &pStrucSolid ) )
+	{
+		if ( cmd & scToggle || cmd & scUnselect )
+		{
+			// stop morphing solid
+			Vector mins,maxs;
+			pSolid->GetRender2DBox(mins, maxs);
+			m_MorphBounds.UpdateBounds(mins, maxs);
+			pStrucSolid->Convert(FALSE);
+			pSolid->GetRender2DBox(mins, maxs);
+			m_MorphBounds.UpdateBounds(mins, maxs);
+
+			pStrucSolid->Detach();
+			m_pDocument->SetModifiedFlag();
+			
+			// want to draw in 2d views again
+			pSolid->SetVisible2D(true);
+
+			// remove from linked list
+			m_StrucSolids.FindAndRemove(pStrucSolid);
+			
+			// make sure none of its handles are selected
+			for(int i = m_SelectedHandles.Count()-1; i >=0; i--)
+			{
+				if(m_SelectedHandles[i].pStrucSolid == pStrucSolid)
+				{
+					m_SelectedHandles.Remove(i);
+				}
+			}
+
+			delete pStrucSolid;
+		
+			pSolid->SetSelectionState(SELECT_NONE);
+		}
+
+		return;
+	}
+
+	pStrucSolid = new CSSolid;
+	
+	// convert to structured solid
+	pStrucSolid->Attach(pSolid);
+	pStrucSolid->Convert();
+
+	pStrucSolid->ShowHandles(m_HandleMode & hmVertex, m_HandleMode & hmEdge);
+
+	// don't draw this solid in the 2D views anymore
+	pSolid->SetVisible2D(false);
+	pSolid->SetSelectionState(SELECT_MORPH);
+
+	// add to list of structured solids
+	m_StrucSolids.AddToTail(pStrucSolid);
+}
+
+
+int Morph3D::HitTest(CMapView *pView, const Vector2D &ptClient, bool bTestHandles )
+{
+	if (m_bBoxSelecting)
+	{
+		return Box3D::HitTest( pView, ptClient, bTestHandles);
+	}
+
+	return FALSE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CompareMorphHandles(const MORPHHANDLE &mh1, const MORPHHANDLE &mh2)
+{
+	return ((mh1.pMapSolid == mh2.pMapSolid) && 
+			(mh1.pStrucSolid == mh2.pStrucSolid) && 
+			(mh1.ssh == mh2.ssh));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether or not the given morph handle is selected.
+//-----------------------------------------------------------------------------
+bool Morph3D::IsSelected(MORPHHANDLE &mh)
+{
+	for (int i = 0; i < m_SelectedHandles.Count(); i++)
+	{
+		if (CompareMorphHandles(m_SelectedHandles[i], mh))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Hit tests against all the handles. Sets the mouse cursor if we are
+//			over a handle.
+// Input  : pt - 
+//			pInfo - 
+// Output : Returns TRUE if the mouse cursor is over a handle, FALSE if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::MorphHitTest(CMapView *pView, const Vector2D &vPoint, MORPHHANDLE *pInfo)
+{
+	SSHANDLE hnd = 0;
+
+	bool bIs2D = pView->IsOrthographic();
+
+	if ( pInfo )
+	{
+		memset(pInfo, 0, sizeof(MORPHHANDLE));
+	}
+
+	// check scaling position first
+	if ( bIs2D && m_bScaling && pInfo)
+	{
+		if ( HitRect( pView, vPoint, m_ScaleOrg, 8 )  )
+		{
+			pInfo->ssh = SSH_SCALEORIGIN;
+			return true;
+		}
+	}
+
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+
+		// do a hit test on all handles:
+		if (m_HandleMode & hmVertex)
+		{
+			for(int i = 0; i < pStrucSolid->m_nVertices; i++)
+			{
+				CSSVertex &v = pStrucSolid->m_Vertices[i];
+
+				if( HitRect( pView, vPoint, v.pos, HANDLE_RADIUS ) )
+				{
+					hnd = v.id;
+					break;
+				}
+			}
+		}
+
+		if (!hnd && (m_HandleMode & hmEdge))
+		{
+			for (int i = 0; i < pStrucSolid->m_nEdges; i++)
+			{
+				CSSEdge &e = pStrucSolid->m_Edges[i];
+
+				if( HitRect( pView, vPoint, e.ptCenter, HANDLE_RADIUS ) )
+				{
+					hnd = e.id;
+					break;
+				}
+			}
+		}
+
+		if (hnd)
+		{
+			if ( bIs2D )
+			{
+				SSHANDLEINFO hi;
+				pStrucSolid->GetHandleInfo(&hi, hnd);
+
+				// see if there is a 2d match that is already selected - if
+				//  there is, select that instead
+				SSHANDLE hMatch = Get2DMatches( dynamic_cast<CMapView2D*>(pView), pStrucSolid, hi);
+
+				if(hMatch)
+					hnd = hMatch;
+			}
+
+			if(pInfo)
+			{
+				pInfo->pMapSolid = pStrucSolid->m_pMapSolid;
+				pInfo->pStrucSolid = pStrucSolid;
+				pInfo->ssh = hnd;
+			}
+			break;
+		}
+	}
+
+	return hnd != 0;
+}
+
+void Morph3D::GetHandlePos(MORPHHANDLE *pInfo, Vector& pt)
+{
+	SSHANDLEINFO hi;
+	pInfo->pStrucSolid->GetHandleInfo(&hi, pInfo->ssh);
+	pt = hi.pos;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fills out a list of handles in the given solid that are at the same
+//			position as the given handle in the current 2D view.
+// Input  : pStrucSolid - 
+//			hi - 
+//			hAddSimilarList - 
+//			pnAddSimilar - 
+// Output : Returns a selected handle at the same position as the given handle,
+//			if one exists, otherwise returns 0.
+//-----------------------------------------------------------------------------
+SSHANDLE Morph3D::Get2DMatches( CMapView2D *pView, CSSolid *pStrucSolid, SSHANDLEINFO &hi, CUtlVector<SSHANDLE>*pSimilarList)
+{
+	SSHANDLE hNewMoveHandle = 0;
+
+	int axHorz = pView->axHorz;
+	int axVert = pView->axVert;
+
+	if(hi.Type == shtVertex)
+	{
+		for(int i = 0; i < pStrucSolid->m_nVertices; i++)
+		{
+			CSSVertex & v = pStrucSolid->m_Vertices[i];
+	
+			// YWB Fixme, scale olerance to zoom amount?
+			if( (fabs(hi.pos[axHorz] - v.pos[axHorz]) < 0.5) && 
+				(fabs(hi.pos[axVert] - v.pos[axVert]) < 0.5) )
+			{
+				if(v.m_bSelected)
+				{
+					hNewMoveHandle = v.id;
+				}
+
+				// add it to the array to select
+				if( pSimilarList )
+					pSimilarList->AddToTail(v.id);
+			}
+		}
+	}
+	else if(hi.Type == shtEdge)
+	{
+		for(int i = 0; i < pStrucSolid->m_nEdges; i++)
+		{
+			CSSEdge& e = pStrucSolid->m_Edges[i];
+	
+			if( (fabs(hi.pos[axHorz] - e.ptCenter[axHorz]) < 0.5) && 
+				(fabs(hi.pos[axVert] - e.ptCenter[axVert]) < 0.5) )
+			{
+				if(e.m_bSelected)
+				{
+					hNewMoveHandle = e.id;
+				}
+
+				//  add it to the array to select
+				if( pSimilarList )
+					pSimilarList->AddToTail(e.id);
+			}
+		}
+	}
+
+	return hNewMoveHandle;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Selects all the handles that are of the same type and at the same
+//			position in the current 2D projection as the given handle.
+// Input  : pInfo - 
+//			cmd - 
+// Output : Returns the number of handles that were selected by this call.
+//-----------------------------------------------------------------------------
+void Morph3D::SelectHandle2D( CMapView2D *pView, MORPHHANDLE *pInfo, UINT cmd)
+{
+	SSHANDLEINFO hi;
+
+	if ( !pInfo )
+		return;
+
+	if( pInfo->ssh == SSH_SCALEORIGIN )
+		return;
+	
+	if (!pInfo->pStrucSolid->GetHandleInfo(&hi, pInfo->ssh))
+	{
+		// Can't find the handle info, bail.
+		DeselectHandle(pInfo);
+		return;
+	}
+
+	//
+	// Check to see if there is a same type handle at the same
+	// 2d coordinates.
+	//
+	CUtlVector<SSHANDLE> addSimilarList;
+
+	Get2DMatches( pView, pInfo->pStrucSolid, hi, &addSimilarList );
+
+	for (int i = 0; i < addSimilarList.Count(); i++)
+	{
+		MORPHHANDLE mh;
+		mh.ssh = addSimilarList[i];
+		mh.pStrucSolid = pInfo->pStrucSolid;
+		mh.pMapSolid = pInfo->pStrucSolid->m_pMapSolid;
+
+		SelectHandle(&mh, cmd);
+
+		if (i == 0)
+		{
+			cmd &= ~scClear;
+		}
+	}
+
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+
+	return;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pInfo - 
+//-----------------------------------------------------------------------------
+void Morph3D::DeselectHandle(MORPHHANDLE *pInfo)
+{
+	for (int i = 0; i <m_SelectedHandles.Count(); i++)
+	{
+		if (!memcmp(&m_SelectedHandles[i], pInfo, sizeof(*pInfo)))
+		{
+			m_SelectedHandles.Remove(i);
+			break;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pInfo - 
+//			cmd - 
+//-----------------------------------------------------------------------------
+void Morph3D::SelectHandle(MORPHHANDLE *pInfo, UINT cmd)
+{
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+
+	if( pInfo && pInfo->ssh == SSH_SCALEORIGIN )
+		return;
+
+	if(cmd & scSelectAll)
+	{
+		MORPHHANDLE mh;
+
+		FOR_EACH_OBJ( m_StrucSolids, pos )
+		{	
+			CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+
+			for(int i = 0; i < pStrucSolid->m_nVertices; i++)
+			{
+				CSSVertex& v = pStrucSolid->m_Vertices[i];
+				mh.ssh = v.id;
+				mh.pStrucSolid = pStrucSolid;
+				mh.pMapSolid = pStrucSolid->m_pMapSolid;
+				SelectHandle(&mh, scSelect);
+			}
+		}
+
+		return;
+	}
+
+	if(cmd & scClear)
+	{
+		// clear handles first
+		while( m_SelectedHandles.Count()>0)
+		{
+			SelectHandle(&m_SelectedHandles[0], scUnselect);
+		}
+	}
+
+	if(cmd == scClear)
+	{
+		if(m_bScaling)
+			OnScaleCmd(TRUE);	// update scaling
+
+		return;	// nothing else to do here
+	}
+	
+	SSHANDLEINFO hi;
+	if (!pInfo->pStrucSolid->GetHandleInfo(&hi, pInfo->ssh))
+	{
+		// Can't find the handle info, bail.
+		DeselectHandle(pInfo);
+		return;
+	}
+
+	if(hi.Type != m_SelectedType)
+		SelectHandle(NULL, scClear);	// clear selection first
+
+	m_SelectedType = hi.Type;
+
+	bool bAlreadySelected = (hi.p2DHandle->m_bSelected == TRUE);
+	bool bChanged = false;
+
+	// toggle selection:
+	if(cmd & scToggle)
+	{
+		cmd &= ~scToggle;
+		cmd |= bAlreadySelected ? scUnselect : scSelect;
+	}
+
+	if(cmd & scSelect && !(hi.p2DHandle->m_bSelected))
+	{
+		hi.p2DHandle->m_bSelected = TRUE;
+		bChanged = true;
+	}
+	else if(cmd & scUnselect && hi.p2DHandle->m_bSelected)
+	{
+		hi.p2DHandle->m_bSelected = FALSE;
+		bChanged = true;
+	}
+
+	if(!bChanged)
+		return;
+
+	if(hi.p2DHandle->m_bSelected)
+	{
+		m_SelectedHandles.AddToTail(*pInfo);
+	}
+	else
+	{
+		DeselectHandle(pInfo);
+	}
+
+	if(m_bScaling)
+		OnScaleCmd(TRUE);
+}
+
+
+void Morph3D::MoveSelectedHandles(const Vector &Delta)
+{
+
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+		pStrucSolid->MoveSelectedHandles(Delta);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pRender - 
+//-----------------------------------------------------------------------------
+void Morph3D::RenderTool2D(CRender2D *pRender)
+{
+	pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );
+
+	for (int nPass = 0; nPass < 2; nPass++)
+	{
+
+		FOR_EACH_OBJ( m_StrucSolids, pos )
+		{
+			CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+
+			//
+			// Draw the edges.
+			//
+			for (int i = 0; i < pStrucSolid->m_nEdges; i++)
+			{
+				CSSEdge *pEdge = & pStrucSolid->m_Edges[i];
+
+				if (((pEdge->m_bSelected) && (nPass == 0)) ||
+					((!pEdge->m_bSelected) && (nPass == 1)))
+				{
+					continue;
+				}
+
+				pRender->SetDrawColor( 255, 0, 0 );
+
+				SSHANDLEINFO hi1;
+				SSHANDLEINFO hi2;
+				pStrucSolid->GetHandleInfo(&hi1, pEdge->hvStart);
+				pStrucSolid->GetHandleInfo(&hi2, pEdge->hvEnd);
+				
+				pRender->DrawLine(hi1.pos, hi2.pos);
+
+				if (!(m_HandleMode & hmEdge))
+				{
+					// Don't draw edge handles.
+					continue;
+				}
+
+				// Draw the edge center handle.
+												
+				if (pEdge->m_bSelected)
+				{
+					pRender->SetHandleColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) );
+				}
+				else
+				{
+					pRender->SetHandleColor( 255,255,0 ) ;
+				}
+
+				pRender->DrawHandle( pEdge->ptCenter );
+			}
+
+			if (!(m_HandleMode & hmVertex))
+			{
+				// Don't draw vertex handles.
+				continue;
+			}
+
+			//
+			// Draw vertex handles.
+			bool bClientSpace = pRender->BeginClientSpace();
+		
+			for (int i = 0; i < pStrucSolid->m_nVertices; i++)
+			{
+				CSSVertex &v = pStrucSolid->m_Vertices[i];
+
+				if (((v.m_bSelected) && (nPass == 0)) ||
+					((!v.m_bSelected) && (nPass == 1)))
+				{
+					continue;
+				}
+
+				if (v.m_bSelected)
+				{
+					pRender->SetHandleColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) );
+				}
+				else
+				{
+					pRender->SetHandleColor( GetRValue(Options.colors.clrToolHandle), GetGValue(Options.colors.clrToolHandle), GetBValue(Options.colors.clrToolHandle));
+				}
+
+				pRender->DrawHandle( v.pos );
+			}
+
+			if ( bClientSpace )
+				pRender->EndClientSpace();
+
+		}
+	}
+
+	//
+	// Draw scaling point.
+	//
+	if (m_bScaling && m_SelectedHandles.Count() )
+	{
+		pRender->SetHandleStyle( 8, CRender::HANDLE_CIRCLE );
+		pRender->SetHandleColor( GetRValue(Options.colors.clrToolHandle), GetGValue(Options.colors.clrToolHandle), GetBValue(Options.colors.clrToolHandle) );
+		pRender->DrawHandle( m_ScaleOrg );
+	}
+
+	if ( m_bBoxSelecting )
+	{
+		Box3D::RenderTool2D(pRender);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Finishes the morph, committing changes made to the selected objects.
+//-----------------------------------------------------------------------------
+void Morph3D::SetEmpty()
+{
+	GetHistory()->MarkUndoPosition(NULL, "Morphing");
+
+	while(m_StrucSolids.Count()>0)
+	{
+		// keep getting the head position because SelectObject (below)
+		//  removes the object from the list.
+		
+		CSSolid *pStrucSolid = m_StrucSolids[0];
+		
+		//
+		// Save this solid. BUT, before doing so, set it as visible in the 2D views.
+		// Otherwise, it will vanish if the user does an "Undo Morphing".
+		//
+		pStrucSolid->m_pMapSolid->SetVisible2D(true);
+		GetHistory()->Keep(pStrucSolid->m_pMapSolid);
+		pStrucSolid->m_pMapSolid->SetVisible2D(false);
+
+		// calling SelectObject with scUnselect SAVES the contents
+		//  of the morph.
+		SelectObject(pStrucSolid->m_pMapSolid, scUnselect);
+	}
+}
+
+
+// 3d translation --
+void Morph3D::StartTranslation( CMapView *pView, const Vector2D &vPoint, MORPHHANDLE *pInfo )
+{
+	if(m_bScaling)
+	{
+		// back to 1
+		m_bScaling = false;	// don't want it to update here
+		m_ScaleDlg.m_cScale.SetWindowText("1.0");
+		m_bScaling = true;
+	}
+
+	if(pInfo->ssh == SSH_SCALEORIGIN)
+		m_OrigHandlePos = m_ScaleOrg;
+	else
+
+		GetHandlePos(pInfo, m_OrigHandlePos);
+	
+	Vector vOrigin, vecHorz, vecVert, vecThird;
+	pView->GetBestTransformPlane( vecHorz, vecVert, vecThird );
+	SetTransformationPlane(  m_OrigHandlePos, vecHorz, vecVert, vecThird );
+
+	// align translation plane to world origin
+	ProjectOnTranslationPlane( vec3_origin, vOrigin, 0 );
+
+	// set transformation plane
+	SetTransformationPlane(vOrigin, vecHorz, vecVert, vecThird );
+
+	Tool3D::StartTranslation( pView, vPoint, false );
+
+	m_DragHandle = *pInfo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pt - 
+//			uFlags - 
+//			& - 
+// Output : Returns TRUE on success, FALSE on failure.
+//-----------------------------------------------------------------------------
+bool Morph3D::UpdateTranslation(const Vector &vUpdate, UINT uFlags)
+{
+	if (m_bBoxSelecting)
+	{
+		return Box3D::UpdateTranslation(vUpdate, uFlags);
+	}
+
+	if ( !Tool3D::UpdateTranslation( vUpdate, uFlags) )
+		return false;
+
+	bool bSnap =  uFlags & constrainSnap;
+	
+	if (m_DragHandle.ssh == SSH_SCALEORIGIN)
+	{
+		m_ScaleOrg = m_OrigHandlePos + vUpdate;
+
+		if (bSnap)
+		{
+			m_pDocument->Snap( m_ScaleOrg, uFlags );
+		}
+
+		m_bUpdateOrg = false;
+
+		return true;
+	}
+
+	//
+	// Get the current handle position.
+	//
+
+	Vector vCurPos;
+	GetHandlePos(&m_DragHandle, vCurPos);
+	
+	// We don't want to snap edge handles to the grid, because they don't
+	// necessarily belong on the grid in the first place.
+	if ( uFlags!=0 )
+	{
+		ProjectOnTranslationPlane( m_OrigHandlePos+m_vTranslation, m_vTranslation, uFlags );
+		m_vTranslation -= m_OrigHandlePos;
+	}
+
+	Vector vDelta = (m_OrigHandlePos+m_vTranslation)-vCurPos;
+
+	//
+	// Create delta and determine if it is large enough to warrant an update.
+	//
+
+	if ( vDelta.Length() < 0.5 )
+	{
+		return false;	// no need to update.
+	}
+
+	MoveSelectedHandles( vDelta );
+
+	return true;
+}
+
+bool Morph3D::StartBoxSelection(CMapView *pView, const Vector2D &vPoint, const Vector& vStart)
+{
+	m_bBoxSelecting = true;
+
+	SetDrawColors(RGB(255, 255, 255), RGB(50, 255, 255));
+
+	Box3D::StartNew( pView, vPoint, vStart, Vector(0,0,0) );
+
+	return true;
+}
+
+
+void Morph3D::SelectInBox()
+{
+	if(!m_bBoxSelecting)
+		return;
+
+	// select all vertices within the box, and finish box
+	//  selection.
+
+	EndBoxSelection();	// may as well do it here
+
+	// expand box along 0-depth axes
+	int countzero = 0;
+	for(int i = 0; i < 3; i++)
+	{
+		if(bmaxs[i] - bmins[i] == 0)
+		{
+			bmaxs[i] = COORD_NOTINIT;
+			bmins[i] = -COORD_NOTINIT;
+			countzero++;
+		}
+	}
+	if(countzero > 1)
+		return;
+
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{	
+		CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+
+		for(int i = 0; i < pStrucSolid->m_nVertices; i++)
+		{
+			CSSVertex& v = pStrucSolid->m_Vertices[i];
+			int i2;
+			for(i2 = 0; i2 < 3; i2++)
+			{
+				if(v.pos[i2] < bmins[i2] || v.pos[i2] > bmaxs[i2])
+					break;
+			}
+			
+			if(i2 == 3)
+			{
+				// completed loop - intersects - select handle
+				MORPHHANDLE mh;
+				mh.ssh = v.id;
+				mh.pStrucSolid = pStrucSolid;
+				mh.pMapSolid = pStrucSolid->m_pMapSolid;
+				SelectHandle(&mh, scSelect);
+			}
+		}
+	}
+}
+
+void Morph3D::EndBoxSelection()
+{
+	m_bBoxSelecting = false;
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bSave - 
+//-----------------------------------------------------------------------------
+void Morph3D::FinishTranslation(bool bSave)
+{
+	if (m_bBoxSelecting)
+	{
+		Box3D::FinishTranslation(bSave);
+		return;
+	}
+	else if (bSave && m_DragHandle.ssh != SSH_SCALEORIGIN)
+	{
+		// figure out all the affected solids
+		CUtlVector<CSSolid*> Affected;
+				
+		FOR_EACH_OBJ( m_StrucSolids, pos )
+		{
+			CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+			if(Affected.Find(pStrucSolid) == -1)
+				Affected.AddToTail(pStrucSolid);
+		}
+
+		int iConfirm = -1;
+		FOR_EACH_OBJ( Affected, pos )
+		{
+			CSSolid *pStrucSolid = Affected.Element(pos);
+			if(pStrucSolid->CanMergeVertices() && iConfirm != 0)
+			{
+				if(iConfirm == -1)
+				{
+					// ask
+					if(AfxMessageBox("Merge vertices?", MB_YESNO) == IDYES)
+						iConfirm = 1;
+					else
+						iConfirm = 0;
+				}
+				if(iConfirm == 1)
+				{
+					int nDeleted;
+					SSHANDLE *pDeleted = pStrucSolid->MergeSameVertices(nDeleted);
+					// ensure deleted handles are not marked
+					for(int i = 0; i < nDeleted; i++)
+					{
+						MORPHHANDLE mh;
+						mh.ssh = pDeleted[i];
+						mh.pStrucSolid = pStrucSolid;
+						mh.pMapSolid = pStrucSolid->m_pMapSolid;
+						SelectHandle(&mh, scUnselect);
+					}
+				}
+			}
+//			pStrucSolid->CheckFaces();
+		}
+	}
+
+	Tool3D::FinishTranslation(bSave);
+
+	if(!bSave)
+	{
+		// move back to original positions
+		Vector curpos;
+		GetHandlePos(&m_DragHandle, curpos);
+		MoveSelectedHandles(m_OrigHandlePos - curpos);
+	}
+	else if(m_bScaling)
+	{
+		OnScaleCmd(TRUE);
+	}
+}
+
+
+bool Morph3D::SplitFace()
+{
+	if(!CanSplitFace())
+		return false;
+
+	if(m_SelectedHandles[0].pStrucSolid->SplitFace(m_SelectedHandles[0].ssh,
+		m_SelectedHandles[1].ssh))
+	{
+		// unselect those invalid edges
+		if(m_SelectedType == shtVertex)
+		{
+			// proper deselection
+			SelectHandle(NULL, scClear);
+		}
+		else	// selection is invalid; set count to 0
+			m_SelectedHandles.RemoveAll();
+
+		m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_OBJECTS );
+
+		return false;
+	}
+
+	return true;
+}
+
+
+bool Morph3D::CanSplitFace()
+{
+	// along two edges.
+	if(m_SelectedHandles.Count() != 2 || (m_SelectedType != shtEdge && 
+		m_SelectedType != shtVertex))
+		return false;
+
+	// make sure same solid.
+	if(m_SelectedHandles[0].pStrucSolid != m_SelectedHandles[1].pStrucSolid)
+		return false;
+
+	return true;
+}
+
+
+void Morph3D::ToggleMode()
+{
+	if(m_HandleMode == hmBoth)
+		m_HandleMode = hmVertex;
+	else if(m_HandleMode == hmVertex)
+		m_HandleMode = hmEdge;
+	else
+		m_HandleMode = hmBoth;
+
+	// run through selected solids and tell them the new mode
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+		pStrucSolid->ShowHandles(m_HandleMode & hmVertex, m_HandleMode & hmEdge);
+	}
+
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the center of the morph selection.
+// Input  : pt - Point at the center of the selection or selected handles.
+//-----------------------------------------------------------------------------
+void Morph3D::GetSelectedCenter(Vector& pt)
+{
+	BoundBox box;
+
+	//
+	// If we have selected handles, our bounds center is the center of those handles.
+	//
+	if (m_SelectedHandles.Count() > 0)
+	{
+		SSHANDLEINFO hi;
+
+		for (int i = 0; i < m_SelectedHandles.Count(); i++)
+		{
+			MORPHHANDLE *mh = &m_SelectedHandles[i];
+			mh->pStrucSolid->GetHandleInfo(&hi, mh->ssh);
+
+			box.UpdateBounds(hi.pos);
+		}
+	}
+	//
+	// If no handles are selected, our bounds center is the center of all selected solids.
+	//
+	else
+	{
+		FOR_EACH_OBJ( m_StrucSolids, pos )
+		{
+			CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+			for (int nVertex = 0; nVertex < pStrucSolid->m_nVertices; nVertex++)
+			{
+				CSSVertex &v = pStrucSolid->m_Vertices[nVertex];
+				box.UpdateBounds(v.pos);
+			}
+		}
+	}
+
+	box.GetBoundsCenter(pt);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fills out a list of the objects selected for morphing.
+//-----------------------------------------------------------------------------
+void Morph3D::GetMorphingObjects(CUtlVector<CMapClass *> &List)
+{
+	FOR_EACH_OBJ( m_StrucSolids, pos )
+	{
+		CSSolid *pStrucSolid = m_StrucSolids.Element(pos);
+		List.AddToTail(pStrucSolid->m_pMapSolid);
+	}
+}
+
+
+void Morph3D::OnScaleCmd(BOOL bReInit)
+{
+	if(m_pOrigPosList)
+	{
+		delete[] m_pOrigPosList;
+		m_pOrigPosList = NULL;
+	}
+
+	if(m_bScaling && !bReInit)
+	{
+		m_ScaleDlg.ShowWindow(SW_HIDE);
+		m_ScaleDlg.DestroyWindow();
+		m_bScaling = false;
+		return;
+	}
+
+	// start scaling
+	if(!bReInit)
+	{
+		m_ScaleDlg.Create(IDD_SCALEVERTICES);
+		CPoint pt;
+		GetCursorPos(&pt);
+		m_bUpdateOrg = true;
+
+		m_ScaleDlg.SetWindowPos(NULL, pt.x, pt.y, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_SHOWWINDOW);
+	}
+	else
+	{
+		m_bScaling = false;	// don't want an update
+		m_ScaleDlg.m_cScale.SetWindowText("1.0");
+		m_bScaling = true;
+	}
+
+	if(m_SelectedHandles.Count()==0)
+	{
+		m_bScaling = true;
+		return;
+	}
+
+	m_pOrigPosList = new Vector[m_SelectedHandles.Count()];
+
+	BoundBox box;
+
+	// save original positions of vertices
+	for(int i = 0; i < m_SelectedHandles.Count(); i++)
+	{
+		MORPHHANDLE &hnd = m_SelectedHandles[i];
+		SSHANDLEINFO hi;
+		hnd.pStrucSolid->GetHandleInfo(&hi, hnd.ssh);
+
+		if(hi.Type != shtVertex)
+			continue;
+
+		m_pOrigPosList[i] = hi.pos;
+		box.UpdateBounds(hi.pos);
+	}
+
+	// center is default origin
+	if(m_bUpdateOrg)
+		box.GetBoundsCenter(m_ScaleOrg);
+
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+
+	m_bScaling = true;
+}
+
+
+void Morph3D::UpdateScale()
+{
+	// update scale with data in dialog box
+	if(!m_bScaling)
+		return;
+
+	float fScale = m_ScaleDlg.m_fScale;
+
+	// match up selected vertices to original position in m_pOrigPosList.
+	int iMoved = 0;
+	for(int i = 0; i < m_SelectedHandles.Count(); i++)
+	{
+		MORPHHANDLE &hnd = m_SelectedHandles[i];
+		SSHANDLEINFO hi;
+		hnd.pStrucSolid->GetHandleInfo(&hi, hnd.ssh);
+
+		if(hi.Type != shtVertex)
+			continue;
+
+		// ** scale **
+		Vector& pOrigPos = m_pOrigPosList[iMoved++];
+		Vector newpos;
+		for(int d = 0; d < 3; d++)
+		{
+			float delta = pOrigPos[d] - m_ScaleOrg[d];
+			// YWB rounding
+			newpos[d] = /*V_rint*/(m_ScaleOrg[d] + (delta * fScale));
+		}
+
+		hnd.pStrucSolid->SetVertexPosition(hi.iIndex, newpos[0], 
+			newpos[1], newpos[2]);
+
+		// find edge that references this vertex
+		int nEdges;
+		CSSEdge **pEdges = hnd.pStrucSolid->FindAffectedEdges(&hnd.ssh, 1, 
+			nEdges);
+		for(int e = 0; e < nEdges; e++)
+		{
+			hnd.pStrucSolid->CalcEdgeCenter(pEdges[e]);
+		}
+	}
+
+	m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders an object that is currently selected for morphing. The
+//			object is rendered in three passes:
+//
+//			1. Flat shaded grey with transparency.
+//			2. Wireframe in white.
+//			3. Edges and/or vertices are rendered as boxes.
+//
+// Input  : pSolid - The structured solid to render.
+//-----------------------------------------------------------------------------
+void Morph3D::RenderSolid3D(CRender3D *pRender, CSSolid *pSolid)
+{
+	VMatrix ViewMatrix;
+	Vector	ViewPos;
+	bool bClientSpace = false;
+	
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	for (int nPass = 1; nPass <= 3; nPass++)
+	{
+		if (nPass == 1)
+		{
+			pRender->PushRenderMode( RENDER_MODE_SELECTION_OVERLAY );
+		}
+		else if (nPass == 2)
+		{
+			pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
+		}
+		else
+		{
+			pRender->PushRenderMode( RENDER_MODE_FLAT_NOZ );
+			pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );
+			bClientSpace = pRender->BeginClientSpace();
+			pRender->GetCamera()->GetViewMatrix( ViewMatrix );
+		}
+
+		IMesh* pMesh = pRenderContext->GetDynamicMesh();
+		CMeshBuilder meshBuilder;
+
+		int nFaceCount = pSolid->GetFaceCount();
+		for (int nFace = 0; nFace < nFaceCount; nFace++)
+		{
+			CSSFace *pFace = pSolid->GetFace(nFace);
+
+			int nEdgeCount = pFace->GetEdgeCount();
+
+			unsigned char color[4];
+			if (nPass == 1)
+			{
+				meshBuilder.Begin( pMesh, MATERIAL_POLYGON, nEdgeCount );
+				color[0] = color[1] = color[2] = color[3] = 128; 
+			}
+			else if (nPass == 2)
+			{
+				meshBuilder.Begin( pMesh, MATERIAL_LINE_LOOP, nEdgeCount );
+				color[0] = color[1] = color[2] = color[3] = 255; 
+			}
+
+			for (int nEdge = 0; nEdge < nEdgeCount; nEdge++)
+			{
+				//
+				// Calc next edge so we can see which is the next clockwise point.
+				//
+				int nEdgeNext = nEdge + 1;
+				if (nEdgeNext == nEdgeCount)
+				{
+					nEdgeNext = 0;
+				}
+
+				SSHANDLE hEdge = pFace->GetEdgeHandle(nEdge);
+				CSSEdge *pEdgeCur = (CSSEdge *)pSolid->GetHandleData(hEdge);
+
+				SSHANDLE hEdgeNext = pFace->GetEdgeHandle(nEdgeNext);
+				CSSEdge *pEdgeNext = (CSSEdge *)pSolid->GetHandleData(hEdgeNext);
+
+				if (!pEdgeCur || !pEdgeNext)
+				{
+					return;
+				}
+
+				if ((nPass == 1) || (nPass == 2))
+				{
+					SSHANDLE hVertex = pSolid->GetConnectionVertex(pEdgeCur, pEdgeNext);
+
+					if (!hVertex)
+					{
+						return;
+					}
+
+					CSSVertex *pVertex = (CSSVertex *)pSolid->GetHandleData(hVertex);
+
+					if (!pVertex)
+					{
+						return;
+					}
+
+					Vector Vertex;
+					pVertex->GetPosition(Vertex);
+					meshBuilder.Position3f(Vertex[0], Vertex[1], Vertex[2]);
+					meshBuilder.Color4ubv( color );
+					meshBuilder.AdvanceVertex();
+				}
+				else
+				{
+					if (pSolid->ShowEdges())
+					{
+						//
+						// Project the edge midpoint into screen space.
+						//
+						Vector CenterPoint;
+						pEdgeCur->GetCenterPoint(CenterPoint);
+
+						ViewMatrix.V3Mul( CenterPoint, ViewPos );
+
+						if (ViewPos[2] < 0)
+						{
+							Vector2D ClientPos;
+							pRender->TransformPoint(ClientPos, CenterPoint);
+
+							pEdgeCur->m_bVisible = TRUE;
+							pEdgeCur->m_r.left = ClientPos.x - HANDLE_RADIUS;
+							pEdgeCur->m_r.top = ClientPos.y - HANDLE_RADIUS;
+							pEdgeCur->m_r.right = ClientPos.x + HANDLE_RADIUS + 1;
+							pEdgeCur->m_r.bottom = ClientPos.y + HANDLE_RADIUS + 1;
+
+							if (pEdgeCur->m_bSelected)
+							{
+								color[0] = 220; color[1] = color[2] = 0; color[3] = 255;
+							}
+							else
+							{
+								color[0] = color[1] = 255; color[2] = 0; color[3] = 255;
+
+							}
+
+							//
+							// Render the edge handle as a box.
+							//
+							pRender->SetHandleColor( color[0], color[1], color[2] );
+							pRender->DrawHandle( CenterPoint );
+						}
+						else
+						{
+							pEdgeCur->m_bVisible = FALSE;
+						}
+					}
+
+					if (pSolid->ShowVertices())
+					{
+						SSHANDLE hVertex = pSolid->GetConnectionVertex(pEdgeCur, pEdgeNext);
+						CSSVertex *pVertex = (CSSVertex *)pSolid->GetHandleData(hVertex);
+
+						//
+						// Project the vertex into screen space.
+						//
+						Vector vPoint;
+
+						pVertex->GetPosition(vPoint);
+
+						ViewMatrix.V3Mul( vPoint, ViewPos );
+						
+						if (ViewPos[2] < 0)
+						{
+							Vector2D ClientPos;
+							pRender->TransformPoint(ClientPos, vPoint);
+							
+							pVertex->m_bVisible = TRUE;
+							pVertex->m_r.left = ClientPos.x - HANDLE_RADIUS;
+							pVertex->m_r.top = ClientPos.y - HANDLE_RADIUS;
+							pVertex->m_r.right = ClientPos.x + HANDLE_RADIUS + 1;
+							pVertex->m_r.bottom = ClientPos.y + HANDLE_RADIUS + 1;
+
+							if (pVertex->m_bSelected)
+							{
+								color[0] = 220; color[1] = color[2] = 0; color[3] = 255;
+							}
+							else
+							{
+								color[0] = color[1] = color[2] = 255; color[3] = 255;
+							}
+
+							//
+							// Render the vertex as a box.
+							//
+							pRender->SetHandleColor( color[0], color[1], color[2] );
+							pRender->DrawHandle( vPoint );
+						}
+						else
+						{
+							pVertex->m_bVisible = FALSE;
+						}
+					}
+				}
+			}
+
+			if ((nPass == 1) || (nPass == 2))
+			{
+				meshBuilder.End();
+				pMesh->Draw();
+			}
+		}
+
+		if ( bClientSpace )
+		{
+			pRender->EndClientSpace();
+			bClientSpace = false;
+		}
+
+		pRender->PopRenderMode();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders a our selection bounds while we are drag-selecting.
+// Input  : pRender - Rendering interface.
+//-----------------------------------------------------------------------------
+void Morph3D::RenderTool3D(CRender3D *pRender)
+{
+	if (m_bBoxSelecting)
+	{
+		Box3D::RenderTool3D(pRender);
+	}
+
+	for( int pos=0; pos < m_StrucSolids.Count(); pos++ )
+	{
+		RenderSolid3D(pRender, m_StrucSolids[pos] );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles key down events in the 2D view.
+// Input  : Per CWnd::OnKeyDown.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnKeyDown2D(CMapView2D *pView, UINT nChar, UINT nRepCnt, UINT nFlags)
+{
+	bool bSnap = m_pDocument->IsSnapEnabled() && !(GetKeyState(VK_CONTROL) & 0x8000);
+	if (nChar == VK_UP || nChar == VK_DOWN || nChar == VK_LEFT || nChar == VK_RIGHT)
+	{
+		if ( NudgeHandles( pView, nChar, bSnap ) )
+			return true;
+	}
+
+	switch (nChar)
+	{
+		case VK_RETURN:
+		{
+			if ( IsBoxSelecting() )
+			{
+				SelectInBox();
+			}
+			break;
+		}
+
+		case VK_ESCAPE:
+		{
+			OnEscape();
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles character events in the 2D view.
+// Input  : Per CWnd::OnChar.
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnChar2D(CMapView2D *pView, UINT nChar, UINT nRepCnt, UINT nFlags)
+{
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles left mouse button down events in the 2D view.
+// Input  : Per CWnd::OnLButtonDown.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnLMouseDown2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	Tool3D::OnLMouseDown2D(pView, nFlags, vPoint);
+	
+	m_bLButtonDownControlState = (nFlags & MK_CONTROL) != 0;
+
+	m_vLastMouseMovement = vPoint;
+	
+	m_DragHandle.ssh = 0;
+
+	MORPHHANDLE mh;
+	if ( IsBoxSelecting() )
+	{
+		if ( HitTest( pView, vPoint, true ) )
+		{
+			Box3D::StartTranslation( pView, vPoint, m_LastHitTestHandle );
+		}
+	}
+	else if (MorphHitTest( pView, vPoint, &mh))
+	{
+		//
+		// If they clicked on a valid handle, remember which one. We may need it in
+		// left button up or mouse move messages.
+		//
+		m_DragHandle = mh;
+
+		if (!m_bLButtonDownControlState)
+		{
+			//
+			// If they are not holding down control and they clicked on an unselected
+			// handle, select the handle they clicked on straightaway.
+			//
+			if (!IsSelected(m_DragHandle))
+			{
+				// Clear the selected handles and select this handle.
+				UINT cmd = scClear | scSelect;
+				SelectHandle2D( pView, &m_DragHandle, cmd);
+			}
+		}
+	}
+	else
+	{
+		// Try to put another solid into morph mode.
+		SelectAt(pView, nFlags, vPoint);
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles left mouse button up events in the 2D view.
+// Input  : Per CWnd::OnLButtonUp.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnLMouseUp2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	Tool3D::OnLMouseUp2D(pView, nFlags, vPoint);
+
+	if (!IsTranslating())
+	{
+		if (m_DragHandle.ssh != 0)
+		{
+			//
+			// They clicked on a handle and released the left button without moving the mouse.
+			// Change the selection state of the handle that was clicked on.
+			//
+			UINT cmd = scClear | scSelect;
+			if (m_bLButtonDownControlState)
+			{
+				// Control-click: toggle.
+				cmd = scToggle;
+			}
+			SelectHandle2D( pView, &m_DragHandle, cmd);
+		}
+	}
+	else
+	{
+		//
+		// Dragging out a selection box or dragging the selected vertices.
+		//
+		FinishTranslation(true);
+
+		if (IsBoxSelecting() && Options.view2d.bAutoSelect)
+		{
+			SelectInBox();
+		}
+	}
+
+	m_pDocument->UpdateStatusbar();
+	
+	return true;
+}
+
+unsigned int Morph3D::GetConstraints(unsigned int nFlags)
+{
+	unsigned int uConstraints = Tool3D::GetConstraints(nFlags);
+
+	if ( !IsBoxSelecting() )
+	{
+		if ( nFlags & MK_CONTROL )
+			uConstraints |= constrainOnlyVert;
+
+		if ( nFlags & MK_SHIFT )
+			uConstraints |= constrainOnlyHorz;
+	}
+
+	return uConstraints;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles mouse move events in the 2D view.
+// Input  : Per CWnd::OnMouseMove.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnMouseMove2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	vgui::HCursor hCursor = vgui::dc_none;
+
+	unsigned int uConstraints = GetConstraints( nFlags ); 
+
+	Tool3D::OnMouseMove2D(pView, nFlags, vPoint);
+					    
+	// Convert to world coords.
+	
+	Vector vecWorld;
+	pView->ClientToWorld(vecWorld, vPoint);
+	
+	//
+	// Update status bar position display.
+	//
+	char szBuf[128];
+	m_pDocument->Snap(vecWorld,uConstraints);
+	sprintf(szBuf, " @%.0f, %.0f ", vecWorld[pView->axHorz], vecWorld[pView->axVert] );
+	SetStatusText(SBI_COORDS, szBuf);
+
+	if ( m_bMouseDown[MOUSE_LEFT] )
+	{
+		if ( IsTranslating() )
+		{
+			// If they are dragging a selection box or one or more handles, update
+			// the drag based on the cursor position.
+
+			Tool3D::UpdateTranslation( pView, vPoint, uConstraints );
+		}
+		else if ( m_bMouseDragged[MOUSE_LEFT] && m_DragHandle.ssh != 0 )
+		{
+			//
+			// If they are not already dragging a handle and they clicked on a valid handle,
+			// see if they have moved the mouse far enough to begin dragging the handle.
+			//
+			
+			if (m_bLButtonDownControlState && !IsSelected(m_DragHandle))
+			{
+				//
+				// If they control-clicked on an unselected handle and then dragged the mouse,
+				// select the handle that they clicked on now.
+				//
+				SelectHandle2D( pView, &m_DragHandle, scSelect);
+			}
+
+			StartTranslation( pView, m_vMouseStart[MOUSE_LEFT], &m_DragHandle );
+		}
+		else if ( m_bMouseDragged[MOUSE_LEFT] && !IsBoxSelecting() )
+		{
+			//
+			// Left dragging, didn't click on a handle, and we aren't yet dragging a
+			// selection box. Start dragging the selection box.
+			//
+			if (!(nFlags & MK_CONTROL))
+			{
+				SelectHandle(NULL, scClear);
+			}
+
+			Vector ptOrg;
+			pView->ClientToWorld(ptOrg, m_vMouseStart[MOUSE_LEFT] );
+
+			// set best third axis value
+			ptOrg[pView->axThird] = COORD_NOTINIT;
+			m_pDocument->GetBestVisiblePoint(ptOrg);
+			StartBoxSelection( pView, m_vMouseStart[MOUSE_LEFT], ptOrg);
+		}
+	}
+	else if (!IsEmpty())
+	{
+		//
+		// Left button is not down, just see what's under the cursor
+		// position to update the cursor.
+		//
+
+		hCursor = vgui::dc_arrow;
+
+		//
+		// Check to see if the mouse is over a vertex handle.
+		//
+
+		if (!IsBoxSelecting() && MorphHitTest( pView, vPoint, NULL))
+		{
+			hCursor = vgui::dc_crosshair;
+		}
+		//
+		// Check to see if the mouse is over a box handle.
+		//
+		else if ( HitTest(pView, vPoint, true) )
+		{
+			hCursor = UpdateCursor( pView, m_LastHitTestHandle, m_TranslateMode );
+		}
+	}
+	else
+	{
+		hCursor = vgui::dc_arrow;
+	}
+
+	if ( hCursor != vgui::dc_none  )
+		pView->SetCursor( hCursor );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles left mouse button down events in the 3D view.
+// Input  : Per CWnd::OnLButtonDown.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnLMouseDown3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	m_bHit = false;
+
+	Tool3D::OnLMouseDown3D(pView, nFlags, vPoint);
+
+	//
+	// Select morph handles?
+	//
+	MORPHHANDLE mh;
+	if ( MorphHitTest(pView, vPoint, &mh) )
+	{
+		m_bHit = true;
+		m_DragHandle = mh;
+		m_bMorphing = true;
+		m_vLastMouseMovement = vPoint;
+		m_bMovingSelected = false;	// not moving them yet - might just select this
+		StartTranslation( pView, vPoint, &m_DragHandle );
+		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));
+	}
+	else 
+	{ 
+		SelectAt( pView, nFlags, vPoint );
+	}
+
+	return true;
+}
+
+bool Morph3D::SelectAt( CMapView *pView, UINT nFlags, const Vector2D &vPoint )
+{
+	CMapClass *pMorphObject = NULL;
+	bool bUpdateView = false;
+	m_pDocument->GetSelection()->ClearHitList();
+	CMapObjectList SelectList;
+
+	// Find out how many (and what) map objects are under the point clicked on.
+
+	HitInfo_t Objects[MAX_PICK_HITS];
+	int nHits = pView->ObjectsAt( vPoint, Objects, sizeof(Objects) / sizeof(Objects[0]));
+	
+	// We now have an array of pointers to CMapAtoms. Any that can be upcast to CMapClass
+	// we add to a list of hits.
+	
+	for (int i = 0; i < nHits; i++)
+	{
+		CMapClass *pMapClass = dynamic_cast <CMapClass *>(Objects[i].pObject);
+		if (pMapClass != NULL)
+		{
+			SelectList.AddToTail(pMapClass);
+		}
+	}
+
+	//
+	// Actual selection occurs here.
+	//
+	if (!SelectList.Count())
+	{
+		//
+		// Clicked on nothing - clear selection.
+		//
+		pView->GetMapDoc()->SelectFace(NULL, 0, scClear);
+		pView->GetMapDoc()->SelectObject(NULL, scClear );
+		return false;
+	}
+
+	bool bFirst = true;
+	SelectMode_t eSelectMode = m_pDocument->GetSelection()->GetMode();
+
+	// Can we de-select objects?
+	if ( !CanDeselectList() )
+		return true;
+
+	FOR_EACH_OBJ( SelectList, pos )
+	{
+		CMapClass *pObject = SelectList.Element(pos);
+
+		// get hit object type and add it to the hit list
+		CMapClass *pHitObject = pObject->PrepareSelection( eSelectMode );
+		if (pHitObject)
+		{
+			m_pDocument->GetSelection()->AddHit( pHitObject );
+					
+			if (bFirst)
+			{
+				if (pObject->IsMapClass(MAPCLASS_TYPE(CMapSolid)))
+				{
+					CMapSolid *pSolid = (CMapSolid *)pObject;
+					
+					UINT cmd = scClear | scSelect;
+					if (nFlags & MK_CONTROL)
+					{
+						cmd = scToggle;
+					}
+					SelectObject(pSolid, cmd);
+					pMorphObject = pSolid;
+					bUpdateView = true;
+					break;
+				}
+			}
+		
+			bFirst = false;
+		}
+	}
+
+	// do we want to deselect all morphs?
+	if (!pMorphObject && !IsEmpty())
+	{
+		SetEmpty();
+		bUpdateView = true;
+	}
+
+	if (bUpdateView)
+	{
+		GetMainWnd()->pObjectProperties->MarkDataDirty();
+		m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_SELECTION );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles left mouse button up events in the 3D view.
+// Input  : Per CWnd::OnLButtonUp.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnLMouseUp3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	Tool3D::OnLMouseUp3D(pView, nFlags, vPoint);
+
+	if (m_bHit)
+	{
+		m_bHit = false;
+		UINT cmd = scClear | scSelect;
+		if (nFlags & MK_CONTROL)
+		{
+			cmd = scToggle;
+		}
+
+		SelectHandle(&m_DragHandle, cmd);
+	}
+
+	if (m_bMorphing)
+	{
+		FinishTranslation( true );
+		m_bMorphing = false;
+	}
+
+	ReleaseCapture();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Snap the selected handles to the grid
+// Input  : 
+//-----------------------------------------------------------------------------
+void Morph3D::SnapSelectedToGrid( int nGridSpacing )
+{
+	CUtlVector<MORPHHANDLE> vecHandles;
+	
+	if ( GetSelectedHandleCount() != 0 )
+	{
+		// Remember selected verts
+		vecHandles.AddVectorToTail( m_SelectedHandles );
+	}
+	else
+	{
+		// None selected.  Do nothing
+		return;
+	}
+
+	FOR_EACH_VEC( vecHandles, i )
+	{
+		// Set as sole-selection
+		SelectHandle( &vecHandles[i], scSelect | scClear );
+
+		// Get current position
+		Vector vCurPos;
+		SSHANDLEINFO hi;
+		vecHandles[i].pStrucSolid->GetHandleInfo(&hi, vecHandles[i].ssh);
+		vCurPos = hi.pos;
+
+		// Get snapped position
+		Vector vSnappedPos( V_rint(vCurPos[0] / nGridSpacing) * nGridSpacing,
+							V_rint(vCurPos[1] / nGridSpacing) * nGridSpacing,
+							V_rint(vCurPos[2] / nGridSpacing) * nGridSpacing );
+
+		// Get delta to move original position into snapped position
+		Vector vDelta = vSnappedPos - vCurPos;
+
+		// Move!
+		MoveSelectedHandles( vDelta );
+	}
+
+	// Re-select all the handles
+	SelectHandle( NULL, scClear );
+	FOR_EACH_VEC( vecHandles, i )
+	{
+		SelectHandle( &vecHandles[i], scSelect );
+	}
+
+	FinishTranslation( true );
+	m_pDocument->SetModifiedFlag();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : axes - 
+//			nChar - 
+//			bSnap - 
+//-----------------------------------------------------------------------------
+bool Morph3D::NudgeHandles(CMapView *pView, UINT nChar, bool bSnap)
+{
+	if ( GetSelectedHandleCount() < 1 || !Options.view2d.bNudge )
+		return false;
+
+	Vector vecDelta, vHorz, vVert, vThrd;
+	pView->GetBestTransformPlane( vHorz, vVert, vThrd );
+	m_pDocument->GetNudgeVector( vHorz, vVert,  nChar, bSnap, vecDelta);
+
+	if ( bSnap && (GetSelectedHandleCount() == 1) && (GetSelectedType() == shtVertex))
+	{
+		// we have one vertex selected, so make sure
+		// it's going to snap to grid.
+		Vector pos;	GetSelectedCenter(pos);
+
+		SetTransformationPlane( pos, vHorz, vVert, vThrd );
+
+		// calculate new delta
+		ProjectOnTranslationPlane( pos + vecDelta, vecDelta, constrainSnap );
+		vecDelta -= pos;
+	}
+
+	MoveSelectedHandles(vecDelta);
+	FinishTranslation( true );	// force checking for merges
+
+	m_pDocument->SetModifiedFlag();
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles the key down event in the 3D view.
+// Input  : Per CWnd::OnKeyDown.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnKeyDown3D(CMapView3D *pView, UINT nChar, UINT nRepCnt, UINT nFlags)
+{
+	bool bSnap = m_pDocument->IsSnapEnabled() && !(GetAsyncKeyState(VK_CONTROL) & 0x8000);
+
+	switch (nChar)
+	{	
+		case VK_ESCAPE:
+		{
+			OnEscape();
+			return true;
+		}
+
+		case VK_UP :
+		case VK_DOWN :
+		case VK_LEFT :
+		case VK_RIGHT :
+			{
+				if ( NudgeHandles( pView, nChar, bSnap ) )
+					return true;
+			}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles the escape key in the 2D or 3D views.
+//-----------------------------------------------------------------------------
+void Morph3D::OnEscape(void)
+{
+	//
+	// If we're box selecting with the morph tool, stop.
+	//
+	if ( IsBoxSelecting() )
+	{
+		EndBoxSelection();
+	}
+	//
+	// If we have handle(s) selected, deselect them.
+	//
+	else if (!IsEmpty() && (GetSelectedHandleCount() != 0))
+	{
+		SelectHandle(NULL, scClear);
+	}
+	//
+	// Stop using the morph tool.
+	//
+	else
+	{
+		ToolManager()->SetTool(TOOL_POINTER);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles the move move event in the 3D view.
+// Input  : Per CWnd::OnMouseMove.
+// Output : Returns true if the message was handled, false if not.
+//-----------------------------------------------------------------------------
+bool Morph3D::OnMouseMove3D(CMapView3D *pView, UINT nFlags, const Vector2D &vPoint)
+{
+	Tool3D::OnMouseMove3D(pView, nFlags, vPoint);
+
+	if (m_bMorphing)
+	{
+		//
+		// Check distance moved since left button down and don't start
+		// moving unless it's greater than the threshold.
+		//
+		if (!m_bMovingSelected)
+		{
+			Vector2D sizeMoved = vPoint - m_vLastMouseMovement;
+			if ((abs(sizeMoved.x) > 3) || (abs(sizeMoved.y) > 3))
+			{
+				m_bMovingSelected = true;
+
+				if (m_bHit)
+				{
+					m_bHit = false;
+					SSHANDLEINFO hi;
+					m_DragHandle.pStrucSolid->GetHandleInfo(&hi, m_DragHandle.ssh);
+					unsigned uSelFlags = scSelect;
+
+					if (!(nFlags & MK_CONTROL) && !hi.p2DHandle->m_bSelected)
+					{
+						uSelFlags |= scClear;
+					}
+
+					SelectHandle(&m_DragHandle, uSelFlags);
+				}
+			}
+			else
+			{
+				return true;
+			}
+		}
+
+		unsigned int uConstraints = GetConstraints( nFlags ); 
+
+		Tool3D::UpdateTranslation( pView, vPoint, uConstraints );
+
+		m_vLastMouseMovement = vPoint;
+	}
+	else if ( MorphHitTest(pView, vPoint, NULL ))
+	{
+		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));
+	}
+	else
+	{
+		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
+	}
+
+	return true;
+}
\ No newline at end of file