1254 lines
32 KiB
C++
1254 lines
32 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include <stdafx.h>
|
|
#include "MainFrm.h"
|
|
#include "MapDoc.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "Subdiv.h"
|
|
#include "History.h"
|
|
|
|
//=============================================================================
|
|
//
|
|
// Subdivision Point Functions
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivPoint::Clear( void )
|
|
{
|
|
VectorClear( m_Point );
|
|
VectorClear( m_NewPoint );
|
|
VectorClear( m_Normal );
|
|
VectorClear( m_NewNormal );
|
|
|
|
m_Type = -1;
|
|
m_Valence = 0;
|
|
|
|
for( int i = 0; i < NUM_SUBDIV_EDGES; i++ )
|
|
{
|
|
m_pEdges[i] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivPoint::Copy( const CSubdivPoint *pFrom )
|
|
{
|
|
m_Point = pFrom->m_Point;
|
|
m_NewPoint = pFrom->m_NewPoint;
|
|
m_Normal = pFrom->m_Normal;
|
|
m_NewNormal = pFrom->m_NewNormal;
|
|
|
|
m_Type = pFrom->m_Type;
|
|
m_Valence = pFrom->m_Valence;
|
|
|
|
for( int i = 0; i < NUM_SUBDIV_EDGES; i++ )
|
|
{
|
|
m_pEdges[i] = pFrom->m_pEdges[i];
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivPoint::CalcNewVertexNormal( void )
|
|
{
|
|
switch( m_Type )
|
|
{
|
|
case POINT_CORNER:
|
|
{
|
|
m_NewNormal = m_Normal;
|
|
break;
|
|
}
|
|
case POINT_CREASE:
|
|
{
|
|
Vector edgeAccum;
|
|
VectorClear( edgeAccum );
|
|
for( int i = 0; i < m_Valence; i++ )
|
|
{
|
|
if( m_pEdges[i]->m_Sharpness > 0.0f )
|
|
{
|
|
VectorAdd( edgeAccum, m_pEdges[i]->m_NewEdgeNormal, edgeAccum );
|
|
}
|
|
}
|
|
|
|
//
|
|
// normal
|
|
//
|
|
VectorScale( m_Normal, 6.0f, m_NewNormal );
|
|
VectorAdd( m_NewNormal, edgeAccum, m_NewNormal );
|
|
VectorScale( m_NewNormal, 0.125f, m_NewNormal );
|
|
|
|
break;
|
|
}
|
|
case POINT_ORDINARY:
|
|
{
|
|
//
|
|
// accumulate edge data and multiply by valence ratio
|
|
//
|
|
Vector edgeAccum;
|
|
VectorClear( edgeAccum );
|
|
for( int i = 0; i < m_Valence; i++ )
|
|
{
|
|
VectorAdd( edgeAccum, m_pEdges[i]->m_NewEdgeNormal, edgeAccum );
|
|
}
|
|
float ratio = ( 1.0f / ( float )( m_Valence * m_Valence ) );
|
|
VectorScale( edgeAccum, ratio, edgeAccum );
|
|
|
|
//
|
|
// accumulate centroid data and multiply by valence ratio
|
|
//
|
|
int quadCount = 0;
|
|
CSubdivQuad *quadList[16];
|
|
for( i = 0; i < m_Valence; i++ )
|
|
{
|
|
for( int j = 0; j < 2; j++ )
|
|
{
|
|
if( m_pEdges[i]->m_pQuads[j] )
|
|
{
|
|
for( int k = 0; k < quadCount; k++ )
|
|
{
|
|
if( m_pEdges[i]->m_pQuads[j] == quadList[k] )
|
|
break;
|
|
}
|
|
|
|
if( k != quadCount )
|
|
continue;
|
|
|
|
quadList[quadCount] = m_pEdges[i]->m_pQuads[j];
|
|
quadCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
Vector centroidAccum;
|
|
VectorClear( centroidAccum );
|
|
for( i = 0; i < quadCount; i++ )
|
|
{
|
|
Vector centroid;
|
|
quadList[i]->GetNormal( centroid );
|
|
VectorAdd( centroidAccum, centroid, centroidAccum );
|
|
}
|
|
VectorScale( centroidAccum, ratio, centroidAccum );
|
|
|
|
//
|
|
// normal
|
|
//
|
|
VectorScale( m_Normal, ratio, m_NewNormal );
|
|
VectorAdd( m_NewNormal, edgeAccum, m_NewNormal );
|
|
VectorAdd( m_NewNormal, centroidAccum, m_NewNormal );
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivPoint::CalcNewVertexPoint( void )
|
|
{
|
|
switch( m_Type )
|
|
{
|
|
case POINT_CORNER:
|
|
{
|
|
m_NewPoint = m_Point;
|
|
break;
|
|
}
|
|
case POINT_CREASE:
|
|
{
|
|
Vector edgeAccum;
|
|
VectorClear( edgeAccum );
|
|
for( int i = 0; i < m_Valence; i++ )
|
|
{
|
|
if( m_pEdges[i]->m_Sharpness > 0.0f )
|
|
{
|
|
VectorAdd( edgeAccum, m_pEdges[i]->m_NewEdgePoint, edgeAccum );
|
|
}
|
|
}
|
|
|
|
//
|
|
// point
|
|
//
|
|
VectorScale( m_Point, 6.0f, m_NewPoint );
|
|
VectorAdd( m_NewPoint, edgeAccum, m_NewPoint );
|
|
VectorScale( m_NewPoint, 0.125f, m_NewPoint );
|
|
|
|
break;
|
|
}
|
|
case POINT_ORDINARY:
|
|
{
|
|
//
|
|
// accumulate edge data and multiply by valence ratio
|
|
//
|
|
Vector edgeAccum;
|
|
VectorClear( edgeAccum );
|
|
for( int i = 0; i < m_Valence; i++ )
|
|
{
|
|
VectorAdd( edgeAccum, m_pEdges[i]->m_NewEdgePoint, edgeAccum );
|
|
}
|
|
float ratio = ( 1.0f / ( float )( m_Valence * m_Valence ) );
|
|
VectorScale( edgeAccum, ratio, edgeAccum );
|
|
|
|
//
|
|
// accumulate centroid data and multiply by valence ratio
|
|
//
|
|
int quadCount = 0;
|
|
CSubdivQuad *quadList[16];
|
|
for( i = 0; i < m_Valence; i++ )
|
|
{
|
|
for( int j = 0; j < 2; j++ )
|
|
{
|
|
if( m_pEdges[i]->m_pQuads[j] )
|
|
{
|
|
for( int k = 0; k < quadCount; k++ )
|
|
{
|
|
if( m_pEdges[i]->m_pQuads[j] == quadList[k] )
|
|
break;
|
|
}
|
|
|
|
if( k != quadCount )
|
|
continue;
|
|
|
|
quadList[quadCount] = m_pEdges[i]->m_pQuads[j];
|
|
quadCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
Vector centroidAccum;
|
|
VectorClear( centroidAccum );
|
|
for( i = 0; i < quadCount; i++ )
|
|
{
|
|
Vector centroid;
|
|
quadList[i]->GetCentroid( centroid );
|
|
VectorAdd( centroidAccum, centroid, centroidAccum );
|
|
}
|
|
VectorScale( centroidAccum, ratio, centroidAccum );
|
|
|
|
//
|
|
// point contribution to eqtn.
|
|
//
|
|
ratio = ( ( float )m_Valence - 2.0f ) / ( float )m_Valence;
|
|
VectorScale( m_Point, ratio, m_NewPoint );
|
|
|
|
VectorAdd( m_NewPoint, edgeAccum, m_NewPoint );
|
|
VectorAdd( m_NewPoint, centroidAccum, m_NewPoint );
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareSubdivPoints( const CSubdivPoint *pPoint1, const CSubdivPoint *pPoint2, float tolerance )
|
|
{
|
|
for( int i = 0 ; i < 3 ; i++ )
|
|
{
|
|
if( fabs( pPoint1->m_Point[i] - pPoint2->m_Point[i] ) > tolerance )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareSubdivPointToPoint( const CSubdivPoint *pSubdivPoint, const Vector& point, float tolerance )
|
|
{
|
|
for( int i = 0 ; i < 3 ; i++ )
|
|
{
|
|
if( fabs( pSubdivPoint->m_Point[i] - point[i] ) > tolerance )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Subdivision Edge Functions
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivEdge::Clear( void )
|
|
{
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
m_ndxPoint[i] = -1;
|
|
m_pQuads[i] = NULL;
|
|
m_ndxQuadEdge[i] = -1;
|
|
}
|
|
|
|
m_Sharpness = 1.0f;
|
|
VectorClear( m_NewEdgePoint );
|
|
m_Active = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivEdge::Copy( const CSubdivEdge *pFrom )
|
|
{
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
m_ndxPoint[i] = pFrom->m_ndxPoint[i];
|
|
m_pQuads[i] = pFrom->m_pQuads[i];
|
|
m_ndxQuadEdge[i] = pFrom->m_ndxQuadEdge[i];
|
|
}
|
|
|
|
m_Sharpness = pFrom->m_Sharpness;
|
|
m_NewEdgePoint = pFrom->m_NewEdgePoint;
|
|
m_Active = pFrom->m_Active;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivEdge::CalcNewEdgeNormal( void )
|
|
{
|
|
if( !m_Active )
|
|
return;
|
|
|
|
//
|
|
// get the subdivision mesh
|
|
//
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
//
|
|
// get the edge data
|
|
//
|
|
Vector normal0, normal1;
|
|
pMesh->GetNormal( m_ndxPoint[0], normal0 );
|
|
pMesh->GetNormal( m_ndxPoint[1], normal1 );
|
|
|
|
//
|
|
// calculate the "sharp" new edge point
|
|
//
|
|
Vector vSharp;
|
|
VectorClear( vSharp );
|
|
VectorAdd( normal0, normal1, vSharp );
|
|
VectorScale( vSharp, 0.5f, vSharp );
|
|
|
|
//
|
|
// calculate the "smooth" new edge point if necessary
|
|
//
|
|
Vector vSmooth;
|
|
VectorClear( vSmooth );
|
|
if( m_pQuads[1] && ( m_Sharpness != 1.0f ) )
|
|
{
|
|
Vector quadNormals[2];
|
|
m_pQuads[0]->GetNormal( quadNormals[0] );
|
|
m_pQuads[1]->GetNormal( quadNormals[1] );
|
|
VectorAdd( normal0, normal1, vSmooth );
|
|
VectorAdd( vSmooth, quadNormals[0], vSmooth );
|
|
VectorAdd( vSmooth, quadNormals[1], vSmooth );
|
|
VectorScale( vSmooth, 0.25f, vSmooth );
|
|
}
|
|
else
|
|
{
|
|
// make sure -- if here because of no neighboring quad
|
|
m_Sharpness = 1.0f;
|
|
m_pQuads[0]->CalcNormal();
|
|
}
|
|
|
|
//
|
|
// calculate the new edge point
|
|
//
|
|
// ( 1 - edge(sharpness) ) * vSmooth + edge(sharpness) * vSharp
|
|
//
|
|
VectorScale( vSmooth, ( 1.0f - m_Sharpness ), vSmooth );
|
|
VectorScale( vSharp, m_Sharpness, vSharp );
|
|
VectorAdd( vSmooth, vSharp, m_NewEdgeNormal );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivEdge::CalcNewEdgePoint( void )
|
|
{
|
|
if( !m_Active )
|
|
return;
|
|
|
|
//
|
|
// get the subdivision mesh
|
|
//
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
//
|
|
// get the edge data
|
|
//
|
|
Vector edgePt0, edgePt1;
|
|
pMesh->GetPoint( m_ndxPoint[0], edgePt0 );
|
|
pMesh->GetPoint( m_ndxPoint[1], edgePt1 );
|
|
|
|
//
|
|
// calculate the "sharp" new edge point
|
|
//
|
|
Vector vSharp;
|
|
VectorClear( vSharp );
|
|
VectorAdd( edgePt0, edgePt1, vSharp );
|
|
VectorScale( vSharp, 0.5f, vSharp );
|
|
|
|
//
|
|
// calculate the "smooth" new edge point if necessary
|
|
//
|
|
Vector vSmooth;
|
|
VectorClear( vSmooth );
|
|
if( m_pQuads[1] && ( m_Sharpness != 1.0f ) )
|
|
{
|
|
Vector centroids[2];
|
|
m_pQuads[0]->GetCentroid( centroids[0] );
|
|
m_pQuads[1]->GetCentroid( centroids[1] );
|
|
VectorAdd( edgePt0, edgePt1, vSmooth );
|
|
VectorAdd( vSmooth, centroids[0], vSmooth );
|
|
VectorAdd( vSmooth, centroids[1], vSmooth );
|
|
VectorScale( vSmooth, 0.25f, vSmooth );
|
|
}
|
|
else
|
|
{
|
|
// make sure -- if here because of no neighboring quad
|
|
m_Sharpness = 1.0f;
|
|
m_pQuads[0]->CalcCentroid();
|
|
}
|
|
|
|
//
|
|
// calculate the new edge point
|
|
//
|
|
// ( 1 - edge(sharpness) ) * vSmooth + edge(sharpness) * vSharp
|
|
//
|
|
VectorScale( vSmooth, ( 1.0f - m_Sharpness ), vSmooth );
|
|
VectorScale( vSharp, m_Sharpness, vSharp );
|
|
VectorAdd( vSmooth, vSharp, m_NewEdgePoint );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareSubdivEdges( const CSubdivEdge *pEdge1, const CSubdivEdge *pEdge2 )
|
|
{
|
|
if( ( ( pEdge1->m_ndxPoint[0] == pEdge2->m_ndxPoint[0] ) && ( pEdge1->m_ndxPoint[1] == pEdge2->m_ndxPoint[1] ) ) ||
|
|
( ( pEdge1->m_ndxPoint[0] == pEdge2->m_ndxPoint[1] ) && ( pEdge1->m_ndxPoint[1] == pEdge2->m_ndxPoint[0] ) ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Subdivision Quad Functions
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivQuad::GetCentroid( Vector& centroid )
|
|
{
|
|
// get the subdivision mesh
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
VectorClear( centroid );
|
|
for( int i = 0; i < 4; i++ )
|
|
{
|
|
Vector point;
|
|
pMesh->GetPoint( m_ndxVert[i], point );
|
|
VectorAdd( centroid, point, centroid );
|
|
}
|
|
|
|
VectorScale( centroid, 0.25f, centroid );
|
|
|
|
// keep to surface creation
|
|
m_Centroid = centroid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivQuad::CalcCentroid( void )
|
|
{
|
|
// get the subdivision mesh
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
VectorClear( m_Centroid );
|
|
for( int i = 0; i < 4; i++ )
|
|
{
|
|
Vector point;
|
|
pMesh->GetPoint( m_ndxVert[i], point );
|
|
VectorAdd( m_Centroid, point, m_Centroid );
|
|
}
|
|
|
|
VectorScale( m_Centroid, 0.25f, m_Centroid );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivQuad::GetNormal( Vector& normal )
|
|
{
|
|
// get the subdivision mesh
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
Vector points[3];
|
|
Vector segs[2];
|
|
|
|
pMesh->GetPoint( m_ndxVert[0], points[0] );
|
|
pMesh->GetPoint( m_ndxVert[1], points[1] );
|
|
pMesh->GetPoint( m_ndxVert[2], points[2] );
|
|
|
|
VectorSubtract( points[1], points[0], segs[0] );
|
|
VectorSubtract( points[2], points[0], segs[1] );
|
|
|
|
CrossProduct( segs[1], segs[0], normal );
|
|
VectorNormalize( normal );
|
|
|
|
m_Normal = normal;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivQuad::CalcNormal( void )
|
|
{
|
|
// get the subdivision mesh
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CSubdivMesh *pMesh = pDoc->GetSubdivMesh();
|
|
|
|
Vector points[3];
|
|
Vector segs[2];
|
|
|
|
pMesh->GetPoint( m_ndxVert[0], points[0] );
|
|
pMesh->GetPoint( m_ndxVert[1], points[1] );
|
|
pMesh->GetPoint( m_ndxVert[2], points[2] );
|
|
|
|
VectorSubtract( points[1], points[0], segs[0] );
|
|
VectorSubtract( points[2], points[0], segs[1] );
|
|
|
|
CrossProduct( segs[1], segs[0], m_Normal );
|
|
VectorNormalize( m_Normal );
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Subdivision Mesh Functions
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CSubdivMesh::CSubdivMesh()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
CSubdivMesh::~CSubdivMesh()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSubdivMesh::AddPoint( const Vector& point, const Vector& normal )
|
|
{
|
|
//
|
|
// check for existing point within CSubdivPoints
|
|
//
|
|
for( int i = 0; i < m_PointCount; i++ )
|
|
{
|
|
if( CompareSubdivPointToPoint( &m_pPoints[i], point, 0.01f ) )
|
|
return i;
|
|
}
|
|
|
|
if( m_PointCount >= m_MaxPointCount )
|
|
{
|
|
// error message!
|
|
return -1;
|
|
}
|
|
|
|
m_pPoints[m_PointCount].m_Point = point;
|
|
m_pPoints[m_PointCount].m_Normal = normal;
|
|
m_PointCount++;
|
|
|
|
return ( m_PointCount - 1 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::RemovePoint( Vector& point )
|
|
{
|
|
//
|
|
// find point in list (and remove it)
|
|
//
|
|
for( int i = 0; i < m_PointCount; i++ )
|
|
{
|
|
if( !CompareSubdivPointToPoint( &m_pPoints[i], point, 0.01f ) )
|
|
continue;
|
|
|
|
if( i == ( m_PointCount - 1 ) )
|
|
{
|
|
m_pPoints[i].Clear();
|
|
}
|
|
else
|
|
{
|
|
m_pPoints[i].Copy( &m_pPoints[m_PointCount-1] );
|
|
m_pPoints[m_PointCount-1].Clear();
|
|
}
|
|
|
|
m_PointCount--;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSubdivMesh::AddEdge( CSubdivEdge *edge )
|
|
{
|
|
//
|
|
// check for existing edge
|
|
//
|
|
for( int i = 0; i < m_EdgeCount; i++ )
|
|
{
|
|
if( CompareSubdivEdges( edge, &m_pEdges[i] ) )
|
|
{
|
|
//
|
|
// check for "quads" on both sides of edge (add if necessary)
|
|
//
|
|
if( ( !m_pEdges[i].m_pQuads[1] ) && ( edge->m_pQuads[0] != m_pEdges[i].m_pQuads[0] ) )
|
|
{
|
|
m_pEdges[i].m_pQuads[1] = edge->m_pQuads[0];
|
|
m_pEdges[i].m_ndxQuadEdge[1] = edge->m_ndxQuadEdge[0];
|
|
m_pEdges[i].m_Sharpness = 0.0f;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
if( m_EdgeCount >= m_MaxEdgeCount )
|
|
{
|
|
// error message!
|
|
return -1;
|
|
}
|
|
|
|
m_pEdges[m_EdgeCount].Copy( edge );
|
|
m_pEdges[m_EdgeCount].m_Active = true;
|
|
m_EdgeCount++;
|
|
|
|
return ( m_EdgeCount - 1 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::RemoveEdge( CSubdivEdge *edge )
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CatmullClarkSubdivide( void )
|
|
{
|
|
//
|
|
// calculate the "new edge points"
|
|
//
|
|
for( int i = 0; i < m_EdgeCount; i++ )
|
|
{
|
|
m_pEdges[i].CalcNewEdgePoint();
|
|
m_pEdges[i].CalcNewEdgeNormal();
|
|
}
|
|
|
|
//
|
|
// if point index if part of edge, add to point edge list and increment valence
|
|
//
|
|
for( i = 0; i < m_PointCount; i++ )
|
|
{
|
|
for( int j = 0; j < m_EdgeCount; j++ )
|
|
{
|
|
if( !m_pEdges[j].m_Active )
|
|
continue;
|
|
|
|
if( ( i == m_pEdges[j].m_ndxPoint[0] ) || ( i == m_pEdges[j].m_ndxPoint[1] ) )
|
|
{
|
|
m_pPoints[i].m_pEdges[m_pPoints[i].m_Valence] = &m_pEdges[j];
|
|
m_pPoints[i].m_Valence++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// determine the point's "type"
|
|
//
|
|
for( i = 0; i < m_PointCount; i++ )
|
|
{
|
|
//
|
|
// get the number of sharp incident edges and neighbor data
|
|
//
|
|
int sharpnessCount = 0;
|
|
int sharpnessThreshold = m_pPoints[i].m_Valence - 1;
|
|
bool bHasNeighbors = false;
|
|
|
|
for( int j = 0; j < m_pPoints[i].m_Valence; j++ )
|
|
{
|
|
if( m_pPoints[i].m_pEdges[j]->m_Sharpness > 0.0f )
|
|
{
|
|
sharpnessCount++;
|
|
}
|
|
|
|
if( m_pPoints[i].m_pEdges[j]->m_pQuads[1] )
|
|
{
|
|
bHasNeighbors = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
// determine point type
|
|
//
|
|
if( ( sharpnessCount >= sharpnessThreshold ) || !bHasNeighbors )
|
|
// if( ( sharpnessCount > 2 ) || !bHasNeighbors )
|
|
{
|
|
m_pPoints[i].m_Type = CSubdivPoint::POINT_CORNER;
|
|
continue;
|
|
}
|
|
|
|
if( sharpnessCount > 1 )
|
|
// if( sharpnessCount == 2 )
|
|
{
|
|
m_pPoints[i].m_Type = CSubdivPoint::POINT_CREASE;
|
|
continue;
|
|
}
|
|
|
|
m_pPoints[i].m_Type = CSubdivPoint::POINT_ORDINARY;
|
|
}
|
|
|
|
//
|
|
// calculate the new vertex point
|
|
//
|
|
for( i = 0; i < m_PointCount; i++ )
|
|
{
|
|
m_pPoints[i].CalcNewVertexPoint();
|
|
m_pPoints[i].CalcNewVertexNormal();
|
|
}
|
|
|
|
//
|
|
// move all new points to points
|
|
//
|
|
for( i = 0; i < m_PointCount; i++ )
|
|
{
|
|
m_pPoints[i].m_Point = m_pPoints[i].m_NewPoint;
|
|
m_pPoints[i].m_Normal = m_pPoints[i].m_NewNormal;
|
|
VectorClear( m_pPoints[i].m_NewPoint );
|
|
VectorClear( m_pPoints[i].m_NewNormal );
|
|
m_pPoints[i].m_Valence = 0;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSubdivMesh::AddTree( CSubdivQuad *pTree )
|
|
{
|
|
//
|
|
// check to see if tree already exists in list
|
|
//
|
|
for( int i = 0; i < m_TreeCount; i++ )
|
|
{
|
|
if( pTree == m_ppTrees[i] )
|
|
return i;
|
|
}
|
|
|
|
//
|
|
// check tree count
|
|
//
|
|
if( m_TreeCount >= m_MaxTreeCount )
|
|
{
|
|
// error message
|
|
_asm int 3;
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// add tree to list
|
|
//
|
|
m_ppTrees[m_TreeCount] = pTree;
|
|
m_TreeCount++;
|
|
|
|
return ( m_TreeCount - 1 );
|
|
}
|
|
|
|
static HCURSOR preSubdivCursor;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CSubdivMesh::PreSubdivide( void )
|
|
{
|
|
// change the mouse to hourglass -- so level designers know something is
|
|
// happening
|
|
preSubdivCursor = SetCursor( LoadCursor( NULL, IDC_WAIT ) );
|
|
|
|
// clear the mesh
|
|
Clear();
|
|
|
|
//
|
|
// get the selection set
|
|
//
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return false;
|
|
|
|
CDispManager *pDispManager = pDoc->GetDispManager();
|
|
if( !pDispManager )
|
|
return false;
|
|
|
|
// get number of displacements in selection
|
|
int selectionCount = pDispManager->GetSelectionListCount();
|
|
|
|
// allocate memory
|
|
if( !AllocCache( selectionCount ) )
|
|
return false;
|
|
|
|
// mark the subdivision undo
|
|
GetHistory()->MarkUndoPosition( NULL, "Subdivision" );
|
|
|
|
//
|
|
// add all surfaces to mesh to subdivide
|
|
//
|
|
for( int i = 0; i < selectionCount; i++ )
|
|
{
|
|
// get the current displacement surface
|
|
CMapDisp *pDisp = pDispManager->GetFromSelectionList( i );
|
|
if( !pDisp )
|
|
continue;
|
|
|
|
//
|
|
// setup for undo
|
|
//
|
|
CMapFace *pFace = ( CMapFace* )pDisp->GetParent();
|
|
CMapSolid *pSolid = ( CMapSolid* )pFace->GetParent();
|
|
GetHistory()->Keep( ( CMapClass* )pSolid );
|
|
|
|
//
|
|
// add displacement's subdivision tree to mesh list
|
|
//
|
|
if( AddTree( pDisp->PreSubdivide( this ) ) == -1 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::SetEdgeData( CSubdivQuad *pRoot, int index, int parentIndex, int subdivIndex )
|
|
{
|
|
for( int i = 0; i < 4; i++ )
|
|
{
|
|
CSubdivEdge edge;
|
|
|
|
//
|
|
// add vert indices
|
|
//
|
|
edge.m_ndxPoint[0] = pRoot[index].m_ndxVert[i];
|
|
edge.m_ndxPoint[1] = pRoot[index].m_ndxVert[(i+1)%4];
|
|
|
|
//
|
|
// set initial quads and edges data
|
|
//
|
|
edge.m_pQuads[0] = &pRoot[index];
|
|
edge.m_pQuads[1] = NULL;
|
|
|
|
edge.m_ndxQuadEdge[0] = i;
|
|
edge.m_ndxQuadEdge[1] = -1;
|
|
|
|
//
|
|
// set edge sharpness
|
|
//
|
|
if( ( i == subdivIndex ) || ( i == ( (subdivIndex+3)%4 ) ) )
|
|
{
|
|
edge.m_Sharpness = m_pEdges[pRoot[parentIndex].m_ndxEdge[i]].m_Sharpness;
|
|
}
|
|
else
|
|
{
|
|
edge.m_Sharpness = 0.0f;
|
|
}
|
|
|
|
// add edge to global list
|
|
pRoot[index].m_ndxEdge[i] = AddEdge( &edge );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CreateChildQuad4( CSubdivQuad *pRoot, int index, int parentIndex )
|
|
{
|
|
//
|
|
// set quad indices -- displacement index values
|
|
//
|
|
pRoot[index].m_ndxQuad[0] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[3] ) / 2 );
|
|
pRoot[index].m_ndxQuad[1] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
pRoot[index].m_ndxQuad[2] = ( ( pRoot[parentIndex].m_ndxQuad[2] + pRoot[parentIndex].m_ndxQuad[3] ) / 2 );
|
|
pRoot[index].m_ndxQuad[3] = pRoot[parentIndex].m_ndxQuad[3];
|
|
|
|
//
|
|
// set vert indices
|
|
//
|
|
pRoot[index].m_ndxVert[0] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[3]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[3]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[1] = AddPoint( pRoot[parentIndex].m_Centroid, pRoot[parentIndex].m_Normal );
|
|
pRoot[index].m_ndxVert[2] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[2]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[2]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[3] = pRoot[parentIndex].m_ndxVert[3];
|
|
|
|
// set edge data
|
|
SetEdgeData( pRoot, index, parentIndex, 3 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CreateChildQuad3( CSubdivQuad *pRoot, int index, int parentIndex )
|
|
{
|
|
//
|
|
// set quad indices -- displacement index values
|
|
//
|
|
pRoot[index].m_ndxQuad[0] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
pRoot[index].m_ndxQuad[1] = ( ( pRoot[parentIndex].m_ndxQuad[1] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
pRoot[index].m_ndxQuad[2] = pRoot[parentIndex].m_ndxQuad[2];
|
|
pRoot[index].m_ndxQuad[3] = ( ( pRoot[parentIndex].m_ndxQuad[2] + pRoot[parentIndex].m_ndxQuad[3] ) / 2 );
|
|
|
|
//
|
|
// set vert indices
|
|
//
|
|
pRoot[index].m_ndxVert[0] = AddPoint( pRoot[parentIndex].m_Centroid, pRoot[parentIndex].m_Normal );
|
|
pRoot[index].m_ndxVert[1] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[1]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[1]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[2] = pRoot[parentIndex].m_ndxVert[2];
|
|
pRoot[index].m_ndxVert[3] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[2]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[2]].m_NewEdgeNormal );
|
|
|
|
// set edge data
|
|
SetEdgeData( pRoot, index, parentIndex, 2 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CreateChildQuad2( CSubdivQuad *pRoot, int index, int parentIndex )
|
|
{
|
|
//
|
|
// set quad indices -- displacement index values
|
|
//
|
|
pRoot[index].m_ndxQuad[0] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[1] ) / 2 );
|
|
pRoot[index].m_ndxQuad[1] = pRoot[parentIndex].m_ndxQuad[1];
|
|
pRoot[index].m_ndxQuad[2] = ( ( pRoot[parentIndex].m_ndxQuad[1] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
pRoot[index].m_ndxQuad[3] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
|
|
//
|
|
// set vert indices
|
|
//
|
|
pRoot[index].m_ndxVert[0] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[0]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[0]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[1] = pRoot[parentIndex].m_ndxVert[1];
|
|
pRoot[index].m_ndxVert[2] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[1]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[1]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[3] = AddPoint( pRoot[parentIndex].m_Centroid, pRoot[parentIndex].m_Normal );
|
|
|
|
// set edge data
|
|
SetEdgeData( pRoot, index, parentIndex, 1 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CreateChildQuad1( CSubdivQuad *pRoot, int index, int parentIndex )
|
|
{
|
|
//
|
|
// set quad indices -- displacement index values
|
|
//
|
|
pRoot[index].m_ndxQuad[0] = pRoot[parentIndex].m_ndxQuad[0];
|
|
pRoot[index].m_ndxQuad[1] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[1] ) / 2 );
|
|
pRoot[index].m_ndxQuad[2] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[2] ) / 2 );
|
|
pRoot[index].m_ndxQuad[3] = ( ( pRoot[parentIndex].m_ndxQuad[0] + pRoot[parentIndex].m_ndxQuad[3] ) / 2 );
|
|
|
|
//
|
|
// set vert indices
|
|
//
|
|
pRoot[index].m_ndxVert[0] = pRoot[parentIndex].m_ndxVert[0];
|
|
pRoot[index].m_ndxVert[1] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[0]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[0]].m_NewEdgeNormal );
|
|
pRoot[index].m_ndxVert[2] = AddPoint( pRoot[parentIndex].m_Centroid, pRoot[parentIndex].m_Normal );
|
|
pRoot[index].m_ndxVert[3] = AddPoint( m_pEdges[pRoot[parentIndex].m_ndxEdge[3]].m_NewEdgePoint,
|
|
m_pEdges[pRoot[parentIndex].m_ndxEdge[3]].m_NewEdgeNormal );
|
|
|
|
// set edge data
|
|
SetEdgeData( pRoot, index, parentIndex, 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::CreateChildQuads( CSubdivQuad *pRoot, int quadIndex )
|
|
{
|
|
//
|
|
// create children
|
|
//
|
|
CreateChildQuad1( pRoot, ( ( quadIndex << 2 ) + 1 ), quadIndex );
|
|
CreateChildQuad2( pRoot, ( ( quadIndex << 2 ) + 2 ), quadIndex );
|
|
CreateChildQuad3( pRoot, ( ( quadIndex << 2 ) + 3 ), quadIndex );
|
|
CreateChildQuad4( pRoot, ( ( quadIndex << 2 ) + 4 ), quadIndex );
|
|
|
|
for( int i = 0; i < 4; i++ )
|
|
{
|
|
m_pEdges[pRoot[quadIndex].m_ndxEdge[i]].m_Active = false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::AddQuadToMesh( CSubdivQuad *pQuad )
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSubdivMesh::GetEndIndexFromLevel( int levelIndex )
|
|
{
|
|
switch( levelIndex )
|
|
{
|
|
case 0: { return 0; }
|
|
case 1: { return 4; }
|
|
case 2: { return 20; }
|
|
case 3: { return 84; }
|
|
default: { return 0; }
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSubdivMesh::GetStartIndexFromLevel( int levelIndex )
|
|
{
|
|
switch( levelIndex )
|
|
{
|
|
case 0: { return 0; }
|
|
case 1: { return 1; }
|
|
case 2: { return 5; }
|
|
case 3: { return 21; }
|
|
default: { return 0; }
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::Subdivide( void )
|
|
{
|
|
//
|
|
// subdivide to four levels always (what the trees hold)
|
|
//
|
|
for( int subdivLevel = 0; subdivLevel < 4; subdivLevel++ )
|
|
{
|
|
int startIndex = GetStartIndexFromLevel( subdivLevel );
|
|
int endIndex = GetEndIndexFromLevel( subdivLevel );
|
|
|
|
// subdivide
|
|
CatmullClarkSubdivide();
|
|
|
|
//
|
|
// add subdivision data to subdivision tree
|
|
//
|
|
for( int treeIndex = 0; treeIndex < m_TreeCount; treeIndex++ )
|
|
{
|
|
//
|
|
// get the current tree
|
|
//
|
|
CSubdivQuad *pTree = m_ppTrees[treeIndex];
|
|
if( !pTree )
|
|
continue;
|
|
|
|
//
|
|
// for each quad in the tree (at the given level)
|
|
//
|
|
for( int index = startIndex; index <= endIndex; index++ )
|
|
{
|
|
CreateChildQuads( pTree, index );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::PostSubdivide( void )
|
|
{
|
|
//
|
|
// get the selection set
|
|
//
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
if( !pDoc )
|
|
return;
|
|
|
|
CDispManager *pDispManager = pDoc->GetDispManager();
|
|
if( !pDispManager )
|
|
return;
|
|
|
|
//
|
|
// add all surfaces to mesh to subdivide
|
|
//
|
|
int selectionCount = pDispManager->GetSelectionListCount();
|
|
for( int i = 0; i < selectionCount; i++ )
|
|
{
|
|
// get the current displacement surface
|
|
CMapDisp *pDisp = pDispManager->GetFromSelectionList( i );
|
|
if( !pDisp )
|
|
continue;
|
|
|
|
// post subdivide
|
|
pDisp->PostSubdivide( this );
|
|
}
|
|
|
|
// destroy cache!!!
|
|
FreeCache();
|
|
|
|
// set the cursor back to its previous state (before subdivision
|
|
SetCursor( preSubdivCursor );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::DoSubdivide( void )
|
|
{
|
|
PreSubdivide();
|
|
Subdivide();
|
|
PostSubdivide();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
bool CSubdivMesh::AllocCache( int dispCount )
|
|
{
|
|
#define POINTS_PER_DISP 512
|
|
#define EDGES_PER_DISP 1024
|
|
|
|
m_MaxPointCount = POINTS_PER_DISP * dispCount;
|
|
m_MaxEdgeCount = EDGES_PER_DISP * dispCount;
|
|
m_MaxTreeCount = dispCount;
|
|
|
|
m_pPoints = new CSubdivPoint[m_MaxPointCount];
|
|
m_pEdges = new CSubdivEdge[m_MaxEdgeCount];
|
|
m_ppTrees = new CSubdivQuad*[m_MaxTreeCount];
|
|
|
|
if( !m_pPoints || !m_pEdges || !m_ppTrees )
|
|
{
|
|
FreeCache();
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// clear cache
|
|
//
|
|
for( int i = 0; i < m_MaxPointCount; i++ )
|
|
{
|
|
m_pPoints[i].Clear();
|
|
}
|
|
|
|
for( i = 0; i < m_MaxEdgeCount; i++ )
|
|
{
|
|
m_pEdges[i].Clear();
|
|
}
|
|
|
|
//
|
|
// tell size of cache
|
|
//
|
|
int size = m_MaxPointCount * sizeof( CSubdivPoint );
|
|
size += m_MaxEdgeCount * sizeof( CSubdivEdge );
|
|
size += m_MaxTreeCount * sizeof( CSubdivQuad );
|
|
|
|
TRACE1( "Subdiv Cache: %d\n", size );
|
|
|
|
return true;
|
|
|
|
#undef POINTS_PER_DISP
|
|
#undef EDGES_PER_DISP
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSubdivMesh::FreeCache( void )
|
|
{
|
|
if( m_pPoints )
|
|
{
|
|
delete [] m_pPoints;
|
|
m_pPoints = NULL;
|
|
m_PointCount = 0;
|
|
}
|
|
|
|
if( m_pEdges )
|
|
{
|
|
delete [] m_pEdges;
|
|
m_pEdges = NULL;
|
|
m_EdgeCount = 0;
|
|
}
|
|
|
|
if( m_ppTrees )
|
|
{
|
|
delete [] m_ppTrees;
|
|
m_ppTrees = NULL;
|
|
m_TreeCount = 0;
|
|
}
|
|
|
|
// tell cache destroyed!!
|
|
TRACE0( "Subdiv Cache Destroyed!\n" );
|
|
}
|