2413 lines
67 KiB
C++
2413 lines
67 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include <stdafx.h>
|
|
#include <malloc.h>
|
|
#include "FaceEditSheet.h"
|
|
#include "MainFrm.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "MapDisp.h"
|
|
#include "MapFace.h"
|
|
#include "UtlVector.h"
|
|
#include "disp_tesselate.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
//============================================================================
|
|
//
|
|
// e1
|
|
// c1------c2
|
|
// | |
|
|
// e0 | | e2
|
|
// | |
|
|
// c0------c3
|
|
// e3
|
|
//
|
|
// Note: edges refer to internal edge points only, corners "contain" all surfaces
|
|
// touching the corner (surfaces that only touch the corner, as well as those
|
|
// "edges" that end/begin at the corner(s))
|
|
//
|
|
#define DISPSEW_POINT_TOLERANCE 1.0f // one unit
|
|
|
|
#define DISPSEW_NULL_INDEX -99999
|
|
|
|
#define DISPSEW_EDGE_NORMAL 0
|
|
#define DISPSEW_EDGE_TJSTART 1
|
|
#define DISPSEW_EDGE_TJEND 2
|
|
#define DISPSEW_EDGE_TJ 3
|
|
|
|
#define DISPSEW_FACES_AT_EDGE 3
|
|
#define DISPSEW_FACES_AT_CORNER 16
|
|
#define DISPSEW_FACES_AT_TJUNC 8
|
|
|
|
struct SewEdgeData_t
|
|
{
|
|
int faceCount; // number of faces contributing to the edge sew
|
|
CMapFace *pFaces[DISPSEW_FACES_AT_EDGE]; // the faces contributing to the edge sew
|
|
int ndxEdges[DISPSEW_FACES_AT_EDGE]; // the faces' edge indices contributing to the edge sew
|
|
int type[DISPSEW_FACES_AT_EDGE]; // the type of edge t-junction, match t-junction start, etc....
|
|
};
|
|
|
|
struct SewCornerData_t
|
|
{
|
|
int faceCount; // number of faces contributing to the corner sew
|
|
CMapFace *pFaces[DISPSEW_FACES_AT_CORNER]; // the faces contributing to the corner sew
|
|
int ndxCorners[DISPSEW_FACES_AT_CORNER]; // the faces' corner indices contributing to the corner sew
|
|
};
|
|
|
|
struct SewTJuncData_t
|
|
{
|
|
int faceCount; // number of faces contributing to the t-junction sew
|
|
CMapFace *pFaces[DISPSEW_FACES_AT_TJUNC]; // the faces contributing to the t-junction sew
|
|
int ndxCorners[DISPSEW_FACES_AT_TJUNC]; // the faces' corner indices contributing to the t-junction sew
|
|
int ndxEdges[DISPSEW_FACES_AT_TJUNC]; // the faces' edge (midpoint) indices contributing to the t-junction sew
|
|
};
|
|
|
|
static CUtlVector<SewEdgeData_t*> s_EdgeData;
|
|
static CUtlVector<SewCornerData_t*> s_CornerData;
|
|
static CUtlVector<SewTJuncData_t*> s_TJData;
|
|
static CUtlVector<CCoreDispInfo*> m_aCoreDispInfos;
|
|
|
|
// local functions
|
|
void SewCorner_Build( void );
|
|
void SewCorner_Resolve( void );
|
|
void SewCorner_Destroy( SewCornerData_t *pCornerData );
|
|
void SewTJunc_Build( void );
|
|
void SewTJunc_Resolve( void );
|
|
void SewTJunc_Destroy( SewTJuncData_t *pTJData );
|
|
void SewEdge_Build( void );
|
|
void SewEdge_Resolve( void );
|
|
void SewEdge_Destroy( SewEdgeData_t *pEdgeData );
|
|
|
|
void PlanarizeDependentVerts( void );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: compare two point positions to see if they are equivolent given a
|
|
// tolerance
|
|
//-----------------------------------------------------------------------------
|
|
bool PointCompareWithTolerance( Vector const& pt1, Vector const& pt2, float tolerance )
|
|
{
|
|
for( int i = 0 ; i < 3 ; i++ )
|
|
{
|
|
if( fabs( pt1[i] - pt2[i] ) > tolerance )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool EdgeCompare( Vector *pEdgePts1, Vector *pEdgePts2, int &edgeType1, int &edgeType2 )
|
|
{
|
|
Vector edge1[3];
|
|
Vector edge2[3];
|
|
|
|
//
|
|
// create edges and midpoints
|
|
//
|
|
edge1[0] = pEdgePts1[0];
|
|
edge1[1] = ( pEdgePts1[0] + pEdgePts1[1] ) * 0.5f;
|
|
edge1[2] = pEdgePts1[1];
|
|
|
|
edge2[0] = pEdgePts2[0];
|
|
edge2[1] = ( pEdgePts2[0] + pEdgePts2[1] ) * 0.5f;
|
|
edge2[2] = pEdgePts2[1];
|
|
|
|
// assume edge type to be normal (will get overridden if otherwise)
|
|
edgeType1 = DISPSEW_EDGE_NORMAL;
|
|
edgeType2 = DISPSEW_EDGE_NORMAL;
|
|
|
|
//
|
|
// compare points and determine how many are shared between the two edges
|
|
//
|
|
int overlapCount = 0;
|
|
int ndxEdge1[2];
|
|
int ndxEdge2[2];
|
|
|
|
for( int ndx1 = 0; ndx1 < 3; ndx1++ )
|
|
{
|
|
for( int ndx2 = 0; ndx2 < 3; ndx2++ )
|
|
{
|
|
if( PointCompareWithTolerance( edge1[ndx1], edge2[ndx2], DISPSEW_POINT_TOLERANCE ) )
|
|
{
|
|
// no midpoint to midpoint sharing allowed (midpoints are odd index values)
|
|
if( ( ndx1%2 != 0 ) && ( ndx2%2 != 0 ) )
|
|
continue;
|
|
|
|
// sanity check
|
|
assert( overlapCount >= 0 );
|
|
assert( overlapCount < 2 );
|
|
|
|
ndxEdge1[overlapCount] = ndx1;
|
|
ndxEdge2[overlapCount] = ndx2;
|
|
|
|
overlapCount++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( overlapCount != 2 )
|
|
return false;
|
|
|
|
// handle edge1 as t-junction edge
|
|
if( ndxEdge1[0]%2 != 0 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJ;
|
|
|
|
if( ndxEdge1[1] == 0 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJSTART;
|
|
}
|
|
else if( ndxEdge1[1] == 2 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJEND;
|
|
}
|
|
}
|
|
else if( ndxEdge1[1]%2 != 0 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJ;
|
|
|
|
if( ndxEdge1[0] == 0 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJSTART;
|
|
}
|
|
else if( ndxEdge1[0] == 2 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJEND;
|
|
}
|
|
}
|
|
|
|
// handle edge2 as t-junction edge
|
|
if( ndxEdge2[0]%2 != 0 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJ;
|
|
|
|
if( ndxEdge2[1] == 0 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJSTART;
|
|
}
|
|
else if( ndxEdge2[1] == 2 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJEND;
|
|
}
|
|
}
|
|
else if( ndxEdge2[1]%2 != 0 )
|
|
{
|
|
edgeType2 = DISPSEW_EDGE_TJ;
|
|
|
|
if( ndxEdge2[0] == 0 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJSTART;
|
|
}
|
|
else if( ndxEdge2[0] == 2 )
|
|
{
|
|
edgeType1 = DISPSEW_EDGE_TJEND;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: get a point from the surface at the given index, will get the point
|
|
// from the displacement surface if it exists, it will get it from the
|
|
// base face otherwise
|
|
//-----------------------------------------------------------------------------
|
|
inline void GetPointFromSurface( CMapFace *pFace, int ndxPt, Vector &pt )
|
|
{
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle != EDITDISPHANDLE_INVALID )
|
|
{
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
pDisp->GetSurfPoint( ndxPt, pt );
|
|
}
|
|
else
|
|
{
|
|
pFace->GetPoint( pt, ndxPt );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int GetEdgePointIndex( CMapDisp *pDisp, int edgeIndex, int edgePtIndex, bool bCCW )
|
|
{
|
|
int height = pDisp->GetHeight();
|
|
int width = pDisp->GetWidth();
|
|
|
|
if( bCCW )
|
|
{
|
|
switch( edgeIndex )
|
|
{
|
|
case 0: { return ( edgePtIndex * height ); }
|
|
case 1: { return ( ( ( height - 1 ) * width ) + edgePtIndex ); }
|
|
case 2: { return ( ( height * width - 1 ) - ( edgePtIndex * height ) ); }
|
|
case 3: { return ( ( width - 1 ) - edgePtIndex ); }
|
|
default: { return -1; }
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( edgeIndex )
|
|
{
|
|
case 0: { return ( ( ( height - 1 ) * width ) - ( edgePtIndex * height ) ); }
|
|
case 1: { return ( ( height * width - 1 ) - edgePtIndex ); }
|
|
case 2: { return ( ( width - 1 ) + ( edgePtIndex * height ) ); }
|
|
case 3: { return ( edgePtIndex ); }
|
|
default: { return -1; }
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int GetCornerPointIndex( CMapDisp *pDisp, int cornerIndex )
|
|
{
|
|
int width = pDisp->GetWidth();
|
|
int height = pDisp->GetHeight();
|
|
|
|
switch( cornerIndex )
|
|
{
|
|
case 0: { return 0; }
|
|
case 1: { return ( ( height - 1 ) * width ); }
|
|
case 2: { return ( height * width - 1 ); }
|
|
case 3: { return ( width - 1 ); }
|
|
default: { return -1; }
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int GetTJuncIndex( CMapDisp *pDisp, int ndxEdge )
|
|
{
|
|
int width = pDisp->GetWidth();
|
|
int height = pDisp->GetHeight();
|
|
|
|
switch( ndxEdge )
|
|
{
|
|
case 0: { return( height * ( width / 2 ) ); }
|
|
case 1: { return( ( ( height - 1 ) * width ) + ( width / 2 ) ); }
|
|
case 2: { return( ( height * ( width / 2 ) ) + ( width - 1 ) ); }
|
|
case 3: { return( width / 2 ); }
|
|
default: { return -1; }
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void AverageVectorFieldData( CMapDisp *pDisp1, int ndx1, CMapDisp *pDisp2, int ndx2 )
|
|
{
|
|
//
|
|
// average the positions at each index
|
|
// position = dispVector * dispDist
|
|
//
|
|
float dist1 = pDisp1->GetFieldDistance( ndx1 );
|
|
float dist2 = pDisp2->GetFieldDistance( ndx2 );
|
|
|
|
Vector v1, v2;
|
|
pDisp1->GetFieldVector( ndx1, v1 );
|
|
pDisp2->GetFieldVector( ndx2, v2 );
|
|
|
|
v1 *= dist1;
|
|
v2 *= dist2;
|
|
|
|
Vector vAvg;
|
|
vAvg = ( v1 + v2 ) * 0.5f;
|
|
|
|
float distAvg = VectorNormalize( vAvg );
|
|
|
|
pDisp1->SetFieldDistance( ndx1, distAvg );
|
|
pDisp2->SetFieldDistance( ndx2, distAvg );
|
|
pDisp1->SetFieldVector( ndx1, vAvg );
|
|
pDisp2->SetFieldVector( ndx2, vAvg );
|
|
|
|
// Check to see if the materials match and blend alphas if they do.
|
|
CMapFace *pFace1 = static_cast<CMapFace*>( pDisp1->GetParent() );
|
|
CMapFace *pFace2 = static_cast<CMapFace*>( pDisp2->GetParent() );
|
|
char szMatName1[128];
|
|
char szMatName2[128];
|
|
pFace1->GetTexture()->GetShortName( szMatName1 );
|
|
pFace2->GetTexture()->GetShortName( szMatName2 );
|
|
if ( !strcmpi( szMatName1, szMatName2 ) )
|
|
{
|
|
// Grab the alphas at the points and average them.
|
|
float flAlpha1, flAlpha2;
|
|
flAlpha1 = pDisp1->GetAlpha( ndx1 );
|
|
flAlpha2 = pDisp2->GetAlpha( ndx2 );
|
|
float flAlphaBlend = ( flAlpha1 + flAlpha1 ) * 0.5f;
|
|
pDisp1->SetAlpha( ndx1, flAlphaBlend );
|
|
pDisp2->SetAlpha( ndx2, flAlphaBlend );
|
|
}
|
|
|
|
// average the multiblends
|
|
// should this check for the same texture, or maybe just blend the first two channels? or check for same sub textures?
|
|
Vector4D vMultiBlendA, vMultiBlendB;
|
|
Vector4D vAlphaBlendA, vAlphaBlendB;
|
|
Vector vColorA[ MAX_MULTIBLEND_CHANNELS], vColorB[ MAX_MULTIBLEND_CHANNELS ];
|
|
pDisp1->GetMultiBlend( ndx1, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
pDisp2->GetMultiBlend( ndx2, vMultiBlendB, vAlphaBlendB, vColorB[ 0 ], vColorB[ 1 ], vColorB[ 2 ], vColorB[ 3 ] );
|
|
vMultiBlendA = ( vMultiBlendA + vMultiBlendB ) * 0.5f;
|
|
vMultiBlendA = ( vMultiBlendA + vMultiBlendB ) * 0.5f;
|
|
vColorA[ 0 ] = ( vColorA[ 0 ] + vColorB[ 0 ] ) * 0.5f;
|
|
vColorA[ 1 ] = ( vColorA[ 1 ] + vColorB[ 1 ] ) * 0.5f;
|
|
vColorA[ 2 ] = ( vColorA[ 2 ] + vColorB[ 2 ] ) * 0.5f;
|
|
vColorA[ 3 ] = ( vColorA[ 3 ] + vColorB[ 3 ] ) * 0.5f;
|
|
pDisp1->SetMultiBlend( ndx1, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
pDisp2->SetMultiBlend( ndx2, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
|
|
//
|
|
// average the subdivion positions and normals
|
|
//
|
|
pDisp1->GetSubdivPosition( ndx1, v1 );
|
|
pDisp2->GetSubdivPosition( ndx2, v2 );
|
|
vAvg = ( v1 + v2 ) * 0.5f;
|
|
pDisp1->SetSubdivPosition( ndx1, vAvg );
|
|
pDisp2->SetSubdivPosition( ndx2, vAvg );
|
|
|
|
pDisp1->GetSubdivNormal( ndx1, v1 );
|
|
pDisp2->GetSubdivNormal( ndx2, v2 );
|
|
vAvg = v1 + v2;
|
|
VectorNormalize( vAvg );
|
|
pDisp1->SetSubdivNormal( ndx1, vAvg );
|
|
pDisp2->SetSubdivNormal( ndx2, vAvg );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void BlendVectorFieldData( CMapDisp *pDisp1, int ndxSrc1, int ndxDst1,
|
|
CMapDisp *pDisp2, int ndxSrc2, int ndxDst2,
|
|
float blendFactor )
|
|
{
|
|
//
|
|
// to blend positions -- calculate the positions at the end points
|
|
// find the new point along the parameterized line and calculate the
|
|
// new field vector direction and distance (position)
|
|
//
|
|
float dist1 = pDisp1->GetFieldDistance( ndxSrc1 );
|
|
float dist2 = pDisp2->GetFieldDistance( ndxSrc2 );
|
|
|
|
Vector v1, v2;
|
|
pDisp1->GetFieldVector( ndxSrc1, v1 );
|
|
pDisp2->GetFieldVector( ndxSrc2, v2 );
|
|
|
|
v1 *= dist1;
|
|
v2 *= dist2;
|
|
|
|
Vector vBlend;
|
|
vBlend = v1 + ( v2 - v1 ) * blendFactor;
|
|
|
|
float distBlend = VectorNormalize( vBlend );
|
|
|
|
pDisp1->SetFieldDistance( ndxDst1, distBlend );
|
|
pDisp2->SetFieldDistance( ndxDst2, distBlend );
|
|
pDisp1->SetFieldVector( ndxDst1, vBlend );
|
|
pDisp2->SetFieldVector( ndxDst2, vBlend );
|
|
|
|
// Check to see if the materials match and blend alphas if they do.
|
|
CMapFace *pFace1 = static_cast<CMapFace*>( pDisp1->GetParent() );
|
|
CMapFace *pFace2 = static_cast<CMapFace*>( pDisp2->GetParent() );
|
|
char szMatName1[128];
|
|
char szMatName2[128];
|
|
pFace1->GetTexture()->GetShortName( szMatName1 );
|
|
pFace2->GetTexture()->GetShortName( szMatName2 );
|
|
if ( !strcmpi( szMatName1, szMatName2 ) )
|
|
{
|
|
float flAlpha1, flAlpha2;
|
|
flAlpha1 = pDisp1->GetAlpha( ndxDst1 );
|
|
flAlpha2 = pDisp2->GetAlpha( ndxDst2 );
|
|
float flAlphaBlend = flAlpha1 + ( flAlpha2 - flAlpha1 ) * blendFactor;
|
|
pDisp1->SetAlpha( ndxDst1, flAlphaBlend );
|
|
pDisp2->SetAlpha( ndxDst2, flAlphaBlend );
|
|
}
|
|
|
|
// average the multiblends
|
|
// should this check for the same texture, or maybe just blend the first two channels? or check for same sub textures?
|
|
Vector4D vMultiBlendA, vMultiBlendB;
|
|
Vector4D vAlphaBlendA, vAlphaBlendB;
|
|
Vector vColorA[ MAX_MULTIBLEND_CHANNELS], vColorB[ MAX_MULTIBLEND_CHANNELS ];
|
|
pDisp1->GetMultiBlend( ndxDst1, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
pDisp2->GetMultiBlend( ndxDst2, vMultiBlendB, vAlphaBlendB, vColorB[ 0 ], vColorB[ 1 ], vColorB[ 2 ], vColorB[ 3 ] );
|
|
vMultiBlendA = ( vMultiBlendA + vMultiBlendB ) * 0.5f;
|
|
vAlphaBlendA = ( vAlphaBlendA + vAlphaBlendB ) * 0.5f;
|
|
vColorA[ 0 ] = ( vColorA[ 0 ] + vColorB[ 0 ] ) * 0.5f;
|
|
vColorA[ 1 ] = ( vColorA[ 1 ] + vColorB[ 1 ] ) * 0.5f;
|
|
vColorA[ 2 ] = ( vColorA[ 2 ] + vColorB[ 2 ] ) * 0.5f;
|
|
vColorA[ 3 ] = ( vColorA[ 3 ] + vColorB[ 3 ] ) * 0.5f;
|
|
pDisp1->SetMultiBlend( ndxDst1, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
pDisp2->SetMultiBlend( ndxDst2, vMultiBlendA, vAlphaBlendA, vColorA[ 0 ], vColorA[ 1 ], vColorA[ 2 ], vColorA[ 3 ] );
|
|
|
|
//
|
|
// blend subdivision positions and normals as before,
|
|
// this isn't truly accurate, but I am not sure what these
|
|
// values mean in the edge sewing case anyway???
|
|
//
|
|
pDisp1->GetSubdivPosition( ndxSrc1, v1 );
|
|
pDisp2->GetSubdivPosition( ndxSrc2, v2 );
|
|
vBlend = v1 + ( v2 - v1 ) * blendFactor;
|
|
pDisp1->SetSubdivPosition( ndxDst1, vBlend );
|
|
pDisp2->SetSubdivPosition( ndxDst2, vBlend );
|
|
|
|
pDisp1->GetSubdivNormal( ndxSrc1, v1 );
|
|
pDisp2->GetSubdivNormal( ndxSrc2, v2 );
|
|
vBlend = v1 + ( v2 - v1 ) * blendFactor;
|
|
pDisp1->SetSubdivNormal( ndxDst1, vBlend );
|
|
pDisp2->SetSubdivNormal( ndxDst2, vBlend );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline bool Face_IsSolid( CMapFace *pFace )
|
|
{
|
|
return ( pFace->GetDisp() == EDITDISPHANDLE_INVALID );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void Faces_Update( void )
|
|
{
|
|
//
|
|
// get the "faces" selection list (contains displaced and non-displaced faces)
|
|
//
|
|
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
|
|
if( !pSheet )
|
|
return;
|
|
|
|
//
|
|
// for each face in list
|
|
//
|
|
int faceCount = pSheet->GetFaceListCount();
|
|
|
|
for( int ndxFace = 0; ndxFace < faceCount; ndxFace++ )
|
|
{
|
|
// get the current face
|
|
CMapFace *pFace = pSheet->GetFaceListDataFace( ndxFace );
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// only update displacement surfaces
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
pDisp->UpdateData();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Build temporary edge/midpoint/corner info for sewing.
|
|
//-----------------------------------------------------------------------------
|
|
void PreFaceListSew( void )
|
|
{
|
|
// Build edge/midpoint/corner data.
|
|
SewCorner_Build();
|
|
SewTJunc_Build();
|
|
SewEdge_Build();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destroy temporary edge/midpoint/corner info for sewing and
|
|
// update the effected displacements.
|
|
//-----------------------------------------------------------------------------
|
|
void PostFaceListSew( void )
|
|
{
|
|
// Destroy all corners, midpoint, edges.
|
|
int count = s_CornerData.Count();
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
SewCorner_Destroy( s_CornerData.Element( i ) );
|
|
}
|
|
|
|
count = s_TJData.Count();
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
SewTJunc_Destroy( s_TJData.Element( i ) );
|
|
}
|
|
|
|
count = s_EdgeData.Count();
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
SewEdge_Destroy( s_EdgeData.Element( i ) );
|
|
}
|
|
|
|
// Flush all of the sewing data buffers.
|
|
s_CornerData.Purge();
|
|
s_TJData.Purge();
|
|
s_EdgeData.Purge();
|
|
|
|
// Update the faces.
|
|
Faces_Update();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: given a face with a displacement surface, "sew" all edges to all
|
|
// neighboring displacement and non-displacement surfaces
|
|
// found in the selection set
|
|
//-----------------------------------------------------------------------------
|
|
void FaceListSewEdges( void )
|
|
{
|
|
// Setup.
|
|
PreFaceListSew();
|
|
|
|
// Resolve/Planarize unusable verts.
|
|
PlanarizeDependentVerts();
|
|
|
|
// Resolve sewing.
|
|
SewCorner_Resolve();
|
|
SewTJunc_Resolve();
|
|
SewEdge_Resolve();
|
|
|
|
// Update and clean-up.
|
|
PostFaceListSew();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
SewCornerData_t *SewCorner_Create( void )
|
|
{
|
|
SewCornerData_t *pCornerData = new SewCornerData_t;
|
|
if( pCornerData )
|
|
{
|
|
// initialize the data
|
|
pCornerData->faceCount = 0;
|
|
return pCornerData;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_Destroy( SewCornerData_t *pCornerData )
|
|
{
|
|
if( pCornerData )
|
|
{
|
|
delete pCornerData;
|
|
pCornerData = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewCorner_IsSolid( SewCornerData_t *pCornerData )
|
|
{
|
|
for( int i = 0; i < pCornerData->faceCount; i++ )
|
|
{
|
|
if( Face_IsSolid( pCornerData->pFaces[i] ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_Add( SewCornerData_t *pCornerData, CMapFace *pFace, int ndx )
|
|
{
|
|
if ( pCornerData->faceCount >= DISPSEW_FACES_AT_CORNER )
|
|
{
|
|
AfxMessageBox( "Warning: Too many displacement faces at corner!\n" );
|
|
return;
|
|
}
|
|
|
|
pCornerData->pFaces[pCornerData->faceCount] = pFace;
|
|
pCornerData->ndxCorners[pCornerData->faceCount] = ndx;
|
|
pCornerData->faceCount++;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_AddToList( SewCornerData_t *pCornerData )
|
|
{
|
|
// get the current corner point
|
|
Vector pt;
|
|
GetPointFromSurface( pCornerData->pFaces[0], pCornerData->ndxCorners[0], pt );
|
|
|
|
//
|
|
// check to see if the corner point already exists in the corner data list
|
|
//
|
|
int cornerCount = s_CornerData.Count();
|
|
|
|
for( int i = 0; i < cornerCount; i++ )
|
|
{
|
|
//
|
|
// get the compare corner point
|
|
//
|
|
SewCornerData_t *pCmpData = s_CornerData.Element( i );
|
|
if( !pCmpData )
|
|
continue;
|
|
|
|
Vector cmpPt;
|
|
GetPointFromSurface( pCmpData->pFaces[0], pCmpData->ndxCorners[0], cmpPt );
|
|
|
|
// compare the points - return if found
|
|
if( PointCompareWithTolerance( pt, cmpPt, DISPSEW_POINT_TOLERANCE ) )
|
|
{
|
|
SewCorner_Destroy( pCornerData );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// unique corner point -- add it to the list
|
|
s_CornerData.AddToTail( pCornerData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_Build( void )
|
|
{
|
|
//
|
|
// get the "faces" selection list (contains displaced and non-displaced faces)
|
|
//
|
|
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
|
|
if( !pSheet )
|
|
return;
|
|
|
|
//
|
|
// for each face in list
|
|
//
|
|
int faceCount = pSheet->GetFaceListCount();
|
|
|
|
for( int ndxFace = 0; ndxFace < faceCount; ndxFace++ )
|
|
{
|
|
// get the current face
|
|
CMapFace *pFace = pSheet->GetFaceListDataFace( ndxFace );
|
|
if( !pFace )
|
|
continue;
|
|
|
|
//
|
|
// for each face point
|
|
//
|
|
int ptCount = pFace->GetPointCount();
|
|
for( int ndxPt = 0; ndxPt < ptCount; ndxPt++ )
|
|
{
|
|
// get the current point
|
|
Vector pt;
|
|
GetPointFromSurface( pFace, ndxPt, pt );
|
|
|
|
// allocate new corner point
|
|
SewCornerData_t *pCornerData = SewCorner_Create();
|
|
if( !pCornerData )
|
|
return;
|
|
|
|
//
|
|
// compare this point to all of the other points on all the other faces in the list
|
|
//
|
|
for( int ndxFace2 = 0; ndxFace2 < faceCount; ndxFace2++ )
|
|
{
|
|
// don't compare to itself
|
|
if( ndxFace == ndxFace2 )
|
|
continue;
|
|
|
|
// get the current compare face
|
|
CMapFace *pFace2 = pSheet->GetFaceListDataFace( ndxFace2 );
|
|
if( !pFace2 )
|
|
continue;
|
|
|
|
//
|
|
// for each compare face point
|
|
//
|
|
int ptCount2 = pFace2->GetPointCount();
|
|
for( int ndxPt2 = 0; ndxPt2 < ptCount2; ndxPt2++ )
|
|
{
|
|
// get the current compare point
|
|
Vector pt2;
|
|
GetPointFromSurface( pFace2, ndxPt2, pt2 );
|
|
|
|
// compare pt1 and pt2
|
|
if( PointCompareWithTolerance( pt, pt2, DISPSEW_POINT_TOLERANCE ) )
|
|
{
|
|
SewCorner_Add( pCornerData, pFace2, ndxPt2 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// had neighbors -- add base point and add it to corner list
|
|
if( pCornerData->faceCount > 0 )
|
|
{
|
|
SewCorner_Add( pCornerData, pFace, ndxPt );
|
|
SewCorner_AddToList( pCornerData );
|
|
}
|
|
// no neighbors -- de-allocate
|
|
else
|
|
{
|
|
SewCorner_Destroy( pCornerData );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_ResolveDisp( SewCornerData_t *pCornerData )
|
|
{
|
|
// the field data accumulators
|
|
float avgDist = 0.0f;
|
|
Vector vAvgField( 0.0f, 0.0f, 0.0f );
|
|
Vector vAvgSubdivPos( 0.0f, 0.0f, 0.0f );
|
|
Vector vAvgSubdivNormal( 0.0f, 0.0f, 0.0f );
|
|
float flAvgAlpha = 0.0f;
|
|
|
|
Vector4D vAvgMultiBlend, vAvgAlphaBlend;
|
|
Vector vAvgColor1, vAvgColor2, vAvgColor3, vAvgColor4;
|
|
|
|
vAvgMultiBlend.Init();
|
|
vAvgAlphaBlend.Init();
|
|
vAvgColor1.Init();
|
|
vAvgColor2.Init();
|
|
vAvgColor3.Init();
|
|
vAvgColor4.Init();
|
|
|
|
int i;
|
|
|
|
// Blend the alpha?
|
|
bool bBlendAlpha = true;
|
|
char szMatName1[128];
|
|
char szMatName2[128];
|
|
bool bInitMat = false;
|
|
for( i = 0; i < pCornerData->faceCount; i++ )
|
|
{
|
|
// get the current corner face
|
|
CMapFace *pFace = pCornerData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
if ( !bInitMat )
|
|
{
|
|
pFace->GetTexture()->GetShortName( szMatName1 );
|
|
bInitMat = true;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
pFace->GetTexture()->GetShortName( szMatName2 );
|
|
if ( strcmpi( szMatName1, szMatName2 ) )
|
|
{
|
|
bBlendAlpha = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// for all the faces at the corner
|
|
for( i = 0; i < pCornerData->faceCount; i++ )
|
|
{
|
|
// get the current corner face
|
|
CMapFace *pFace = pCornerData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the corner index
|
|
int ndxPt = GetCornerPointIndex( pDisp, pCornerData->ndxCorners[i] );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
Vector vecPos;
|
|
pDisp->GetVert( ndxPt, vecPos );
|
|
|
|
float dist = pDisp->GetFieldDistance( ndxPt );
|
|
avgDist += dist;
|
|
|
|
Vector vTmp;
|
|
pDisp->GetFieldVector( ndxPt, vTmp );
|
|
vAvgField += vTmp;
|
|
|
|
pDisp->GetSubdivPosition( ndxPt, vTmp );
|
|
vAvgSubdivPos += vTmp;
|
|
|
|
pDisp->GetSubdivNormal( ndxPt, vTmp );
|
|
vAvgSubdivNormal += vTmp;
|
|
|
|
if ( bBlendAlpha )
|
|
{
|
|
flAvgAlpha += pDisp->GetAlpha( ndxPt );
|
|
}
|
|
|
|
Vector4D vMultiBlend, vAlphaBlend;
|
|
Vector vColor1, vColor2, vColor3, vColor4;
|
|
|
|
pDisp->GetMultiBlend( ndxPt, vMultiBlend, vAlphaBlend, vColor1, vColor2, vColor3, vColor4 );
|
|
vAvgMultiBlend += vMultiBlend;
|
|
vAvgAlphaBlend += vAlphaBlend;
|
|
vAvgColor1 += vColor1;
|
|
vAvgColor2 += vColor2;
|
|
vAvgColor3 += vColor3;
|
|
vAvgColor4 += vColor4;
|
|
}
|
|
|
|
// calculate the average
|
|
avgDist /= pCornerData->faceCount;
|
|
vAvgField /= pCornerData->faceCount;
|
|
vAvgSubdivPos /= pCornerData->faceCount;
|
|
vAvgSubdivNormal /= pCornerData->faceCount;
|
|
if ( bBlendAlpha )
|
|
{
|
|
flAvgAlpha /= pCornerData->faceCount;
|
|
}
|
|
vAvgMultiBlend /= pCornerData->faceCount;
|
|
vAvgAlphaBlend /= pCornerData->faceCount;
|
|
vAvgColor1 /= pCornerData->faceCount;
|
|
vAvgColor2 /= pCornerData->faceCount;
|
|
vAvgColor3 /= pCornerData->faceCount;
|
|
vAvgColor4 /= pCornerData->faceCount;
|
|
|
|
for( int i = 0; i < pCornerData->faceCount; i++ )
|
|
{
|
|
// get the current corner face
|
|
CMapFace *pFace = pCornerData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the corner index
|
|
int ndxPt = GetCornerPointIndex( pDisp, pCornerData->ndxCorners[i] );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
// set the averaged values
|
|
pDisp->SetFieldDistance( ndxPt, avgDist );
|
|
pDisp->SetFieldVector( ndxPt, vAvgField );
|
|
pDisp->SetSubdivPosition( ndxPt, vAvgSubdivPos );
|
|
pDisp->SetSubdivNormal( ndxPt, vAvgSubdivNormal );
|
|
if ( bBlendAlpha )
|
|
{
|
|
pDisp->SetAlpha( ndxPt, flAvgAlpha );
|
|
}
|
|
pDisp->SetMultiBlend( ndxPt, vAvgMultiBlend, vAvgAlphaBlend, vAvgColor1, vAvgColor2, vAvgColor3, vAvgColor4 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_ResolveSolid( SewCornerData_t *pCornerData )
|
|
{
|
|
// create a clear vector - to reset the offset vector
|
|
Vector vClear( 0.0f, 0.0f, 0.0f );
|
|
Vector vSet( 1.0f, 1.0f, 1.0f );
|
|
Vector4D vClearMultiBlend, vClearAlphaBlend;
|
|
|
|
vClearMultiBlend.Init();
|
|
vClearAlphaBlend.Init();
|
|
|
|
// for all the faces at the corner
|
|
for( int i = 0; i < pCornerData->faceCount; i++ )
|
|
{
|
|
// get the current corner face
|
|
CMapFace *pFace = pCornerData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the face normal -- to reset the field vector
|
|
Vector vNormal;
|
|
pDisp->GetSurfNormal( vNormal );
|
|
|
|
// get the corner index
|
|
int ndxPt = GetCornerPointIndex( pDisp, pCornerData->ndxCorners[i] );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset all neighbor surface data - field vector, distance, and offset
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vNormal );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewCorner_Resolve( void )
|
|
{
|
|
// get the number of corners in the corner list
|
|
int cornerCount = s_CornerData.Count();
|
|
|
|
// resolve each corner
|
|
for( int i = 0; i < cornerCount; i++ )
|
|
{
|
|
// get the current corner data struct
|
|
SewCornerData_t *pCornerData = s_CornerData.Element( i );
|
|
if( !pCornerData )
|
|
continue;
|
|
|
|
// determine if any of the faces is solid
|
|
bool bSolid = SewCorner_IsSolid( pCornerData );
|
|
|
|
// solid at corner -- reset corner data
|
|
if( bSolid )
|
|
{
|
|
SewCorner_ResolveSolid( pCornerData );
|
|
}
|
|
// all disps at corner -- average
|
|
else
|
|
{
|
|
SewCorner_ResolveDisp( pCornerData );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
SewTJuncData_t *SewTJunc_Create( void )
|
|
{
|
|
SewTJuncData_t *pTJData = new SewTJuncData_t;
|
|
if( pTJData )
|
|
{
|
|
// initialize the data
|
|
pTJData->faceCount = 0;
|
|
return pTJData;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_Destroy( SewTJuncData_t *pTJData )
|
|
{
|
|
if( pTJData )
|
|
{
|
|
delete pTJData;
|
|
pTJData = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewTJunc_IsSolid( SewTJuncData_t *pTJData )
|
|
{
|
|
for( int i = 0; i < pTJData->faceCount; i++ )
|
|
{
|
|
if( Face_IsSolid( pTJData->pFaces[i] ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_Add( SewTJuncData_t *pTJData, CMapFace *pFace, int ndxCorner, int ndxEdge )
|
|
{
|
|
if ( pTJData->faceCount >= DISPSEW_FACES_AT_TJUNC )
|
|
{
|
|
AfxMessageBox( "Warning: Too many displacement faces at t-junction!\n" );
|
|
return;
|
|
}
|
|
|
|
pTJData->pFaces[pTJData->faceCount] = pFace;
|
|
pTJData->ndxCorners[pTJData->faceCount] = ndxCorner;
|
|
pTJData->ndxEdges[pTJData->faceCount] = ndxEdge;
|
|
pTJData->faceCount++;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_AddToList( SewTJuncData_t *pTJData )
|
|
{
|
|
// get the current t-junction point
|
|
Vector pt;
|
|
GetPointFromSurface( pTJData->pFaces[0], pTJData->ndxCorners[0], pt );
|
|
|
|
//
|
|
// check to see if the t-junction point already exists in the t-junction data list
|
|
//
|
|
int tjCount = s_TJData.Count();
|
|
for( int i = 0; i < tjCount; i++ )
|
|
{
|
|
// get the compare t-junction point
|
|
SewTJuncData_t *pCmpData = s_TJData.Element( i );
|
|
if( !pCmpData )
|
|
continue;
|
|
|
|
Vector cmpPt;
|
|
GetPointFromSurface( pCmpData->pFaces[0], pCmpData->ndxCorners[0], cmpPt );
|
|
|
|
// compare the points - return if found
|
|
if( PointCompareWithTolerance( pt, cmpPt, DISPSEW_POINT_TOLERANCE ) )
|
|
{
|
|
SewTJunc_Destroy( pTJData );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// unique t-junction point -- add it to the list
|
|
s_TJData.AddToTail( pTJData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_Build( void )
|
|
{
|
|
//
|
|
// get the "faces" selection list (contains displaced and non-displaced faces)
|
|
//
|
|
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
|
|
if( !pSheet )
|
|
return;
|
|
|
|
//
|
|
// for each face in list
|
|
//
|
|
int faceCount = pSheet->GetFaceListCount();
|
|
|
|
for( int ndxFace = 0; ndxFace < faceCount; ndxFace++ )
|
|
{
|
|
// get the current face
|
|
CMapFace *pFace = pSheet->GetFaceListDataFace( ndxFace );
|
|
if( !pFace )
|
|
continue;
|
|
|
|
//
|
|
// for each face point
|
|
//
|
|
int ptCount = pFace->GetPointCount();
|
|
for( int ndxPt = 0; ndxPt < ptCount; ndxPt++ )
|
|
{
|
|
// get the current t-junction point
|
|
Vector pt, tmpPt1, tmpPt2;
|
|
GetPointFromSurface( pFace, ndxPt, tmpPt1 );
|
|
GetPointFromSurface( pFace, (ndxPt+1)%ptCount, tmpPt2 );
|
|
pt = ( tmpPt1 + tmpPt2 ) * 0.5f;
|
|
|
|
// allocate new corner point
|
|
SewTJuncData_t *pTJData = SewTJunc_Create();
|
|
if( !pTJData )
|
|
return;
|
|
|
|
//
|
|
// compare this point to all of the other points on all the other faces in the list
|
|
//
|
|
for( int ndxFace2 = 0; ndxFace2 < faceCount; ndxFace2++ )
|
|
{
|
|
// don't compare to itself
|
|
if( ndxFace == ndxFace2 )
|
|
continue;
|
|
|
|
// get the current compare face
|
|
CMapFace *pFace2 = pSheet->GetFaceListDataFace( ndxFace2 );
|
|
if( !pFace2 )
|
|
continue;
|
|
|
|
//
|
|
// for each compare face point
|
|
//
|
|
int ptCount2 = pFace2->GetPointCount();
|
|
for( int ndxPt2 = 0; ndxPt2 < ptCount2; ndxPt2++ )
|
|
{
|
|
// get the current compare point
|
|
Vector pt2;
|
|
GetPointFromSurface( pFace2, ndxPt2, pt2 );
|
|
|
|
// compare pt1 and pt2
|
|
if( PointCompareWithTolerance( pt, pt2, DISPSEW_POINT_TOLERANCE ) )
|
|
{
|
|
SewTJunc_Add( pTJData, pFace2, ndxPt2, -1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// had neighbors -- add base point and add it to corner list
|
|
if( pTJData->faceCount > 0 )
|
|
{
|
|
SewTJunc_Add( pTJData, pFace, -1, ndxPt );
|
|
SewTJunc_AddToList( pTJData );
|
|
}
|
|
// no neighbors -- de-allocate
|
|
else
|
|
{
|
|
SewTJunc_Destroy( pTJData );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_ResolveDisp( SewTJuncData_t *pTJData )
|
|
{
|
|
// the field data accumulators
|
|
float avgDist = 0.0f;
|
|
Vector vAvgField( 0.0f, 0.0f, 0.0f );
|
|
Vector vAvgSubdivPos( 0.0f, 0.0f, 0.0f );
|
|
Vector vAvgSubdivNormal( 0.0f, 0.0f, 0.0f );
|
|
float flAvgAlpha = 0.0f;
|
|
Vector4D vAvgMultiBlend, vAvgAlphaBlend;
|
|
Vector vAvgColor1, vAvgColor2, vAvgColor3, vAvgColor4;
|
|
|
|
vAvgMultiBlend.Init();
|
|
vAvgAlphaBlend.Init();
|
|
vAvgColor1.Init();
|
|
vAvgColor2.Init();
|
|
vAvgColor3.Init();
|
|
vAvgColor4.Init();
|
|
|
|
// for all the faces at the t-junction
|
|
for( int i = 0; i < pTJData->faceCount; i++ )
|
|
{
|
|
// get the current t-junction face
|
|
CMapFace *pFace = pTJData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the t-junction index
|
|
int ndxPt = -1;
|
|
if( pTJData->ndxCorners[i] != -1 )
|
|
{
|
|
ndxPt = GetCornerPointIndex( pDisp, pTJData->ndxCorners[i] );
|
|
}
|
|
else if( pTJData->ndxEdges[i] != -1 )
|
|
{
|
|
int ndxEdgePt = pDisp->GetWidth() / 2;
|
|
ndxPt = GetEdgePointIndex( pDisp, pTJData->ndxEdges[i], ndxEdgePt, true );
|
|
}
|
|
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
float dist = pDisp->GetFieldDistance( ndxPt );
|
|
avgDist += dist;
|
|
|
|
Vector vTmp;
|
|
pDisp->GetFieldVector( ndxPt, vTmp );
|
|
vAvgField += vTmp;
|
|
|
|
pDisp->GetSubdivPosition( ndxPt, vTmp );
|
|
vAvgSubdivPos += vTmp;
|
|
|
|
pDisp->GetSubdivNormal( ndxPt, vTmp );
|
|
vAvgSubdivNormal += vTmp;
|
|
|
|
flAvgAlpha += pDisp->GetAlpha( ndxPt );
|
|
|
|
Vector4D vMultiBlend, vAlphaBlend;
|
|
Vector vColor1, vColor2, vColor3, vColor4;
|
|
|
|
pDisp->GetMultiBlend( ndxPt, vMultiBlend, vAlphaBlend, vColor1, vColor2, vColor3, vColor4 );
|
|
vAvgMultiBlend += vMultiBlend;
|
|
vAvgAlphaBlend += vAlphaBlend;
|
|
vAvgColor1 += vColor1;
|
|
vAvgColor2 += vColor2;
|
|
vAvgColor3 += vColor3;
|
|
vAvgColor4 += vColor4;
|
|
}
|
|
|
|
// calculate the average
|
|
avgDist /= pTJData->faceCount;
|
|
vAvgField /= pTJData->faceCount;
|
|
vAvgSubdivPos /= pTJData->faceCount;
|
|
vAvgSubdivNormal /= pTJData->faceCount;
|
|
flAvgAlpha /= pTJData->faceCount;
|
|
vAvgMultiBlend /= pTJData->faceCount;
|
|
vAvgAlphaBlend /= pTJData->faceCount;
|
|
vAvgColor1 /= pTJData->faceCount;
|
|
vAvgColor2 /= pTJData->faceCount;
|
|
vAvgColor3 /= pTJData->faceCount;
|
|
vAvgColor4 /= pTJData->faceCount;
|
|
|
|
for( int i = 0; i < pTJData->faceCount; i++ )
|
|
{
|
|
// get the current t-junction face
|
|
CMapFace *pFace = pTJData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the t-junction index
|
|
int ndxPt = -1;
|
|
if( pTJData->ndxCorners[i] != -1 )
|
|
{
|
|
ndxPt = GetCornerPointIndex( pDisp, pTJData->ndxCorners[i] );
|
|
}
|
|
else if( pTJData->ndxEdges[i] != -1 )
|
|
{
|
|
int ndxEdgePt = pDisp->GetWidth() / 2;
|
|
ndxPt = GetEdgePointIndex( pDisp, pTJData->ndxEdges[i], ndxEdgePt, true );
|
|
}
|
|
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
// set the averaged values
|
|
pDisp->SetFieldDistance( ndxPt, avgDist );
|
|
pDisp->SetFieldVector( ndxPt, vAvgField );
|
|
pDisp->SetSubdivPosition( ndxPt, vAvgSubdivPos );
|
|
pDisp->SetSubdivNormal( ndxPt, vAvgSubdivNormal );
|
|
pDisp->SetAlpha( ndxPt, flAvgAlpha );
|
|
pDisp->SetMultiBlend( ndxPt, vAvgMultiBlend, vAvgAlphaBlend, vAvgColor1, vAvgColor2, vAvgColor3, vAvgColor4 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_ResolveSolid( SewTJuncData_t *pTJData )
|
|
{
|
|
// create a clear vector - to reset the offset vector
|
|
Vector vClear( 0.0f, 0.0f, 0.0f );
|
|
Vector vSet( 1.0f, 1.0f, 1.0f );
|
|
Vector4D vClearMultiBlend, vClearAlphaBlend;
|
|
|
|
vClearMultiBlend.Init();
|
|
vClearAlphaBlend.Init();
|
|
|
|
// for all the faces at the t-junction
|
|
for( int i = 0; i < pTJData->faceCount; i++ )
|
|
{
|
|
// get the current t-junction face
|
|
CMapFace *pFace = pTJData->pFaces[i];
|
|
if( !pFace )
|
|
continue;
|
|
|
|
// get the current displacement surface to reset, if solid = done!
|
|
EditDispHandle_t dispHandle = pFace->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get the face normal -- to reset the field vector
|
|
Vector vNormal;
|
|
pDisp->GetSurfNormal( vNormal );
|
|
|
|
// get the t-junction index
|
|
int ndxPt = -1;
|
|
if( pTJData->ndxCorners[i] != -1 )
|
|
{
|
|
ndxPt = GetCornerPointIndex( pDisp, pTJData->ndxCorners[i] );
|
|
}
|
|
else if( pTJData->ndxEdges[i] != -1 )
|
|
{
|
|
int ndxEdgePt = pDisp->GetWidth() / 2;
|
|
ndxPt = GetEdgePointIndex( pDisp, pTJData->ndxEdges[i], ndxEdgePt, true );
|
|
}
|
|
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset all neighbor surface data - field vector, distance, and offset
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vNormal );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewTJunc_Resolve( void )
|
|
{
|
|
// get the number of t-junctions in the t-junction list
|
|
int tjCount = s_TJData.Count();
|
|
|
|
// resolve each t-junction
|
|
for( int i = 0; i < tjCount; i++ )
|
|
{
|
|
// get the current t-junction data struct
|
|
SewTJuncData_t *pTJData = s_TJData.Element( i );
|
|
if( !pTJData )
|
|
continue;
|
|
|
|
// determine if any of the faces is solid
|
|
bool bSolid = SewTJunc_IsSolid( pTJData );
|
|
|
|
// solid at t-junction -- reset t-junction data
|
|
if( bSolid )
|
|
{
|
|
SewTJunc_ResolveSolid( pTJData );
|
|
}
|
|
// all disps at t-junction -- average
|
|
else
|
|
{
|
|
SewTJunc_ResolveDisp( pTJData );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
SewEdgeData_t *SewEdge_Create( void )
|
|
{
|
|
SewEdgeData_t *pEdgeData = new SewEdgeData_t;
|
|
if( pEdgeData )
|
|
{
|
|
// initialize the data
|
|
pEdgeData->faceCount = 0;
|
|
return pEdgeData;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_Destroy( SewEdgeData_t *pEdgeData )
|
|
{
|
|
if( pEdgeData )
|
|
{
|
|
delete pEdgeData;
|
|
pEdgeData = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline bool SewEdge_IsSolidNormal( SewEdgeData_t *pEdgeData )
|
|
{
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
if( Face_IsSolid( pEdgeData->pFaces[i] ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline int SewEdge_TJIndex( SewEdgeData_t *pEdgeData, int type )
|
|
{
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
if( pEdgeData->type[i] == type )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline bool SewEdge_IsSolidTJunc( SewEdgeData_t *pEdgeData, int type )
|
|
{
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
if( pEdgeData->type[i] != type )
|
|
continue;
|
|
|
|
if( Face_IsSolid( pEdgeData->pFaces[i] ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewEdge_Add( SewEdgeData_t *pEdgeData, CMapFace *pFace, int ndxEdge, int type )
|
|
{
|
|
if ( pEdgeData->faceCount >= DISPSEW_FACES_AT_EDGE )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Add face to edge.
|
|
pEdgeData->pFaces[pEdgeData->faceCount] = pFace;
|
|
pEdgeData->ndxEdges[pEdgeData->faceCount] = ndxEdge;
|
|
pEdgeData->type[pEdgeData->faceCount] = type;
|
|
pEdgeData->faceCount++;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewEdge_AddToListMerge( SewEdgeData_t *pEdgeData, SewEdgeData_t *pCmpData )
|
|
{
|
|
bool bReturn = true;
|
|
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
// t-junction edges already exist in both (skip it!)
|
|
if( pEdgeData->type[i] == DISPSEW_EDGE_TJ )
|
|
continue;
|
|
|
|
int j;
|
|
for( j = 0; j < pCmpData->faceCount; j++ )
|
|
{
|
|
// t-junction edges already exist in both (skip it!)
|
|
if( pCmpData->type[j] == DISPSEW_EDGE_TJ )
|
|
continue;
|
|
|
|
if( pEdgeData->type[i] == pCmpData->type[j] )
|
|
break;
|
|
}
|
|
|
|
// no match found -- add it
|
|
if( j == pCmpData->faceCount )
|
|
{
|
|
if (!SewEdge_Add( pCmpData, pEdgeData->pFaces[i], pEdgeData->ndxEdges[i], pEdgeData->type[i] ))
|
|
{
|
|
bReturn = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewEdge_AddToListTJunc( SewEdgeData_t *pEdgeData )
|
|
{
|
|
// find the t-junction edge
|
|
int ndxTJ = SewEdge_TJIndex( pEdgeData, DISPSEW_EDGE_TJ );
|
|
if( ndxTJ == -1 )
|
|
return true;
|
|
|
|
// get the t-junction edge point count
|
|
int ptCount = pEdgeData->pFaces[ndxTJ]->GetPointCount();
|
|
|
|
// get the current t-junction edge (edge points)
|
|
Vector edgePts[2];
|
|
GetPointFromSurface( pEdgeData->pFaces[ndxTJ], pEdgeData->ndxEdges[ndxTJ], edgePts[0] );
|
|
GetPointFromSurface( pEdgeData->pFaces[ndxTJ], (pEdgeData->ndxEdges[ndxTJ]+1)%ptCount, edgePts[1] );
|
|
|
|
//
|
|
// check to see if the edge already exists in the edge data list
|
|
//
|
|
int edgeCount = s_EdgeData.Count();
|
|
for( int i = 0; i < edgeCount; i++ )
|
|
{
|
|
// get the edge points to compare against
|
|
SewEdgeData_t *pCmpData = s_EdgeData.Element( i );
|
|
if( !pCmpData )
|
|
continue;
|
|
|
|
// get the compare t-junction edge
|
|
int ndxCmp = SewEdge_TJIndex( pCmpData, DISPSEW_EDGE_TJ );
|
|
if( ndxCmp == -1 )
|
|
continue;
|
|
|
|
// get the compare face point count
|
|
int ptCount2 = pCmpData->pFaces[ndxCmp]->GetPointCount();
|
|
|
|
Vector edgePts2[2];
|
|
GetPointFromSurface( pCmpData->pFaces[ndxCmp], pCmpData->ndxEdges[ndxCmp], edgePts2[0] );
|
|
GetPointFromSurface( pCmpData->pFaces[ndxCmp], (pCmpData->ndxEdges[ndxCmp]+1)%ptCount2, edgePts2[1] );
|
|
|
|
// compare the edges -- return if found
|
|
int edgeType1, edgeType2;
|
|
if( EdgeCompare( edgePts, edgePts2, edgeType1, edgeType2 ) )
|
|
{
|
|
bool bReturn = SewEdge_AddToListMerge( pEdgeData, pCmpData );
|
|
SewEdge_Destroy( pEdgeData );
|
|
return bReturn;
|
|
}
|
|
}
|
|
|
|
// unique edge -- add it to the list
|
|
s_EdgeData.AddToTail( pEdgeData );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_AddToListNormal( SewEdgeData_t *pEdgeData )
|
|
{
|
|
// get the face point count
|
|
int ptCount = pEdgeData->pFaces[0]->GetPointCount();
|
|
|
|
// get the current edge (edge points)
|
|
Vector edgePts[2];
|
|
GetPointFromSurface( pEdgeData->pFaces[0], pEdgeData->ndxEdges[0], edgePts[0] );
|
|
GetPointFromSurface( pEdgeData->pFaces[0], (pEdgeData->ndxEdges[0]+1)%ptCount, edgePts[1] );
|
|
|
|
//
|
|
// check to see if the edge already exists in the edge data list
|
|
//
|
|
int edgeCount = s_EdgeData.Count();
|
|
for( int i = 0; i < edgeCount; i++ )
|
|
{
|
|
// get the edge points to compare against
|
|
SewEdgeData_t *pCmpData = s_EdgeData.Element( i );
|
|
if( !pCmpData )
|
|
continue;
|
|
|
|
// compare against each edge (all colinear) in struct
|
|
for( int j = 0; j < pCmpData->faceCount; j++ )
|
|
{
|
|
// get the compare face point count
|
|
int ptCount2 = pCmpData->pFaces[j]->GetPointCount();
|
|
|
|
Vector edgePts2[2];
|
|
GetPointFromSurface( pCmpData->pFaces[j], pCmpData->ndxEdges[j], edgePts2[0] );
|
|
GetPointFromSurface( pCmpData->pFaces[j], (pCmpData->ndxEdges[j]+1)%ptCount2, edgePts2[1] );
|
|
|
|
// compare the edges -- return if found
|
|
int edgeType1, edgeType2;
|
|
if( EdgeCompare( edgePts, edgePts2, edgeType1, edgeType2 ) )
|
|
{
|
|
SewEdge_Destroy( pEdgeData );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// unique edge -- add it to the list
|
|
s_EdgeData.AddToTail( pEdgeData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool SewEdge_AddToList( SewEdgeData_t *pEdgeData )
|
|
{
|
|
// if this is a "normal" edge - handle it
|
|
if( pEdgeData->type[0] == DISPSEW_EDGE_NORMAL )
|
|
{
|
|
SewEdge_AddToListNormal( pEdgeData );
|
|
return true;
|
|
}
|
|
|
|
// this is a "t-junction" edge - handle it
|
|
return SewEdge_AddToListTJunc( pEdgeData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_Build( void )
|
|
{
|
|
//
|
|
// get the "faces" selection list (contains displaced and non-displaced faces)
|
|
//
|
|
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
|
|
if( !pSheet )
|
|
return;
|
|
|
|
bool bError = false;
|
|
|
|
//
|
|
// for each face in list
|
|
//
|
|
int faceCount = pSheet->GetFaceListCount();
|
|
|
|
for( int ndxFace = 0; ndxFace < faceCount; ndxFace++ )
|
|
{
|
|
// get the current face
|
|
CMapFace *pFace = pSheet->GetFaceListDataFace( ndxFace );
|
|
if( !pFace )
|
|
continue;
|
|
|
|
//
|
|
// for each face edge
|
|
//
|
|
int ptCount = pFace->GetPointCount();
|
|
for( int ndxPt = 0; ndxPt < ptCount; ndxPt++ )
|
|
{
|
|
// get the current edge points
|
|
int type1_keep = 0;
|
|
Vector edgePts[2];
|
|
GetPointFromSurface( pFace, ndxPt, edgePts[0] );
|
|
GetPointFromSurface( pFace, (ndxPt+1)%ptCount, edgePts[1] );
|
|
|
|
// allocate new edge
|
|
SewEdgeData_t *pEdgeData = SewEdge_Create();
|
|
if( !pEdgeData )
|
|
return;
|
|
|
|
//
|
|
// compare this edge to all of the other edges on all the other faces in the list
|
|
//
|
|
for( int ndxFace2 = 0; ndxFace2 < faceCount; ndxFace2++ )
|
|
{
|
|
// don't compare to itself
|
|
if( ndxFace == ndxFace2 )
|
|
continue;
|
|
|
|
// get the current compare face
|
|
CMapFace *pFace2 = pSheet->GetFaceListDataFace( ndxFace2 );
|
|
if( !pFace2 )
|
|
continue;
|
|
|
|
//
|
|
// for each compare face edge
|
|
//
|
|
int ptCount2 = pFace2->GetPointCount();
|
|
for( int ndxPt2 = 0; ndxPt2 < ptCount2; ndxPt2++ )
|
|
{
|
|
// get the current compare edge point
|
|
Vector edgePts2[2];
|
|
GetPointFromSurface( pFace2, ndxPt2, edgePts2[0] );
|
|
GetPointFromSurface( pFace2, (ndxPt2+1)%ptCount2, edgePts2[1] );
|
|
|
|
// compare pt1 and pt2
|
|
int type1, type2;
|
|
if( EdgeCompare( edgePts, edgePts2, type1, type2 ) )
|
|
{
|
|
if (!SewEdge_Add( pEdgeData, pFace2, ndxPt2, type2 ))
|
|
{
|
|
bError = true;
|
|
}
|
|
type1_keep = type1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// had neighbors -- add base point and add it to corner list
|
|
if( pEdgeData->faceCount > 0 )
|
|
{
|
|
if (!SewEdge_Add( pEdgeData, pFace, ndxPt, type1_keep ))
|
|
{
|
|
bError = true;
|
|
}
|
|
|
|
if (!SewEdge_AddToList( pEdgeData ))
|
|
{
|
|
bError = true;
|
|
}
|
|
}
|
|
// no neighbors -- de-allocate
|
|
else
|
|
{
|
|
SewEdge_Destroy( pEdgeData );
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bError)
|
|
{
|
|
AfxMessageBox("Not all selected faces could be sewn because too many selected faces share a single edge.\n\nLook for places where 3 or more selected faces (displacement or non-displacement) all share an edge.");
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_ResolveDispTJunc( SewEdgeData_t *pEdgeData, int ndxTJ, int ndxTJNeighbor, bool bStart )
|
|
{
|
|
//
|
|
// handle displacement sewing to displacement t-junction edge
|
|
//
|
|
EditDispHandle_t tjEdgeHandle = pEdgeData->pFaces[ndxTJ]->GetDisp();
|
|
EditDispHandle_t edgeHandle = pEdgeData->pFaces[ndxTJNeighbor]->GetDisp();
|
|
if( ( tjEdgeHandle == EDITDISPHANDLE_INVALID ) || ( edgeHandle == EDITDISPHANDLE_INVALID ) )
|
|
return;
|
|
|
|
CMapDisp *pTJEdgeDisp = EditDispMgr()->GetDisp( tjEdgeHandle );
|
|
CMapDisp *pEdgeDisp = EditDispMgr()->GetDisp( edgeHandle );
|
|
|
|
//
|
|
// get the t-junction edge interval (or half of it)
|
|
//
|
|
int tjWidth = pTJEdgeDisp->GetWidth();
|
|
int tjInterval = pTJEdgeDisp->GetWidth() / 2;
|
|
|
|
//
|
|
// get edge interval
|
|
//
|
|
int edgeWidth = pEdgeDisp->GetWidth();
|
|
int edgeInterval = pEdgeDisp->GetWidth();
|
|
|
|
int ratio = ( edgeInterval - 1 ) / tjInterval;
|
|
|
|
bool bFlip = ( ratio < 1 );
|
|
if( bFlip )
|
|
{
|
|
ratio = tjInterval / ( edgeInterval - 1 );
|
|
}
|
|
|
|
//
|
|
// average the "like" points
|
|
//
|
|
if( bStart )
|
|
{
|
|
if( bFlip )
|
|
{
|
|
for( int i = 1, j = ratio; i < edgeInterval; i++, j += ratio )
|
|
{
|
|
int ndxTJPt, ndxEdgePt;
|
|
ndxTJPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], j, true );
|
|
ndxEdgePt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], i, false );
|
|
|
|
// average
|
|
AverageVectorFieldData( pEdgeDisp, ndxEdgePt, pTJEdgeDisp, ndxTJPt );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int i = 1, j = ratio; i < tjInterval; i++, j += ratio )
|
|
{
|
|
int ndxTJPt, ndxEdgePt;
|
|
|
|
ndxTJPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], i, true );
|
|
ndxEdgePt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], j, false );
|
|
|
|
// average
|
|
AverageVectorFieldData( pEdgeDisp, ndxEdgePt, pTJEdgeDisp, ndxTJPt );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( bFlip )
|
|
{
|
|
for( int i = 1, j = ratio; i < edgeWidth; i++, j += ratio )
|
|
{
|
|
int ndxTJPt, ndxEdgePt;
|
|
ndxTJPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], j, false );
|
|
ndxEdgePt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], i, true );
|
|
|
|
// average
|
|
AverageVectorFieldData( pEdgeDisp, ndxEdgePt, pTJEdgeDisp, ndxTJPt );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int i = ( tjInterval + 1 ), j = ratio; i < ( tjWidth - 1 ); i++, j += ratio )
|
|
{
|
|
int ndxTJPt, ndxEdgePt;
|
|
ndxTJPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], i, true );
|
|
ndxEdgePt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], j, false );
|
|
|
|
// average
|
|
AverageVectorFieldData( pEdgeDisp, ndxEdgePt, pTJEdgeDisp, ndxTJPt );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// linearly interpolate the "unlike" points
|
|
//
|
|
float blendRatio = 1.0f / ratio;
|
|
|
|
if( bFlip )
|
|
{
|
|
for( int i = 0; i < ( tjWidth - ratio ); i += ratio )
|
|
{
|
|
int ndxStart = i;
|
|
int ndxEnd = ( i + ratio );
|
|
|
|
int ndxStartPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], ndxStart, true );
|
|
int ndxEndPt = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], ndxEnd, true );
|
|
|
|
for( int j = ( ndxStart + 1 ); j < ndxEnd; j++ )
|
|
{
|
|
float blend = blendRatio * ( j - ndxStart );
|
|
|
|
int ndxDst = GetEdgePointIndex( pTJEdgeDisp, pEdgeData->ndxEdges[ndxTJ], j, true );
|
|
|
|
BlendVectorFieldData( pTJEdgeDisp, ndxStartPt, ndxDst, pTJEdgeDisp, ndxEndPt, ndxDst, blend );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0; i < ( edgeWidth - ratio ); i += ratio )
|
|
{
|
|
int ndxStart = i;
|
|
int ndxEnd = ( i + ratio );
|
|
|
|
int ndxStartPt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], ndxStart, true );
|
|
int ndxEndPt = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], ndxEnd, true );
|
|
|
|
for( int j = ( ndxStart + 1 ); j < ndxEnd; j++ )
|
|
{
|
|
float blend = blendRatio * ( j - ndxStart );
|
|
|
|
int ndxDst = GetEdgePointIndex( pEdgeDisp, pEdgeData->ndxEdges[ndxTJNeighbor], j, true );
|
|
|
|
BlendVectorFieldData( pEdgeDisp, ndxStartPt, ndxDst, pEdgeDisp, ndxEndPt, ndxDst, blend );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_ResolveSolidTJunc( SewEdgeData_t *pEdgeData, int type, bool bStart )
|
|
{
|
|
// create an empty vector to reset the offset with
|
|
Vector vClear( 0.0f, 0.0f, 0.0f );
|
|
Vector vSet( 1.0f, 1.0f, 1.0f );
|
|
Vector4D vClearMultiBlend, vClearAlphaBlend;
|
|
|
|
vClearMultiBlend.Init();
|
|
vClearAlphaBlend.Init();
|
|
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
if( pEdgeData->type[i] != type )
|
|
continue;
|
|
|
|
// get the displacement surface associated with the face
|
|
EditDispHandle_t dispHandle = pEdgeData->pFaces[i]->GetDisp();
|
|
if( dispHandle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );
|
|
|
|
// get surface normal, to reset vector field to base state
|
|
Vector vNormal;
|
|
pDisp->GetSurfNormal( vNormal );
|
|
|
|
// reset tjstart and tjend
|
|
if( type != DISPSEW_EDGE_TJ )
|
|
{
|
|
//
|
|
// for all points along the edge -- reset
|
|
//
|
|
int width = pDisp->GetWidth();
|
|
for( int j = 1; j < ( width - 1 ); j++ )
|
|
{
|
|
// get the edge point index
|
|
int ndxPt = GetEdgePointIndex( pDisp, pEdgeData->ndxEdges[i], j, true );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset displacement data (dist, field vector, and offset vector)
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vNormal );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
// reset tj (upper and lower)
|
|
else
|
|
{
|
|
//
|
|
// for all points along the edge -- reset
|
|
//
|
|
int width = pDisp->GetWidth();
|
|
int widthDiv2 = width / 2;
|
|
|
|
if( bStart )
|
|
{
|
|
for( int j = 1; j < widthDiv2; j++ )
|
|
{
|
|
// get the edge point index
|
|
int ndxPt = GetEdgePointIndex( pDisp, pEdgeData->ndxEdges[i], j, true );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset displacement data (dist, field vector, and offset vector)
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vNormal );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int j = ( widthDiv2 + 1 ); j < ( width - 1 ); j++ )
|
|
{
|
|
// get the edge point index
|
|
int ndxPt = GetEdgePointIndex( pDisp, pEdgeData->ndxEdges[i], j, true );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset displacement data (dist, field vector, and offset vector)
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vNormal );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_ResolveDispNormal( SewEdgeData_t *pEdgeData )
|
|
{
|
|
//
|
|
// get displacement surfaces -- if any
|
|
//
|
|
EditDispHandle_t handle1 = pEdgeData->pFaces[0]->GetDisp();
|
|
EditDispHandle_t handle2 = pEdgeData->pFaces[1]->GetDisp();
|
|
if( ( handle1 == EDITDISPHANDLE_INVALID ) || ( handle2 == EDITDISPHANDLE_INVALID ) )
|
|
return;
|
|
|
|
CMapDisp *pEdgeDisp1 = EditDispMgr()->GetDisp( handle1 );
|
|
CMapDisp *pEdgeDisp2 = EditDispMgr()->GetDisp( handle2 );
|
|
|
|
//
|
|
// sew displacement edges
|
|
//
|
|
|
|
//
|
|
// find displacement with smallest/largest interval
|
|
//
|
|
CMapDisp *pSmDisp, *pLgDisp;
|
|
int smInterval, lgInterval;
|
|
int ndxSmEdge, ndxLgEdge;
|
|
|
|
if( pEdgeDisp1->GetWidth() > pEdgeDisp2->GetWidth() )
|
|
{
|
|
pSmDisp = pEdgeDisp2;
|
|
ndxSmEdge = pEdgeData->ndxEdges[1];
|
|
smInterval = pEdgeDisp2->GetWidth();
|
|
|
|
pLgDisp = pEdgeDisp1;
|
|
ndxLgEdge = pEdgeData->ndxEdges[0];
|
|
lgInterval = pEdgeDisp1->GetWidth();
|
|
}
|
|
else
|
|
{
|
|
pSmDisp = pEdgeDisp1;
|
|
ndxSmEdge = pEdgeData->ndxEdges[0];
|
|
smInterval = pEdgeDisp1->GetWidth();
|
|
|
|
pLgDisp = pEdgeDisp2;
|
|
ndxLgEdge = pEdgeData->ndxEdges[1];
|
|
lgInterval = pEdgeDisp2->GetWidth();
|
|
}
|
|
|
|
// calculate the ratio
|
|
int ratio = ( lgInterval - 1 ) / ( smInterval - 1 );
|
|
|
|
//
|
|
// average "like" points
|
|
//
|
|
for( int ndxSm = 1, ndxLg = ratio; ndxSm < ( smInterval - 1 ); ndxSm++, ndxLg += ratio )
|
|
{
|
|
int ndxSmPt = GetEdgePointIndex( pSmDisp, ndxSmEdge, ndxSm, true );
|
|
int ndxLgPt = GetEdgePointIndex( pLgDisp, ndxLgEdge, ndxLg, false );
|
|
|
|
// average
|
|
AverageVectorFieldData( pSmDisp, ndxSmPt, pLgDisp, ndxLgPt );
|
|
}
|
|
|
|
//
|
|
// linearly interpolate the "unlike" points
|
|
//
|
|
float blendRatio = 1.0f / ratio;
|
|
|
|
for( int ndxLg = 0; ndxLg < ( lgInterval - 1 ); ndxLg += ratio )
|
|
{
|
|
int ndxStart = ndxLg;
|
|
int ndxEnd = ( ndxLg + ratio );
|
|
|
|
int ndxStartPt = GetEdgePointIndex( pLgDisp, ndxLgEdge, ndxStart, true );
|
|
int ndxEndPt = GetEdgePointIndex( pLgDisp, ndxLgEdge, ndxEnd, true );
|
|
|
|
for( int ndx = ( ndxStart + 1 ); ndx < ndxEnd; ndx++ )
|
|
{
|
|
float blend = blendRatio * ( ndx - ndxStart );
|
|
int ndxDst = GetEdgePointIndex( pLgDisp, ndxLgEdge, ndx, true );
|
|
BlendVectorFieldData( pLgDisp, ndxStartPt, ndxDst, pLgDisp, ndxEndPt, ndxDst, blend );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_ResolveSolidNormal( SewEdgeData_t *pEdgeData )
|
|
{
|
|
// create an empty vector to reset the offset with
|
|
Vector vClear( 0.0f, 0.0f, 0.0f );
|
|
Vector vSet( 1.0f, 1.0f, 1.0f );
|
|
Vector4D vClearMultiBlend, vClearAlphaBlend;
|
|
|
|
vClearMultiBlend.Init();
|
|
vClearAlphaBlend.Init();
|
|
|
|
for( int i = 0; i < pEdgeData->faceCount; i++ )
|
|
{
|
|
// get the displacement surface associated with the face
|
|
EditDispHandle_t handle = pEdgeData->pFaces[i]->GetDisp();
|
|
if( handle == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
|
|
|
|
// get surface normal, to reset vector field to base state
|
|
Vector vNormal;
|
|
pDisp->GetSurfNormal( vNormal );
|
|
|
|
//
|
|
// for all points along the edge -- reset
|
|
//
|
|
int width = pDisp->GetWidth();
|
|
for( int j = 0; j < width; j++ )
|
|
{
|
|
// get the edge point index
|
|
int ndxPt = GetEdgePointIndex( pDisp, pEdgeData->ndxEdges[i], j, true );
|
|
if( ndxPt == -1 )
|
|
continue;
|
|
|
|
//
|
|
// reset displacement data (dist, field vector, and offset vector)
|
|
//
|
|
pDisp->SetFieldDistance( ndxPt, 0.0f );
|
|
pDisp->SetFieldVector( ndxPt, vClear );
|
|
pDisp->SetSubdivPosition( ndxPt, vClear );
|
|
pDisp->SetSubdivNormal( ndxPt, vNormal );
|
|
pDisp->SetAlpha( ndxPt, 0.0f );
|
|
pDisp->SetMultiBlend( ndxPt, vClearMultiBlend, vClearAlphaBlend, vSet, vSet, vSet, vSet );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SewEdge_Resolve( void )
|
|
{
|
|
// get the number of edges in the edge list
|
|
int edgeCount = s_EdgeData.Count();
|
|
|
|
// resolve each edge
|
|
for( int i = 0; i < edgeCount; i++ )
|
|
{
|
|
// get the current edge data struct
|
|
SewEdgeData_t *pEdgeData = s_EdgeData.Element( i );
|
|
if( !pEdgeData )
|
|
continue;
|
|
|
|
// handle "normal" edge
|
|
if( pEdgeData->type[0] == DISPSEW_EDGE_NORMAL )
|
|
{
|
|
// solid "normal" edge
|
|
if( SewEdge_IsSolidNormal( pEdgeData ) )
|
|
{
|
|
SewEdge_ResolveSolidNormal( pEdgeData );
|
|
}
|
|
// disps "normal" edge
|
|
else
|
|
{
|
|
SewEdge_ResolveDispNormal( pEdgeData );
|
|
}
|
|
}
|
|
// handle "t-junction" edge
|
|
else
|
|
{
|
|
int ndxTJ = SewEdge_TJIndex( pEdgeData, DISPSEW_EDGE_TJ );
|
|
int ndxTJStart = SewEdge_TJIndex( pEdgeData, DISPSEW_EDGE_TJSTART );
|
|
int ndxTJEnd = SewEdge_TJIndex( pEdgeData, DISPSEW_EDGE_TJEND );
|
|
|
|
if( SewEdge_IsSolidTJunc( pEdgeData, DISPSEW_EDGE_TJ ) )
|
|
{
|
|
// reset both start and end t-junction edges if they exist
|
|
if( ndxTJStart != -1 )
|
|
{
|
|
SewEdge_ResolveSolidTJunc( pEdgeData, DISPSEW_EDGE_TJSTART, false );
|
|
}
|
|
|
|
if( ndxTJEnd != -1 )
|
|
{
|
|
SewEdge_ResolveSolidTJunc( pEdgeData, DISPSEW_EDGE_TJEND, false );
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// handle start edge
|
|
if( ndxTJStart != -1 )
|
|
{
|
|
if( SewEdge_IsSolidTJunc( pEdgeData, DISPSEW_EDGE_TJSTART ) )
|
|
{
|
|
SewEdge_ResolveSolidTJunc( pEdgeData, DISPSEW_EDGE_TJ, true );
|
|
}
|
|
else
|
|
{
|
|
SewEdge_ResolveDispTJunc( pEdgeData, ndxTJ, ndxTJStart, true );
|
|
}
|
|
}
|
|
|
|
// handle end edge
|
|
if( ndxTJEnd != -1 )
|
|
{
|
|
if( SewEdge_IsSolidTJunc( pEdgeData, DISPSEW_EDGE_TJEND ) )
|
|
{
|
|
SewEdge_ResolveSolidTJunc( pEdgeData, DISPSEW_EDGE_TJ, false );
|
|
}
|
|
else
|
|
{
|
|
SewEdge_ResolveDispTJunc( pEdgeData, ndxTJ, ndxTJEnd, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Convert the edge/midpoint/corner data for shared code,
|
|
//-----------------------------------------------------------------------------
|
|
bool PrePlanarizeDependentVerts( void )
|
|
{
|
|
// Create a list of all the selected displacement cores.
|
|
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
|
|
if( !pSheet )
|
|
return false;
|
|
|
|
int nFaceCount = pSheet->GetFaceListCount();
|
|
for( int iFace = 0; iFace < nFaceCount; ++iFace )
|
|
{
|
|
CMapFace *pFace = pSheet->GetFaceListDataFace( iFace );
|
|
if( !pFace || !pFace->HasDisp() )
|
|
continue;
|
|
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( pFace->GetDisp() );
|
|
Assert( pDisp );
|
|
|
|
int iDisp = m_aCoreDispInfos.AddToTail();
|
|
pDisp->GetCoreDispInfo()->SetListIndex( iDisp );
|
|
m_aCoreDispInfos[iDisp] = pDisp->GetCoreDispInfo();
|
|
}
|
|
|
|
// Add the list to the displacements -- this is a bit hacky!!
|
|
for ( int iDisp = 0; iDisp < m_aCoreDispInfos.Count(); ++iDisp )
|
|
{
|
|
m_aCoreDispInfos[iDisp]->SetDispUtilsHelperInfo( m_aCoreDispInfos.Base(), m_aCoreDispInfos.Count() );
|
|
}
|
|
|
|
// Build neighboring info.
|
|
FindNeighboringDispSurfs( m_aCoreDispInfos.Base(), m_aCoreDispInfos.Count() );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
class CHammerTesselateHelper : public CBaseTesselateHelper
|
|
{
|
|
public:
|
|
|
|
void EndTriangle()
|
|
{
|
|
m_pIndices->AddToTail( m_TempIndices[0] );
|
|
m_pIndices->AddToTail( m_TempIndices[1] );
|
|
m_pIndices->AddToTail( m_TempIndices[2] );
|
|
}
|
|
|
|
DispNodeInfo_t& GetNodeInfo( int iNodeBit )
|
|
{
|
|
// Hammer doesn't care about these. Give it back something to play with.
|
|
static DispNodeInfo_t dummy;
|
|
return dummy;
|
|
}
|
|
|
|
public:
|
|
|
|
CUtlVector<unsigned short> *m_pIndices;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool FindEnclosingTri( const Vector2D &vert, CUtlVector<Vector2D> &vertCoords,
|
|
CUtlVector<unsigned short> &indices, int *pStartVert,
|
|
float bcCoords[3] )
|
|
{
|
|
for ( int i = 0; i < indices.Count(); i += 3 )
|
|
{
|
|
GetBarycentricCoords2D( vertCoords[indices[i+0]],
|
|
vertCoords[indices[i+1]],
|
|
vertCoords[indices[i+2]],
|
|
vert, bcCoords );
|
|
|
|
if ( bcCoords[0] >= 0 && bcCoords[0] <= 1 &&
|
|
bcCoords[1] >= 0 && bcCoords[1] <= 1 &&
|
|
bcCoords[2] >= 0 && bcCoords[2] <= 1 )
|
|
{
|
|
*pStartVert = i;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void SnapDependentVertsToSurface( CCoreDispInfo *pCoreDisp )
|
|
{
|
|
// Don't really want to do this, but.......
|
|
CUtlVector<unsigned short> indices;
|
|
CHammerTesselateHelper helper;
|
|
helper.m_pIndices = &indices;
|
|
helper.m_pActiveVerts = pCoreDisp->GetAllowedVerts().Base();
|
|
helper.m_pPowerInfo = pCoreDisp->GetPowerInfo();
|
|
TesselateDisplacement( &helper );
|
|
|
|
// Find allowed/non-allowed verts.
|
|
CUtlVector<bool> vertsTouched;
|
|
vertsTouched.SetSize( pCoreDisp->GetSize() );
|
|
memset( vertsTouched.Base(), 0, sizeof( bool ) * vertsTouched.Count() );
|
|
for ( int iVert = 0; iVert < indices.Count(); ++iVert )
|
|
{
|
|
vertsTouched[indices[iVert]] = true;
|
|
}
|
|
|
|
// Generate 2D floating point coordinates for each vertex. We use these to generate
|
|
// barycentric coordinates, and the scale doesn't matter.
|
|
CUtlVector<Vector2D> vertCoords;
|
|
vertCoords.SetSize( pCoreDisp->GetSize() );
|
|
for ( int iHgt = 0; iHgt < pCoreDisp->GetHeight(); ++iHgt )
|
|
{
|
|
for ( int iWid = 0; iWid < pCoreDisp->GetWidth(); ++iWid )
|
|
{
|
|
vertCoords[iHgt*pCoreDisp->GetWidth()+iWid].Init( iWid, iHgt );
|
|
}
|
|
}
|
|
|
|
// Now, for each vert not touched, snap its position to the main surface.
|
|
for ( int iHgt = 0; iHgt < pCoreDisp->GetHeight(); ++iHgt )
|
|
{
|
|
for ( int iWid = 0; iWid < pCoreDisp->GetWidth(); ++iWid )
|
|
{
|
|
int nIndex = iHgt * pCoreDisp->GetWidth() + iWid;
|
|
if ( !( vertsTouched[nIndex] ) )
|
|
{
|
|
float flBCoords[3];
|
|
int iStartVert = -1;
|
|
|
|
if ( FindEnclosingTri( vertCoords[nIndex], vertCoords, indices, &iStartVert, flBCoords ) )
|
|
{
|
|
const Vector &A = pCoreDisp->GetVert( indices[iStartVert+0] );
|
|
const Vector &B = pCoreDisp->GetVert( indices[iStartVert+1] );
|
|
const Vector &C = pCoreDisp->GetVert( indices[iStartVert+2] );
|
|
Vector vNewPos = A*flBCoords[0] + B*flBCoords[1] + C*flBCoords[2];
|
|
|
|
// Modify the CCoreDispInfo vert (although it probably won't be used later).
|
|
pCoreDisp->Position_Update( nIndex, vNewPos );
|
|
}
|
|
else
|
|
{
|
|
// This shouldn't happen because it would mean that the triangulation that
|
|
// disp_tesselation.h produced was missing a chunk of the space that the
|
|
// displacement covers.
|
|
// It also could indicate a floating-point epsilon error.. check to see if
|
|
// FindEnclosingTri finds a triangle that -almost- encloses the vert.
|
|
Assert( false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get allowed verts bits and planarize cleared verts and purge disp
|
|
// infos.
|
|
//-----------------------------------------------------------------------------
|
|
void PostPlanarizeDependentVerts( void )
|
|
{
|
|
// Snap dependents verts to the displacement surface.
|
|
for ( int iDispCore = 0; iDispCore < m_aCoreDispInfos.Count(); ++iDispCore )
|
|
{
|
|
SnapDependentVertsToSurface( m_aCoreDispInfos[iDispCore] );
|
|
}
|
|
|
|
// Clear out the displacement info list.
|
|
m_aCoreDispInfos.Purge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Planarize vertices that are removed because of dependencies with
|
|
// neighboring displacements.
|
|
//-----------------------------------------------------------------------------
|
|
void PlanarizeDependentVerts( void )
|
|
{
|
|
// Setup.
|
|
if ( !PrePlanarizeDependentVerts() )
|
|
return;
|
|
|
|
SetupAllowedVerts( m_aCoreDispInfos.Base(), m_aCoreDispInfos.Count() );
|
|
|
|
// Update and clean-up.
|
|
PostPlanarizeDependentVerts();
|
|
}
|