You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
332 lines
8.8 KiB
332 lines
8.8 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//=============================================================================// |
|
|
|
#include "disp_vrad.h" |
|
#include "utllinkedlist.h" |
|
#include "utlvector.h" |
|
#include "iscratchpad3d.h" |
|
#include "scratchpadutils.h" |
|
|
|
|
|
//#define USE_SCRATCHPAD |
|
#if defined( USE_SCRATCHPAD ) |
|
static IScratchPad3D *g_pPad = 0; |
|
#endif |
|
|
|
|
|
int FindNeighborCornerVert( CCoreDispInfo *pDisp, const Vector &vTest ) |
|
{ |
|
CDispUtilsHelper *pDispHelper = pDisp; |
|
|
|
int iClosest = 0; |
|
float flClosest = 1e24; |
|
for ( int iCorner=0; iCorner < 4; iCorner++ ) |
|
{ |
|
// Has it been touched? |
|
CVertIndex cornerVert = pDispHelper->GetPowerInfo()->GetCornerPointIndex( iCorner ); |
|
int iCornerVert = pDispHelper->VertIndexToInt( cornerVert ); |
|
const Vector &vCornerVert = pDisp->GetVert( iCornerVert ); |
|
|
|
float flDist = vCornerVert.DistTo( vTest ); |
|
if ( flDist < flClosest ) |
|
{ |
|
iClosest = iCorner; |
|
flClosest = flDist; |
|
} |
|
} |
|
|
|
if ( flClosest <= 0.1f ) |
|
return iClosest; |
|
else |
|
return -1; |
|
} |
|
|
|
|
|
int GetAllNeighbors( const CCoreDispInfo *pDisp, int (&iNeighbors)[512] ) |
|
{ |
|
int nNeighbors = 0; |
|
|
|
// Check corner neighbors. |
|
for ( int iCorner=0; iCorner < 4; iCorner++ ) |
|
{ |
|
const CDispCornerNeighbors *pCorner = pDisp->GetCornerNeighbors( iCorner ); |
|
|
|
for ( int i=0; i < pCorner->m_nNeighbors; i++ ) |
|
{ |
|
if ( nNeighbors < ARRAYSIZE( iNeighbors ) ) |
|
iNeighbors[nNeighbors++] = pCorner->m_Neighbors[i]; |
|
} |
|
} |
|
|
|
for ( int iEdge=0; iEdge < 4; iEdge++ ) |
|
{ |
|
const CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor( iEdge ); |
|
|
|
for ( int i=0; i < 2; i++ ) |
|
{ |
|
if ( pEdge->m_SubNeighbors[i].IsValid() ) |
|
if ( nNeighbors < 512 ) |
|
iNeighbors[nNeighbors++] = pEdge->m_SubNeighbors[i].GetNeighborIndex(); |
|
} |
|
} |
|
|
|
return nNeighbors; |
|
} |
|
|
|
|
|
void BlendCorners( CCoreDispInfo **ppListBase, int listSize ) |
|
{ |
|
CUtlVector<int> nbCornerVerts; |
|
|
|
for ( int iDisp=0; iDisp < listSize; iDisp++ ) |
|
{ |
|
CCoreDispInfo *pDisp = ppListBase[iDisp]; |
|
|
|
int iNeighbors[512]; |
|
int nNeighbors = GetAllNeighbors( pDisp, iNeighbors ); |
|
|
|
// Make sure we have room for all the neighbors. |
|
nbCornerVerts.RemoveAll(); |
|
nbCornerVerts.EnsureCapacity( nNeighbors ); |
|
nbCornerVerts.AddMultipleToTail( nNeighbors ); |
|
|
|
// For each corner. |
|
for ( int iCorner=0; iCorner < 4; iCorner++ ) |
|
{ |
|
// Has it been touched? |
|
CVertIndex cornerVert = pDisp->GetCornerPointIndex( iCorner ); |
|
int iCornerVert = pDisp->VertIndexToInt( cornerVert ); |
|
const Vector &vCornerVert = pDisp->GetVert( iCornerVert ); |
|
|
|
// For each displacement sharing this corner.. |
|
Vector vAverage = pDisp->GetNormal( iCornerVert ); |
|
|
|
for ( int iNeighbor=0; iNeighbor < nNeighbors; iNeighbor++ ) |
|
{ |
|
int iNBListIndex = iNeighbors[iNeighbor]; |
|
CCoreDispInfo *pNeighbor = ppListBase[iNBListIndex]; |
|
|
|
// Find out which vert it is on the neighbor. |
|
int iNBCorner = FindNeighborCornerVert( pNeighbor, vCornerVert ); |
|
if ( iNBCorner == -1 ) |
|
{ |
|
nbCornerVerts[iNeighbor] = -1; // remove this neighbor from the list. |
|
} |
|
else |
|
{ |
|
CVertIndex viNBCornerVert = pNeighbor->GetCornerPointIndex( iNBCorner ); |
|
int iNBVert = pNeighbor->VertIndexToInt( viNBCornerVert ); |
|
nbCornerVerts[iNeighbor] = iNBVert; |
|
vAverage += pNeighbor->GetNormal( iNBVert ); |
|
} |
|
} |
|
|
|
|
|
// Blend all the neighbor normals with this one. |
|
VectorNormalize( vAverage ); |
|
pDisp->SetNormal( iCornerVert, vAverage ); |
|
|
|
#if defined( USE_SCRATCHPAD ) |
|
ScratchPad_DrawArrowSimple( |
|
g_pPad, |
|
pDisp->GetVert( iCornerVert ), |
|
pDisp->GetNormal( iCornerVert ), |
|
Vector( 0, 0, 1 ), |
|
25 ); |
|
#endif |
|
|
|
for ( int iNeighbor=0; iNeighbor < nNeighbors; iNeighbor++ ) |
|
{ |
|
int iNBListIndex = iNeighbors[iNeighbor]; |
|
if ( nbCornerVerts[iNeighbor] == -1 ) |
|
continue; |
|
|
|
CCoreDispInfo *pNeighbor = ppListBase[iNBListIndex]; |
|
pNeighbor->SetNormal( nbCornerVerts[iNeighbor], vAverage ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
void BlendTJuncs( CCoreDispInfo **ppListBase, int listSize ) |
|
{ |
|
for ( int iDisp=0; iDisp < listSize; iDisp++ ) |
|
{ |
|
CCoreDispInfo *pDisp = ppListBase[iDisp]; |
|
|
|
for ( int iEdge=0; iEdge < 4; iEdge++ ) |
|
{ |
|
CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor( iEdge ); |
|
|
|
CVertIndex viMidPoint = pDisp->GetEdgeMidPoint( iEdge ); |
|
int iMidPoint = pDisp->VertIndexToInt( viMidPoint ); |
|
|
|
if ( pEdge->m_SubNeighbors[0].IsValid() && pEdge->m_SubNeighbors[1].IsValid() ) |
|
{ |
|
const Vector &vMidPoint = pDisp->GetVert( iMidPoint ); |
|
|
|
CCoreDispInfo *pNeighbor1 = ppListBase[pEdge->m_SubNeighbors[0].GetNeighborIndex()]; |
|
CCoreDispInfo *pNeighbor2 = ppListBase[pEdge->m_SubNeighbors[1].GetNeighborIndex()]; |
|
|
|
int iNBCorners[2]; |
|
iNBCorners[0] = FindNeighborCornerVert( pNeighbor1, vMidPoint ); |
|
iNBCorners[1] = FindNeighborCornerVert( pNeighbor2, vMidPoint ); |
|
|
|
if ( iNBCorners[0] != -1 && iNBCorners[1] != -1 ) |
|
{ |
|
CVertIndex viNBCorners[2] = |
|
{ |
|
pNeighbor1->GetCornerPointIndex( iNBCorners[0] ), |
|
pNeighbor2->GetCornerPointIndex( iNBCorners[1] ) |
|
}; |
|
|
|
Vector vAverage = pDisp->GetNormal( iMidPoint ); |
|
vAverage += pNeighbor1->GetNormal( viNBCorners[0] ); |
|
vAverage += pNeighbor2->GetNormal( viNBCorners[1] ); |
|
|
|
VectorNormalize( vAverage ); |
|
pDisp->SetNormal( iMidPoint, vAverage ); |
|
pNeighbor1->SetNormal( viNBCorners[0], vAverage ); |
|
pNeighbor2->SetNormal( viNBCorners[1], vAverage ); |
|
|
|
#if defined( USE_SCRATCHPAD ) |
|
ScratchPad_DrawArrowSimple( g_pPad, pDisp->GetVert( iMidPoint ), pDisp->GetNormal( iMidPoint ), Vector( 0, 1, 1 ), 25 ); |
|
#endif |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
void BlendEdges( CCoreDispInfo **ppListBase, int listSize ) |
|
{ |
|
for ( int iDisp=0; iDisp < listSize; iDisp++ ) |
|
{ |
|
CCoreDispInfo *pDisp = ppListBase[iDisp]; |
|
|
|
for ( int iEdge=0; iEdge < 4; iEdge++ ) |
|
{ |
|
CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor( iEdge ); |
|
|
|
for ( int iSub=0; iSub < 2; iSub++ ) |
|
{ |
|
CDispSubNeighbor *pSub = &pEdge->m_SubNeighbors[iSub]; |
|
if ( !pSub->IsValid() ) |
|
continue; |
|
|
|
CCoreDispInfo *pNeighbor = ppListBase[ pSub->GetNeighborIndex() ]; |
|
|
|
int iEdgeDim = g_EdgeDims[iEdge]; |
|
|
|
CDispSubEdgeIterator it; |
|
it.Start( pDisp, iEdge, iSub, true ); |
|
|
|
// Get setup on the first corner vert. |
|
it.Next(); |
|
CVertIndex viPrevPos = it.GetVertIndex(); |
|
|
|
while ( it.Next() ) |
|
{ |
|
// Blend the two. |
|
if ( !it.IsLastVert() ) |
|
{ |
|
Vector vAverage = pDisp->GetNormal( it.GetVertIndex() ) + pNeighbor->GetNormal( it.GetNBVertIndex() ); |
|
VectorNormalize( vAverage ); |
|
|
|
pDisp->SetNormal( it.GetVertIndex(), vAverage ); |
|
pNeighbor->SetNormal( it.GetNBVertIndex(), vAverage ); |
|
|
|
#if defined( USE_SCRATCHPAD ) |
|
ScratchPad_DrawArrowSimple( g_pPad, pDisp->GetVert( it.GetVertIndex() ), pDisp->GetNormal( it.GetVertIndex() ), Vector( 1, 0, 0 ), 25 ); |
|
#endif |
|
} |
|
|
|
// Now blend the in-between verts (if this edge is high-res). |
|
int iPrevPos = viPrevPos[ !iEdgeDim ]; |
|
int iCurPos = it.GetVertIndex()[ !iEdgeDim ]; |
|
|
|
for ( int iTween = iPrevPos+1; iTween < iCurPos; iTween++ ) |
|
{ |
|
float flPercent = RemapVal( iTween, iPrevPos, iCurPos, 0, 1 ); |
|
Vector vNormal; |
|
VectorLerp( pDisp->GetNormal( viPrevPos ), pDisp->GetNormal( it.GetVertIndex() ), flPercent, vNormal ); |
|
VectorNormalize( vNormal ); |
|
|
|
CVertIndex viTween; |
|
viTween[iEdgeDim] = it.GetVertIndex()[ iEdgeDim ]; |
|
viTween[!iEdgeDim] = iTween; |
|
pDisp->SetNormal( viTween, vNormal ); |
|
|
|
#if defined( USE_SCRATCHPAD ) |
|
ScratchPad_DrawArrowSimple( g_pPad, pDisp->GetVert( viTween ), pDisp->GetNormal( viTween ), Vector( 1, 0.5, 0 ), 25 ); |
|
#endif |
|
} |
|
|
|
viPrevPos = it.GetVertIndex(); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
#if defined( USE_SCRATCHPAD ) |
|
void ScratchPad_DrawOriginalNormals( const CCoreDispInfo *pListBase, int listSize ) |
|
{ |
|
for ( int i=0; i < listSize; i++ ) |
|
{ |
|
const CCoreDispInfo *pDisp = &pListBase[i]; |
|
const CPowerInfo *pPowerInfo = pDisp->GetPowerInfo(); |
|
|
|
// Draw the triangles. |
|
for ( int iTri=0; iTri < pPowerInfo->GetNumTriInfos(); iTri++ ) |
|
{ |
|
const CTriInfo *pTriInfo = pPowerInfo->GetTriInfo( iTri ); |
|
|
|
for ( int iLine=0; iLine < 3; iLine++ ) |
|
{ |
|
const Vector &v1 = pDisp->GetVert( pTriInfo->m_Indices[iLine] ); |
|
const Vector &v2 = pDisp->GetVert( pTriInfo->m_Indices[(iLine+1)%3] ); |
|
|
|
g_pPad->DrawLine( CSPVert( v1 ), CSPVert( v2 ) ); |
|
} |
|
} |
|
|
|
// Draw the normals. |
|
CDispCircumferenceIterator it( pPowerInfo->GetSideLength() ); |
|
while ( it.Next() ) |
|
{ |
|
ScratchPad_DrawArrowSimple( |
|
g_pPad, |
|
pDisp->GetVert( it.GetVertIndex() ), |
|
pDisp->GetNormal( it.GetVertIndex() ), |
|
Vector( 0, 1, 0 ), |
|
15 ); |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
|
|
void SmoothNeighboringDispSurfNormals( CCoreDispInfo **ppListBase, int listSize ) |
|
{ |
|
//#if defined( USE_SCRATCHPAD ) |
|
// g_pPad = ScratchPad3D_Create(); |
|
// ScratchPad_DrawOriginalNormals( pListBase, listSize ); |
|
//#endif |
|
|
|
BlendTJuncs( ppListBase, listSize ); |
|
|
|
BlendCorners( ppListBase, listSize ); |
|
|
|
BlendEdges( ppListBase, listSize ); |
|
} |
|
|
|
|
|
|
|
|