source-engine/hammer/dispmapimagefilter.cpp

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