1HEADmaster

1 files changed, 2477 insertions, 0 deletions

diff --git a/hammer/dispmapimagefilter.cpp b/hammer/dispmapimagefilter.cpp
new file mode 100644
index 0000000..bdd6743
--- /dev/null
+++ b/hammer/dispmapimagefilter.cpp
@@ -0,0 +1,2477 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+//=============================================================================
+//
+// NOTE: the painting code in here needs to be cleaned up and a new algorithm
+//       is needed for handling valence greater than 4 cases (I am not too happy
+//       with the current one)
+//
+
+#include <stdafx.h>
+#include "MapDisp.h"
+#include "DispSew.h"
+#include "ChunkFile.h"
+#include "GlobalFunctions.h"
+#include "ToolDisplace.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+#define NULL_VALUE   -99999.0f
+
+//=============================================================================
+//
+// Displacement Image Filter Functions
+//
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CDispMapImageFilter::CDispMapImageFilter()
+{
+	m_Type = (unsigned int)-1;
+	m_DataType = -1;
+
+	m_Height = 0;
+	m_Width = 0;
+	m_pImage = NULL;
+
+	m_Scale = 1.0f;
+	m_AreaHeight = 0;
+	m_AreaWidth = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CDispMapImageFilter::~CDispMapImageFilter()
+{
+	// de-allocate displacement image memory
+	if( m_pImage )
+	{
+		delete [] m_pImage;
+		m_pImage = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilter::GetFilterType( CString type )
+{
+	if( type == "FILTER_ADD" ) { return DISPPAINT_EFFECT_RAISELOWER; }
+	if( type == "FILTER_MULT" ) { return DISPPAINT_EFFECT_MODULATE; }
+	if( type == "FILTER_CONVATTEN" ) { return DISPPAINT_EFFECT_SMOOTH; }
+	if( type == "FILTER_EQUAL" ) { return DISPPAINT_EFFECT_RAISETO; }
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CDispMapImageFilter::LoadImageCallback( CChunkFile *pFile, 
+														  CDispMapImageFilter *pFilter )
+{
+	return( pFile->ReadChunk( ( KeyHandler_t )LoadImageKeyCallback, pFilter ) );
+}
+
+static bool bInitMemory = true;
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CDispMapImageFilter::LoadImageKeyCallback( const char *szKey, const char *szValue,
+															 CDispMapImageFilter *pFilter )
+{
+	//
+	// allocate filter image memory
+	//
+	if( bInitMemory )
+	{
+		int size = pFilter->m_Height * pFilter->m_Width;
+		pFilter->m_pImage = new float[size+1];
+		if( !pFilter->m_pImage )
+			return( ChunkFile_Fail );
+
+		bInitMemory = false;
+	}
+
+	if( !strnicmp( szKey, "row", 3 ) )
+	{
+		char szBuf[MAX_KEYVALUE_LEN];
+		strcpy( szBuf, szValue );
+
+		int row = atoi( &szKey[3] );
+
+		char *pszNext = strtok( szBuf, " " );
+
+		int ndx = row * pFilter->m_Height;
+		while( pszNext != NULL )
+		{
+			float imageValue = ( float )atof( pszNext );
+			pFilter->m_pImage[ndx] = imageValue;
+			pszNext = strtok( NULL, " " );
+			ndx++;
+		}
+	}
+
+	return( ChunkFile_Ok );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilter::ValidHeight( int height )
+{
+	if( ( height < 1 ) || ( height > 9 ) )
+	{
+		Msg( mwError, "Filter height is out of range - %d\n", height );
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilter::ValidWidth( int width )
+{
+	if( ( width < 1 ) || ( width > 9 ) )
+	{
+		Msg( mwError, "Filter width is out of range - %d\n", width );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CDispMapImageFilter::LoadFilterKeyCallback( const char *szKey, const char *szValue,
+															  CDispMapImageFilter *pFilter )
+{
+	if( !stricmp( szKey, "Height" ) )
+	{
+		CChunkFile::ReadKeyValueInt( szValue, pFilter->m_Height );
+		ValidHeight( pFilter->m_Height );
+	}
+	else if( !stricmp( szKey, "Width" ) )
+	{
+		CChunkFile::ReadKeyValueInt( szValue, pFilter->m_Width );
+		ValidWidth( pFilter->m_Width );
+	}
+	else if( !stricmp( szKey, "FilterType" ) )
+	{
+		CString strFilterType = szValue;
+		pFilter->m_Type = GetFilterType( strFilterType );
+	}
+	else if( !stricmp( szKey, "IconName" ) )
+	{
+		pFilter->m_Name = szValue;
+	}
+
+	return( ChunkFile_Ok );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CDispMapImageFilter::LoadFilter( CChunkFile *pFile )
+{
+	bInitMemory = true;
+
+	CChunkHandlerMap Handlers;
+	Handlers.AddHandler( "Image", ( ChunkHandler_t )LoadImageCallback, this );
+
+	pFile->PushHandlers( &Handlers );
+	ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadFilterKeyCallback, this );
+	pFile->PopHandlers();
+
+	return( eResult );
+}
+
+
+//=============================================================================
+//
+// Displacement Filter Manager Functions
+//
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CDispMapImageFilterManager::CDispMapImageFilterManager()
+{
+	m_FilterCount = 0;
+	m_ActiveFilter = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::AddFilterToList( CDispMapImageFilter *pFilter )
+{
+	// don't allow overflow! -- should be an error message here!!!
+	if( m_FilterCount >= FILTERLIST_SIZE )
+		return;
+
+	m_pFilterList[m_FilterCount] = pFilter;
+	m_FilterCount++;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CDispMapImageFilter *CDispMapImageFilterManager::Create( void )
+{
+	// allocate filter
+	CDispMapImageFilter *pFilter = new CDispMapImageFilter;
+	if( !pFilter )
+		return NULL;
+
+	// add filter to list
+	AddFilterToList( pFilter );
+
+	return pFilter;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::Add( CDispMapImageFilter *pFilter )
+{
+	AddFilterToList( pFilter );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::Destroy( void )
+{
+	for( int i = 0; i < m_FilterCount; i++ )
+	{
+		// get the current filter
+		CDispMapImageFilter *pFilter = GetFilter( i );
+		if( !pFilter )
+			continue;
+
+		delete pFilter;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+inline void CDispMapImageFilterManager::SetImageValue( CMapDisp *pDisp, CDispMapImageFilter *pFilter,
+													   int ndxDisp, Vector &vPaintValue )
+{
+	pDisp->Paint_SetValue( ndxDisp, vPaintValue );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+inline void CDispMapImageFilterManager::GetImageValue( CMapDisp *pDisp, CDispMapImageFilter *pFilter,
+													   int ndxDisp, Vector &vPaintValue )
+{
+	if( pFilter->m_DataType == DISPPAINT_CHANNEL_POSITION )
+	{
+		pDisp->GetVert( ndxDisp, vPaintValue );
+	}
+	else if( pFilter->m_DataType == DISPPAINT_CHANNEL_ALPHA )
+	{
+		float alpha = pDisp->GetAlpha( ndxDisp );
+		vPaintValue.Init( alpha, 0.0f, 0.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+inline void CDispMapImageFilterManager::GetImageFlatSubdivValue( CMapDisp *pDisp, CDispMapImageFilter *pFilter,
+													             int ndxDisp, Vector &vPaintValue )
+{
+	if( pFilter->m_DataType == DISPPAINT_CHANNEL_POSITION )
+	{
+		Vector vSPos;
+		pDisp->GetFlatVert( ndxDisp, vPaintValue );
+		pDisp->GetSubdivPosition( ndxDisp, vSPos );
+		vPaintValue += vSPos;
+	}
+	else if( pFilter->m_DataType == DISPPAINT_CHANNEL_ALPHA )
+	{
+		vPaintValue.Init( 0.0f, 0.0f, 0.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+inline void CDispMapImageFilterManager::GetImageFieldData( CMapDisp *pDisp, CDispMapImageFilter *pFilter,
+														   int ndxDisp, Vector &vNormal, float &dist )
+{
+	if( pFilter->m_DataType == DISPPAINT_CHANNEL_POSITION )
+	{
+		pDisp->GetFieldVector( ndxDisp, vNormal );
+		dist = pDisp->GetFieldDistance( ndxDisp );
+	}
+	else if( pFilter->m_DataType == DISPPAINT_CHANNEL_ALPHA )
+	{
+		vNormal.Init( 0.0f, 0.0f, 0.0f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::PreApply( CDispMapImageFilter *pFilter,
+										   int nPaintDirType, const Vector &vecPaintDir )
+{
+	// Save the paint type and direction locally.
+	m_PaintType = nPaintDirType;
+	m_PaintDir = vecPaintDir;
+
+	// Get the displacement manager from the active map document.
+	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+	if( !pDispMgr )
+		return false;
+
+	// Get the displacements in the selection set.
+	int nDispCount = pDispMgr->SelectCount();
+	for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
+	{
+		CMapDisp *pDisp = pDispMgr->GetFromSelect( iDisp );
+		if ( pDisp )
+		{
+			pDisp->Paint_Init( pFilter->m_DataType );
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::PostApply( bool bSew )
+{
+	// Get the displacement manager from the active map document.
+	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+	if( !pDispMgr )
+		return false;
+
+	// Get the displacements in the selection set.
+	int nDispCount = pDispMgr->SelectCount();
+	for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
+	{
+		CMapDisp *pDisp = pDispMgr->GetFromSelect( iDisp );
+		if ( pDisp )
+		{
+			pDisp->Paint_Update( false );
+		}
+	}
+
+	// Sew all surfaces post painting.
+	if( bSew )
+	{
+		FaceListSewEdges();
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::Apply( CDispMapImageFilter *pFilter, CMapDisp *pDisp, 
+									    int paintDirType, Vector const &vPaintDir, bool bSew )
+{
+	// Get the index of the vertex on the displacement surface "hit."
+	int iVert = pDisp->GetTexelHitIndex();
+	if( iVert == -1 )
+		return false;
+
+	if ( !PreApply( pFilter, paintDirType, vPaintDir ) )
+		return false;
+
+	// Apply the filter to the given displacement at the impacted vertex index.
+	ApplyAt( pFilter, pDisp, iVert );
+
+	if ( !PostApply( bSew ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ApplyAt( CDispMapImageFilter *pFilter, CMapDisp *pDisp,
+								          int ndxVert )
+{
+    // Apply filter appropriately type.
+    switch( pFilter->m_Type )
+    {
+    case DISPPAINT_EFFECT_RAISELOWER:
+		{
+			ApplyAddFilter( pFilter, pDisp, ndxVert );
+			return;
+		}
+    case DISPPAINT_EFFECT_MODULATE:
+		{
+			ApplyMultFilter( pFilter, pDisp, ndxVert );
+		    return;
+		}
+    case DISPPAINT_EFFECT_SMOOTH:
+		{
+			ApplySmoothFilter( pFilter, pDisp, ndxVert );
+			return;
+		}
+	case DISPPAINT_EFFECT_RAISETO:
+		{
+			ApplyEqualFilter( pFilter, pDisp, ndxVert );
+			return;
+		}
+    default:
+		{
+	        return;
+		}
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::IsNeighborInSelectionSet( CMapDisp *pNeighborDisp )
+{
+	// Get the displacement manager from the active map document.
+	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+	if( !pDispMgr )
+		return false;
+
+	// Get the displacements in the selection set.
+	int nDispCount = pDispMgr->SelectCount();
+	for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
+	{
+		CMapDisp *pDisp = pDispMgr->GetFromSelect( iDisp );
+		if ( pDisp == pNeighborDisp )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::HitData_Init( PosHitData_t &hitData )
+{
+	hitData.m_CornerCount = 0;
+	hitData.m_ndxCorners[0] = hitData.m_ndxCorners[1] = -1;
+	hitData.m_EdgeCount = 0;
+	hitData.m_ndxEdges[0] = hitData.m_ndxEdges[1] = -1;
+	hitData.m_bMain = false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::HitData_Setup( PosHitData_t &hitData, 
+											    int ndxHgt, int ndxWid, 
+												int imgHgt, int imgWid )
+{
+	// reset the hit data
+	HitData_Init( hitData );
+
+	//
+	// corners
+	//
+
+	// southwest
+	if( ( ndxHgt <= 0.0f ) && ( ndxWid <= 0.0f ) )
+	{
+		hitData.m_ndxCorners[hitData.m_CornerCount] = IMAGEFILTER_SOUTHWEST;
+		hitData.m_CornerCount++;
+	}
+
+	// northwest
+	if( ( ndxHgt >= ( imgHgt - 1 ) ) && ( ndxWid <= 0.0f ) )
+	{
+		hitData.m_ndxCorners[hitData.m_CornerCount] = IMAGEFILTER_NORTHWEST;
+		hitData.m_CornerCount++;
+	}
+
+	// northeast
+	if( ( ndxHgt >= ( imgHgt - 1 ) ) && ( ndxWid >= ( imgWid - 1 ) ) )
+	{
+		hitData.m_ndxCorners[hitData.m_CornerCount] = IMAGEFILTER_NORTHEAST;
+		hitData.m_CornerCount++;
+	}
+
+	// southeast
+	if( ( ndxHgt <= 0.0f ) && ( ndxWid >= ( imgWid - 1 ) ) )
+	{
+		hitData.m_ndxCorners[hitData.m_CornerCount] = IMAGEFILTER_SOUTHEAST;
+		hitData.m_CornerCount++;
+	}
+
+	//
+	// edges "images"
+	//
+
+	// west
+	if( ( ndxHgt >= 0.0f ) && ( ndxHgt <= ( imgHgt - 1 ) ) && ( ndxWid <= 0.0f ) )
+	{
+		hitData.m_ndxEdges[hitData.m_EdgeCount] = IMAGEFILTER_WEST;
+		hitData.m_EdgeCount++;
+	}
+
+	// north
+	if( ( ndxHgt >= ( imgHgt - 1 ) ) && ( ndxWid >= 0.0f ) && ( ndxWid <= ( imgWid - 1 ) ) )
+	{
+		hitData.m_ndxEdges[hitData.m_EdgeCount] = IMAGEFILTER_NORTH;
+		hitData.m_EdgeCount++;
+	}
+
+	// east
+	if( ( ndxHgt >= 0.0f ) && ( ndxHgt <= ( imgHgt - 1 ) ) && ( ndxWid >= ( imgWid - 1 ) ) )
+	{
+		hitData.m_ndxEdges[hitData.m_EdgeCount] = IMAGEFILTER_EAST;
+		hitData.m_EdgeCount++;
+	}
+
+	// south
+	if( ( ndxHgt <= 0.0f ) && ( ndxWid >= 0.0f ) && ( ndxWid <= ( imgWid - 1 ) ) )
+	{
+		hitData.m_ndxEdges[hitData.m_EdgeCount] = IMAGEFILTER_SOUTH;
+		hitData.m_EdgeCount++;
+	}
+
+	//
+	// main "image"
+	//
+	if( ( ndxHgt >= 0.0f ) && ( ndxHgt < imgHgt ) && ( ndxWid >= 0.0f ) && ( ndxWid < imgWid ) )
+	{
+		hitData.m_bMain = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetCornerImageCount( CMapDisp *pDisp, int ndxCorner )
+{
+	switch( ndxCorner )
+	{
+	case IMAGEFILTER_SOUTHWEST: { return pDisp->GetCornerNeighborCount( 0 ); }
+	case IMAGEFILTER_NORTHWEST: { return pDisp->GetCornerNeighborCount( 2 ); }
+	case IMAGEFILTER_NORTHEAST: { return pDisp->GetCornerNeighborCount( 3 ); }
+	case IMAGEFILTER_SOUTHEAST: { return pDisp->GetCornerNeighborCount( 1 ); }
+	default: { return -1; }
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+CMapDisp *CDispMapImageFilterManager::GetImage( CDispMapImageFilter *pFilter,
+											    CMapDisp *pDisp, int ndxHgt, int ndxWid,
+												int ndxImg, int imgCount, int &orient )
+{
+	CMapDisp *pNeighborDisp = NULL;
+	EditDispHandle_t neighborHandle;
+
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST: 
+		{
+			int count = pDisp->GetCornerNeighborCount( 0 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 0, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+					}
+					return pNeighborDisp;
+				}			
+			}
+
+			return NULL;
+		}
+	case IMAGEFILTER_WEST: 
+		{
+			pDisp->GetEdgeNeighbor( 0, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+			}
+			return pNeighborDisp;
+		}
+	case IMAGEFILTER_NORTHWEST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 2 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 2, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+					}
+					return pNeighborDisp;
+				}			
+			}
+
+			return NULL;
+		}
+	case IMAGEFILTER_NORTH: 
+		{
+			pDisp->GetEdgeNeighbor( 1, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+			}
+			return pNeighborDisp;
+		}
+	case IMAGEFILTER_NORTHEAST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 3 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 3, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+					}
+					return pNeighborDisp;
+				}			
+			}
+
+			return NULL;
+		}
+	case IMAGEFILTER_EAST: 
+		{ 
+			pDisp->GetEdgeNeighbor( 2, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+			}
+			return pNeighborDisp;
+		}
+	case IMAGEFILTER_SOUTHEAST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 1 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 1, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+					}
+					return pNeighborDisp;
+				}			
+			}
+
+			return NULL;
+		}
+	case IMAGEFILTER_SOUTH: 
+		{ 
+			pDisp->GetEdgeNeighbor( 3, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+			}
+			return pNeighborDisp;
+		}
+	case IMAGEFILTER_MAIN: 
+		{ 
+			return pDisp;
+		}
+	default: 
+		{ 
+			return NULL; 
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::GetImageFieldValues( CDispMapImageFilter *pFilter,
+									                  CMapDisp *pDisp, int ndxHgt, int ndxWid,
+										              int ndxImg, int imgCount,
+													  Vector &vNormal, float &dist )
+{
+	//
+	// get the image (displacement) given a position
+	//
+	int orient;
+	CMapDisp *pNeighborDisp = GetImage( pFilter, pDisp, ndxHgt, ndxWid, ndxImg, imgCount, orient );
+	if( !pNeighborDisp )
+		return false;
+
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST:
+		{
+			int ndx = GetSWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_WEST:
+		{
+			int ndx = GetWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_NORTHWEST:
+		{
+			int ndx = GetNWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_NORTH:
+		{
+			int ndx = GetNImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_NORTHEAST:
+		{
+			int ndx = GetNEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_EAST:
+		{
+			int ndx = GetEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_SOUTHEAST:
+		{
+			int ndx = GetSEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_SOUTH:
+		{
+			int ndx = GetSImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFieldData( pNeighborDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	case IMAGEFILTER_MAIN:
+		{
+			int ndx = ndxHgt * pDisp->GetWidth() + ndxWid;
+			GetImageFieldData( pDisp, pFilter, ndx, vNormal, dist );
+			return true;
+		}
+	default: { return false; }
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::GetImageFlatSubdivValues( CDispMapImageFilter *pFilter,
+									                       CMapDisp *pDisp, int ndxHgt, int ndxWid,
+										                   int ndxImg, int imgCount, Vector &value )
+{
+	//
+	// get the image (displacement) given a position
+	//
+	int orient;
+	CMapDisp *pNeighborDisp = GetImage( pFilter, pDisp, ndxHgt, ndxWid, ndxImg, imgCount, orient );
+	if( !pNeighborDisp )
+		return false;
+
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST:
+		{
+			int ndx = GetSWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_WEST:
+		{
+			int ndx = GetWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_NORTHWEST:
+		{
+			int ndx = GetNWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_NORTH:
+		{
+			int ndx = GetNImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_NORTHEAST:
+		{
+			int ndx = GetNEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_EAST:
+		{
+			int ndx = GetEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_SOUTHEAST:
+		{
+			int ndx = GetSEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_SOUTH:
+		{
+			int ndx = GetSImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+			GetImageFlatSubdivValue( pNeighborDisp, pFilter, ndx, value );
+			return true;
+		}
+	case IMAGEFILTER_MAIN:
+		{
+			int ndx = ndxHgt * pDisp->GetWidth() + ndxWid;
+			GetImageFlatSubdivValue( pDisp, pFilter, ndx, value );
+			return true;
+		}
+	default: { return false; }
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::GetImageValues( CDispMapImageFilter *pFilter,
+									             CMapDisp *pDisp, int ndxHgt, int ndxWid,
+										         int ndxImg, int imgCount, Vector &value )
+{
+	// Get the image (displacement) given a position
+	int orient;
+	CMapDisp *pNeighborDisp = GetImage( pFilter, pDisp, ndxHgt, ndxWid, ndxImg, imgCount, orient );
+	if( !pNeighborDisp || !IsNeighborInSelectionSet( pNeighborDisp ) )
+		return false;
+
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST: { SWImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_WEST: { WImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_NORTHWEST: { NWImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_NORTH: { NImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_NORTHEAST: { NEImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_EAST: { EImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_SOUTHEAST: { SEImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_SOUTH: { SImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, false, value ); return true; }
+	case IMAGEFILTER_MAIN: { MainImageValue( pFilter, pDisp, ndxHgt, ndxWid, false, value ); return true; }
+	default: { return false; }
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetAdjustedIndex( CMapDisp *pDisp, int orient, 
+												  int ndxHgt, int ndxWid, int ndxImg )
+{
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST: 
+		{
+			return GetSWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_WEST: 
+		{
+			return GetWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_NORTHWEST: 
+		{ 
+			return GetNWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_NORTH: 
+		{
+			return GetNImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_NORTHEAST: 
+		{ 
+			return GetNEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_EAST: 
+		{ 
+			return GetEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_SOUTHEAST: 
+		{ 
+			return GetSEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_SOUTH: 
+		{ 
+			return GetSImageIndex( pDisp, orient, ndxHgt, ndxWid );
+		}
+	case IMAGEFILTER_MAIN: 
+		{ 
+			int imgWid = pDisp->GetWidth();
+			return( ndxHgt * imgWid + ndxWid );
+		}
+	default: 
+		{ 
+			return -1; 
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::SetImageValues( CDispMapImageFilter *pFilter,
+												 CMapDisp *pDisp, int ndxHgt, int ndxWid, 
+												 int ndxImg, int imgCount, Vector &value )
+{
+	CMapDisp *pNeighborDisp = NULL;
+	int		 orient;
+	EditDispHandle_t neighborHandle;
+
+	switch( ndxImg )
+	{
+	case IMAGEFILTER_SOUTHWEST: 
+		{
+			int count = pDisp->GetCornerNeighborCount( 0 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 0, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+						SWImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+					}
+					return;
+				}			
+			}
+
+			return;
+		}
+	case IMAGEFILTER_WEST: 
+		{
+			pDisp->GetEdgeNeighbor( 0, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+				WImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+				return;
+			}
+
+			return;
+		}
+	case IMAGEFILTER_NORTHWEST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 2 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 2, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+						NWImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+					}
+					return;
+				}			
+			}
+
+			return;
+		}
+	case IMAGEFILTER_NORTH: 
+		{
+			pDisp->GetEdgeNeighbor( 1, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+				NImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+				return;
+			}
+
+			// shouldn't be here!!
+			return;
+		}
+	case IMAGEFILTER_NORTHEAST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 3 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 3, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+						NEImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+					}
+					return;
+				}			
+			}
+
+			return;
+		}
+	case IMAGEFILTER_EAST: 
+		{ 
+			pDisp->GetEdgeNeighbor( 2, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+				EImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+				return;
+			}
+
+			return;
+		}
+	case IMAGEFILTER_SOUTHEAST: 
+		{ 
+			int count = pDisp->GetCornerNeighborCount( 1 );
+			if( count != 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( i != imgCount )
+						continue;
+
+					pDisp->GetCornerNeighbor( 1, i, neighborHandle, orient );
+					if( neighborHandle != EDITDISPHANDLE_INVALID )
+					{
+						pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+						SEImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+					}
+					return;
+				}			
+			}
+
+			return;
+		}
+	case IMAGEFILTER_SOUTH: 
+		{ 
+			pDisp->GetEdgeNeighbor( 3, neighborHandle, orient );
+			if( neighborHandle != EDITDISPHANDLE_INVALID )
+			{
+				pNeighborDisp = EditDispMgr()->GetDisp( neighborHandle );
+				SImageValue( pFilter, pNeighborDisp, orient, ndxHgt, ndxWid, true, value );
+				return;
+			}
+
+			return;
+		}
+	case IMAGEFILTER_MAIN: 
+		{ 
+			MainImageValue( pFilter, pDisp, ndxHgt, ndxWid, true, value );
+			return;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::MainImageValue( CDispMapImageFilter *pFilter,
+										         CMapDisp *pDisp, int ndxHgt, int ndxWid, 
+										         bool bSet, Vector &value )
+{
+	// get the image height and width
+	int height = pDisp->GetHeight();
+
+	// calc index value
+	int index = ndxHgt * height + ndxWid;
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetSWImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_SOUTHWEST:
+		{
+			hIndex = -ndxHgt;
+			wIndex = -ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTHEAST:
+		{
+			hIndex = -ndxWid;
+			wIndex = ( width - 1 ) + ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHWEST:
+		{
+			hIndex = ( height - 1 ) + ndxWid;
+			wIndex = -ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHEAST:
+		{
+			hIndex = ( height - 1 ) + ndxHgt;
+			wIndex = ( width - 1 ) + ndxWid;
+			break;
+		}
+	default:
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::SWImageValue( CDispMapImageFilter *pFilter,
+										       CMapDisp *pDisp, int orient,
+										       int ndxHgt, int ndxWid, bool bSet, 
+											   Vector &value )
+{
+	// get the index
+	int index = GetSWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetWImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_WEST:
+		{
+			hIndex = ( height - 1 ) - ndxHgt;
+			wIndex = -ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTH:
+		{
+			hIndex = ( height - 1 ) + ndxWid;
+			wIndex = ( width - 1 ) - ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_EAST:
+		{
+			hIndex = ndxHgt;
+			wIndex = ( width - 1 ) + ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTH:
+		{
+			hIndex = -ndxWid;
+			wIndex = ndxHgt;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::WImageValue( CDispMapImageFilter *pFilter,
+									          CMapDisp *pDisp, int orient,
+									          int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetNWImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_SOUTHWEST:
+		{
+			hIndex = ndxHgt - ( height - 1 );
+			wIndex = -ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTHEAST:
+		{
+			hIndex = ndxHgt - ( height - 1 );
+			wIndex = ( width - 1 ) + ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHWEST:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxHgt;
+			wIndex = -ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHEAST:
+		{
+			hIndex = ( height - 1 ) + ndxWid;
+			wIndex = ( 2 * ( width - 1 ) ) - ndxHgt;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		 }
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::NWImageValue( CDispMapImageFilter *pFilter,
+										       CMapDisp *pDisp, int orient,
+										       int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetNWImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetNImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_WEST:
+		{
+			hIndex = ( height - 1 ) - ndxWid;
+			wIndex = ndxHgt - ( width - 1 );
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTH:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxHgt;
+			wIndex = ( width - 1 ) - ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_EAST:
+		{
+			hIndex = ndxWid;
+			wIndex = ( 2 * ( width - 1 ) ) - ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTH:
+		{
+			hIndex = ndxHgt - ( height - 1 );
+			wIndex = ndxWid;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::NImageValue( CDispMapImageFilter *pFilter,
+									          CMapDisp *pDisp, int orient,
+									          int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetNImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetNEImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_SOUTHWEST:
+		{
+			hIndex = ndxHgt - ( height - 1 );
+			wIndex = ndxWid - ( width - 1 );
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTHEAST:
+		{
+			hIndex = ndxWid - ( height - 1 );
+			wIndex = ( 2 * ( width - 1 ) ) - ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHWEST:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxWid;
+			wIndex = ndxHgt - ( width - 1 );
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHEAST:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxHgt;
+			wIndex = ( 2 * ( width - 1 ) ) - ndxWid;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::NEImageValue( CDispMapImageFilter *pFilter,
+										       CMapDisp *pDisp, int orient,
+										       int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetNEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetEImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_WEST:
+		{
+			hIndex = ndxHgt;
+			wIndex = ndxWid - ( width - 1 );
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTH:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxWid;
+			wIndex = ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_EAST:
+		{
+			hIndex = ( height - 1 ) - ndxHgt;
+			wIndex = ( 2 * ( width - 1 ) ) - ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTH:
+		{
+			hIndex = ndxWid - ( height - 1 );
+			wIndex = ( width - 1 ) - ndxHgt;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::EImageValue( CDispMapImageFilter *pFilter,
+									          CMapDisp *pDisp, int orient,
+									          int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetSEImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_SOUTHWEST:
+		{
+			hIndex = ndxWid - ( height - 1 );
+			wIndex = -ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTHEAST:
+		{
+			hIndex = -ndxHgt;
+			wIndex = ( 2 * ( width - 1 ) ) - ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHWEST:
+		{
+			hIndex = ( height - 1 ) + ndxHgt;
+			wIndex = ndxWid - ( width - 1 );
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTHEAST:
+		{
+			hIndex = ( 2 * ( height - 1 ) ) - ndxWid;
+			wIndex = ( width - 1 ) + ndxHgt;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::SEImageValue( CDispMapImageFilter *pFilter,
+										       CMapDisp *pDisp, int orient,
+										       int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetSEImageIndex( pDisp, orient, ndxHgt, ndxWid );
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CDispMapImageFilterManager::GetSImageIndex( CMapDisp *pDisp, int orient, int ndxHgt, int ndxWid )
+{
+	//
+	// get the image height and width
+	//
+	int height = pDisp->GetHeight();
+	int width = pDisp->GetWidth();
+
+	//
+	//
+	//
+	int hIndex, wIndex;
+	switch( orient )
+	{
+	case IMAGEFILTER_ORIENT_WEST:
+		{
+			hIndex = ndxWid;
+			wIndex = -ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_NORTH:
+		{
+			hIndex = ( height - 1 ) + ndxHgt;
+			wIndex = ndxWid;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_EAST:
+		{
+			hIndex = ( height - 1 ) - ndxWid;
+			wIndex = ( width - 1 ) + ndxHgt;
+			break;
+		}
+	case IMAGEFILTER_ORIENT_SOUTH:
+		{
+			hIndex = -ndxHgt;
+			wIndex = ( width - 1 ) - ndxWid;
+			break;
+		}
+	default: 
+		{
+			hIndex = 0;
+			wIndex = 0;
+		}
+	}
+
+	//
+	// clamp height and width index values
+	//
+	if( hIndex < 0 ) { hIndex = 0; }
+	if( wIndex < 0 ) { wIndex = 0; }
+	if( hIndex > ( height - 1 ) ) { hIndex = ( height - 1 ); }
+	if( wIndex > ( width - 1 ) ) { wIndex = ( width - 1 ); }
+
+	// calc index value
+	return( hIndex * height + wIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::SImageValue( CDispMapImageFilter *pFilter,
+									          CMapDisp *pDisp, int orient,
+									          int ndxHgt, int ndxWid, bool bSet, Vector &value )
+{
+	// get image index
+	int index = GetSImageIndex( pDisp, orient, ndxHgt, ndxWid );
+
+	//
+	// return the value at this position
+	//
+	if( bSet )
+	{
+		SetImageValue( pDisp, pFilter, index, value );
+	}
+	else
+	{
+		GetImageValue( pDisp, pFilter, index, value );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ClampValues( CDispMapImageFilter *pFilter, Vector &v )
+{
+	if( pFilter->m_DataType == DISPPAINT_CHANNEL_ALPHA )
+	{
+		if( v.x < 0.0f ) { v.x = 0.0f; }
+		if( v.x > 255.0f ) { v.x = 255.0f; }
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::GetFilterVector( CDispMapImageFilter *pFilter,
+									              CMapDisp *pDisp, int ndxHgt, int ndxWid,
+										          int ndxImg, int imgCount, int ndxFilter, 
+												  Vector &vFilterDir )
+{
+	// 
+	// handle the alpha case
+	//
+	if( pFilter->m_DataType == DISPPAINT_CHANNEL_ALPHA )
+	{
+		vFilterDir.Init( ( pFilter->m_pImage[ndxFilter] * pFilter->m_Scale ), 0.0f, 0.0f );
+		return true;
+	}
+
+	//
+	// get the image (displacement) given a position
+	//
+	int orient;
+	CMapDisp *pNeighborDisp = GetImage( pFilter, pDisp, ndxHgt, ndxWid, ndxImg, imgCount, orient );
+	if( !pNeighborDisp )
+		return false;
+
+	Vector normal;
+	normal = m_PaintDir;
+
+	if( m_PaintType == DISPPAINT_AXIS_SUBDIV )
+	{
+		switch( ndxImg )
+		{
+		case IMAGEFILTER_SOUTHWEST:
+			{
+				int ndx = GetSWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_WEST: 
+			{
+				int ndx = GetWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_NORTHWEST: 
+			{ 
+				int ndx = GetNWImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_NORTH: 
+			{
+				int ndx = GetNImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_NORTHEAST: 
+			{
+				int ndx = GetNEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_EAST: 
+			{
+				int ndx = GetEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_SOUTHEAST: 
+			{
+				int ndx = GetSEImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_SOUTH: 
+			{ 
+				int ndx = GetSImageIndex( pNeighborDisp, orient, ndxHgt, ndxWid );
+				pNeighborDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		case IMAGEFILTER_MAIN: 
+			{ 
+				int ndx = ndxHgt * pDisp->GetWidth() + ndxWid;
+				pDisp->GetSubdivNormal( ndx, normal );
+				break;
+			}
+		default: 
+			{ 
+				return false; 
+			}
+		}
+	}
+
+	vFilterDir = normal * ( pFilter->m_pImage[ndxFilter] * pFilter->m_Scale );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ApplyAddFilter( CDispMapImageFilter *pFilter,
+										         CMapDisp *pDisp, int iVert )
+{
+	// Get displacement image and filter height and width data
+	int nImageHeight = pDisp->GetHeight();
+	int nImageWidth = pDisp->GetWidth();
+
+	int nFilterHeight = pFilter->m_Height;
+	int nFilterWidth = pFilter->m_Width;
+
+	// Calculate filter mid point.
+	int nFilterMidHeight = ( nFilterHeight - 1 ) / 2;
+	int nFilterMidWidth = ( nFilterWidth - 1 ) / 2;
+
+	// Componentize image index.
+	int iVertHeight = iVert / nImageHeight;
+	int iVertWidth = iVert % nImageWidth;
+
+	// For all positions in filter
+	Vector vecImage;
+	for( int iHgt = 0; iHgt < nFilterHeight; ++iHgt )
+	{
+		for( int iWid = 0; iWid < nFilterWidth; ++iWid )
+		{
+			// Position relative to the center of the filter.
+			int nHeight = iHgt - nFilterMidHeight;
+			int nWidth = iWid - nFilterMidWidth;
+			
+			// Adjusted height and width.
+			int nAdjHeight = iVertHeight + nHeight;
+			int nAdjWidth = iVertWidth + nWidth;
+
+			// Setup the hit data.
+			PosHitData_t hitData;
+			HitData_Setup( hitData, nAdjHeight, nAdjWidth, nImageHeight, nImageWidth );
+
+			// Update corners.
+			if( hitData.m_CornerCount != 0 )
+			{
+				for( int iCorner = 0; iCorner < hitData.m_CornerCount; ++iCorner )
+				{
+					int nCount = GetCornerImageCount( pDisp, hitData.m_ndxCorners[iCorner] );
+					for( int iCurCorner = 0; iCurCorner < nCount; ++iCurCorner )
+					{
+						if( GetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxCorners[iCorner], iCurCorner, vecImage ) )
+						{
+							Vector vecFilter;
+							GetFilterVector( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxCorners[iCorner], iCurCorner, ( iHgt * nFilterHeight + iWid ), vecFilter );
+							vecImage += vecFilter;
+							
+							// Clamp values (for alpha).
+							ClampValues( pFilter, vecImage );
+						
+							SetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxCorners[iCorner], iCurCorner, vecImage );
+						}
+					}
+				}
+			}
+
+			// Update edges.
+			if( hitData.m_EdgeCount != 0 )
+			{
+				for( int iEdge = 0; iEdge < hitData.m_EdgeCount; ++iEdge )
+				{
+					if( GetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxEdges[iEdge], 0, vecImage ) )
+					{
+						Vector vecFilter;
+						GetFilterVector( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxEdges[iEdge], 0, ( iHgt * nFilterHeight + iWid ), vecFilter );
+						vecImage += vecFilter;
+						
+						// Clamp values (for alpha).
+						ClampValues( pFilter, vecImage );
+						
+						SetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, hitData.m_ndxEdges[iEdge], 0, vecImage );
+					}
+				}
+			}
+
+			// Update main.
+			if( hitData.m_bMain )
+			{
+				if( GetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, IMAGEFILTER_MAIN, 0, vecImage ) )
+				{
+					Vector vecFilter;
+					GetFilterVector( pFilter, pDisp, nAdjHeight, nAdjWidth, IMAGEFILTER_MAIN, 0, ( iHgt * nFilterHeight + iWid ), vecFilter );
+					vecImage += vecFilter;
+					
+					// Clamp values (for alpha).
+					ClampValues( pFilter, vecImage );
+					
+					SetImageValues( pFilter, pDisp, nAdjHeight, nAdjWidth, IMAGEFILTER_MAIN, 0, vecImage );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ApplyMultFilter( CDispMapImageFilter *pFilter,
+								  		          CMapDisp *pDisp, int ndxVert )
+{
+	//
+	// get displacement image and filter height and width data
+	//
+	int imgHgt = pDisp->GetHeight();
+	int imgWid = pDisp->GetWidth();
+
+	int filterHgt = pFilter->m_Height;
+	int filterWid = pFilter->m_Width;
+
+	//
+	// get filter mid point
+	//
+	int filterMidHgt = ( filterHgt - 1 ) / 2;
+	int filterMidWid = ( filterWid - 1 ) / 2;
+
+	//
+	// componentize image index
+	//
+	int ndxVertHgt = ndxVert / imgHgt;
+	int ndxVertWid = ndxVert % imgWid;
+
+	//
+	// for all positions in filter
+	//
+	Vector vImg;
+	for( int ndxHgt = 0; ndxHgt < filterHgt; ndxHgt++ )
+	{
+		for( int ndxWid = 0; ndxWid < filterWid; ndxWid++ )
+		{
+			// position relative to the center of the filter
+			int height = ndxHgt - filterMidHgt;
+			int width = ndxWid - filterMidWid;
+			
+			// adjusted height and width
+			int adjHgt = ndxVertHgt + height;
+			int adjWid = ndxVertWid + width;
+
+			// setup the hit data
+			PosHitData_t hitData;
+			HitData_Setup( hitData, adjHgt, adjWid, imgHgt, imgWid );
+
+			// update corners
+			if( hitData.m_CornerCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_CornerCount; i++ )
+				{
+					int count = GetCornerImageCount( pDisp, hitData.m_ndxCorners[i] );
+					for( int j = 0; j < count; j++ )
+					{
+						if( GetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, vImg ) )
+						{
+							Vector vFilter;
+							GetFilterVector( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, (ndxHgt*filterHgt+ndxWid), vFilter );
+							vImg *= vFilter;
+							
+							// clamp values (for alpha)
+							ClampValues( pFilter, vImg );
+							
+							SetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, vImg );
+						}
+					}
+				}
+			}
+
+			// update edges
+			if( hitData.m_EdgeCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_EdgeCount; i++ )
+				{
+					if( GetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, vImg ) )
+					{
+						Vector vFilter;
+						GetFilterVector( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, (ndxHgt*filterHgt+ndxWid), vFilter );
+						vImg += vFilter;
+						
+						// clamp values (for alpha)
+						ClampValues( pFilter, vImg );
+						
+						SetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, vImg );
+					}
+				}
+			}
+
+			// update main
+			if( hitData.m_bMain )
+			{
+				if( GetImageValues( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, vImg ) )
+				{
+					Vector vFilter;
+					GetFilterVector( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, (ndxHgt*filterHgt+ndxWid), vFilter );
+					vImg += vFilter;
+					
+					// clamp values (for alpha)
+					ClampValues( pFilter, vImg );
+					
+					SetImageValues( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, vImg );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::Apply3x3SmoothFilter( CDispMapImageFilter *pFilter,
+													   CMapDisp *pDisp, int ndxVert,
+													   Vector &vPos )
+{
+	//
+	// get displacement image and filter height and width data
+	//
+	int imgHgt = pDisp->GetHeight();
+	int imgWid = pDisp->GetWidth();
+
+	int filterHgt = pFilter->m_Height;
+	int filterWid = pFilter->m_Width;
+
+	int filterMidHgt = ( pFilter->m_Height - 1 ) / 2;
+	int filterMidWid = ( pFilter->m_Width - 1 ) / 2;
+
+	//
+	// componentize image index
+	//
+	int ndxVertHgt = ndxVert / imgHgt;
+	int ndxVertWid = ndxVert % imgWid;
+
+	Vector vNormal;
+	Vector vNormals( 0.0f, 0.0f, 0.0f );
+	float  dist;
+	float  dists = 0.0f;
+	float totalFrac = 0.0f;
+
+	for( int ndxHgt = 0; ndxHgt < filterHgt; ndxHgt++ )
+	{
+		for( int ndxWid = 0; ndxWid < filterWid; ndxWid++ )
+		{
+			// position relative to the center of the filter
+			int height = ndxHgt - filterMidHgt;
+			int width = ndxWid - filterMidWid;
+			
+			// adjusted height and width
+			int adjHgt = ndxVertHgt + height;
+			int adjWid = ndxVertWid + width;
+
+			// setup the hit data
+			PosHitData_t hitData;
+			HitData_Setup( hitData, adjHgt, adjWid, imgHgt, imgWid );
+
+			// update corners
+			if( hitData.m_CornerCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_CornerCount; i++ )
+				{
+					int count = GetCornerImageCount( pDisp, hitData.m_ndxCorners[i] );
+					for( int j = 0; j < count; j++ )
+					{
+						if( GetImageFieldValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, vNormal, dist ) )
+						{
+							vNormals += ( vNormal * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+							dists += ( dist * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+							totalFrac += pFilter->m_pImage[ndxHgt*filterHgt+ndxWid];
+						}
+					}
+				}
+			}
+
+			// update edges
+			if( hitData.m_EdgeCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_EdgeCount; i++ )
+				{
+					if( GetImageFieldValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, vNormal, dist ) )
+					{
+						vNormals += ( vNormal * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+						dists += ( dist * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+						totalFrac += pFilter->m_pImage[ndxHgt*filterHgt+ndxWid];
+					}
+				}
+			}
+
+			// update main
+			if( hitData.m_bMain )
+			{
+				if( GetImageFieldValues( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, vNormal, dist ) )
+				{
+					vNormals += ( vNormal * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+					dists += ( dist * pFilter->m_pImage[ndxHgt*filterHgt+ndxWid] );
+					totalFrac += pFilter->m_pImage[ndxHgt*filterHgt+ndxWid];
+				}
+			}
+		}
+	}
+
+	VectorNormalize( vNormals );
+	dists /= totalFrac;
+
+	vPos = vNormals * dists;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ApplySmoothFilter( CDispMapImageFilter *pFilter,
+										            CMapDisp *pDisp, int ndxVert )
+{
+	//
+	// get displacement image and filter height and width data
+	//
+	int imgHgt = pDisp->GetHeight();
+	int imgWid = pDisp->GetWidth();
+
+	int areaHgt = pFilter->m_AreaHeight;
+	int areaWid = pFilter->m_AreaWidth;
+
+	int areaMidHgt = ( areaHgt - 1 ) / 2;
+	int areaMidWid = ( areaWid - 1 ) / 2;
+
+	//
+	// componentize image index
+	//
+	int ndxVertHgt = ndxVert / imgHgt;
+	int ndxVertWid = ndxVert % imgWid;
+
+	//
+	// for all positions in filter
+	//
+	Vector vPos;
+	for( int ndxHgt = 0; ndxHgt < areaHgt; ndxHgt++ )
+	{
+		for( int ndxWid = 0; ndxWid < areaWid; ndxWid++ )
+		{
+			// position relative to the center of the area of effect
+			int height = ndxHgt - areaMidHgt;
+			int width = ndxWid - areaMidWid;
+
+			// adjusted height and width
+			int adjHgt = ndxVertHgt + height;
+			int adjWid = ndxVertWid + width;
+
+			// setup the hit data
+			PosHitData_t hitData;
+			HitData_Setup( hitData, adjHgt, adjWid, imgHgt, imgWid );
+
+			// update corners
+			if( hitData.m_CornerCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_CornerCount; i++ )
+				{
+					int count = GetCornerImageCount( pDisp, hitData.m_ndxCorners[i] );
+					for( int j = 0; j < count; j++ )
+					{
+						//
+						// get the current corner
+						//
+						int orient;
+						CMapDisp *pAdjDisp = GetImage( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, orient );
+						if( pAdjDisp )
+						{
+							int adjIndex = GetAdjustedIndex( pAdjDisp, orient, adjHgt, adjWid, hitData.m_ndxCorners[i] );
+							
+							// apply a 3x3 box filter at each position
+							Apply3x3SmoothFilter( pFilter, pAdjDisp, adjIndex, vPos );
+						
+							// get the flat/subdivision position
+							Vector vFlat, vSubPos;
+							pAdjDisp->GetFlatVert( adjIndex, vFlat );
+							pAdjDisp->GetSubdivPosition( adjIndex, vSubPos );
+
+							vPos += vFlat;
+							vPos += vSubPos;
+
+							SetImageValue( pAdjDisp, pFilter, adjIndex, vPos );
+						}
+					}
+				}
+			}
+
+			// update edges
+			if( hitData.m_EdgeCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_EdgeCount; i++ )
+				{
+						//
+						// get the current corner
+						//
+						int orient;
+						CMapDisp *pAdjDisp = GetImage( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, orient );
+						if( pAdjDisp )
+						{
+							int adjIndex = GetAdjustedIndex( pAdjDisp, orient, adjHgt, adjWid, hitData.m_ndxEdges[i] );
+							
+							// apply a 3x3 box filter at each position
+							Apply3x3SmoothFilter( pFilter, pAdjDisp, adjIndex, vPos );
+
+							// get the flat/subdivision position
+							Vector vFlat, vSubPos;
+							pAdjDisp->GetFlatVert( adjIndex, vFlat );
+							pAdjDisp->GetSubdivPosition( adjIndex, vSubPos );
+
+							vPos += vFlat;
+							vPos += vSubPos;
+							
+							SetImageValue( pAdjDisp, pFilter, adjIndex, vPos );
+						}
+				}
+			}
+
+			// update main
+			if( hitData.m_bMain )
+			{
+				//
+				// get the current corner
+				//
+				int orient;
+				CMapDisp *pAdjDisp = GetImage( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, orient );
+				if( pAdjDisp )
+				{
+					int adjIndex = GetAdjustedIndex( pAdjDisp, orient, adjHgt, adjWid, IMAGEFILTER_MAIN );
+					
+					// apply a 3x3 box filter at each position
+					Apply3x3SmoothFilter( pFilter, pAdjDisp, adjIndex, vPos );
+
+					// get the flat/subdivision position
+					Vector vFlat, vSubPos;
+					pAdjDisp->GetFlatVert( adjIndex, vFlat );
+					pAdjDisp->GetSubdivPosition( adjIndex, vSubPos );
+					
+					vPos += vFlat;
+					vPos += vSubPos;
+	
+					SetImageValue( pAdjDisp, pFilter, adjIndex, vPos );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CDispMapImageFilterManager::IsEqualMask( CDispMapImageFilter *pFilter, int ndxFilter )
+{
+	if( pFilter->m_pImage[ndxFilter] == IMAGEFILTER_EQUALMASK )
+		return true;
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CDispMapImageFilterManager::ApplyEqualFilter( CDispMapImageFilter *pFilter,
+								  		           CMapDisp *pDisp, int ndxVert )
+{
+	//
+	// get displacement image and filter height and width data
+	//
+	int imgHgt = pDisp->GetHeight();
+	int imgWid = pDisp->GetWidth();
+
+	int filterHgt = pFilter->m_Height;
+	int filterWid = pFilter->m_Width;
+
+	//
+	// get filter mid point
+	//
+	int filterMidHgt = ( filterHgt - 1 ) / 2;
+	int filterMidWid = ( filterWid - 1 ) / 2;
+
+	//
+	// componentize image index
+	//
+	int ndxVertHgt = ndxVert / imgHgt;
+	int ndxVertWid = ndxVert % imgWid;
+
+	//
+	// for all positions in filter
+	//
+	Vector vImg;
+	for( int ndxHgt = 0; ndxHgt < filterHgt; ndxHgt++ )
+	{
+		for( int ndxWid = 0; ndxWid < filterWid; ndxWid++ )
+		{
+			// position relative to the center of the filter
+			int height = ndxHgt - filterMidHgt;
+			int width = ndxWid - filterMidWid;
+			
+			// adjusted height and width
+			int adjHgt = ndxVertHgt + height;
+			int adjWid = ndxVertWid + width;
+
+			// setup the hit data
+			PosHitData_t hitData;
+			HitData_Setup( hitData, adjHgt, adjWid, imgHgt, imgWid );
+
+			// update corners
+			if( hitData.m_CornerCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_CornerCount; i++ )
+				{
+					int count = GetCornerImageCount( pDisp, hitData.m_ndxCorners[i] );
+					for( int j = 0; j < count; j++ )
+					{
+						if( GetImageFlatSubdivValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, vImg ) )
+						{
+							if( !IsEqualMask( pFilter, (ndxHgt*filterHgt+ndxWid) ) )
+							{
+								Vector vFilter;
+								GetFilterVector( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, (ndxHgt*filterHgt+ndxWid), vFilter );
+								vImg += vFilter;
+
+								ClampValues( pFilter, vImg );
+
+								SetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxCorners[i], j, vImg );
+							}
+						}
+					}
+				}
+			}
+
+			// update edges
+			if( hitData.m_EdgeCount != 0 )
+			{
+				for( int i = 0; i < hitData.m_EdgeCount; i++ )
+				{
+					if( GetImageFlatSubdivValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, vImg ) )
+					{
+						if( !IsEqualMask( pFilter, (ndxHgt*filterHgt+ndxWid) ) )
+						{
+							Vector vFilter;
+							GetFilterVector( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, (ndxHgt*filterHgt+ndxWid), vFilter );
+							vImg += vFilter;
+							
+							ClampValues( pFilter, vImg );
+
+							SetImageValues( pFilter, pDisp, adjHgt, adjWid, hitData.m_ndxEdges[i], 0, vImg );
+						}
+					}
+				}
+			}
+
+			// update main
+			if( hitData.m_bMain )
+			{
+				if( GetImageFlatSubdivValues( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, vImg ) )
+				{
+					if( !IsEqualMask( pFilter, (ndxHgt*filterHgt+ndxWid) ) )
+					{
+						Vector vFilter;
+						GetFilterVector( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, (ndxHgt*filterHgt+ndxWid), vFilter );
+						vImg += vFilter;
+						
+						ClampValues( pFilter, vImg );
+
+						SetImageValues( pFilter, pDisp, adjHgt, adjWid, IMAGEFILTER_MAIN, 0, vImg );
+					}
+				}
+			}
+		}
+	}
+}
+
+