mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
2478 lines
65 KiB
C++
2478 lines
65 KiB
C++
//========= 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 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|