/*
============
idAASBuild::GravitationalSubdivision
============
*/
void idAASBuild::GravitationalSubdivision( idBrushBSP &bsp ) {
	numGravitationalSubdivisions = 0;

	common->Printf( "[Gravitational Subdivision]\n" );

	SetPortalFlags_r( bsp.GetRootNode() );
	GravSubdiv_r( bsp.GetRootNode() );

	common->Printf( "\r%6d subdivisions\n", numGravitationalSubdivisions );
}

/*
============
idAASBuild::MergeLeafNodes
============
*/
void idAASBuild::MergeLeafNodes( idBrushBSP &bsp ) {
	numMergedLeafNodes = 0;

	common->Printf( "[Merge Leaf Nodes]\n" );

	MergeLeafNodes_r( bsp, bsp.GetRootNode() );
	bsp.GetRootNode()->RemoveFlagRecurse( NODE_DONE );
	bsp.PruneMergedTree_r( bsp.GetRootNode() );

	common->Printf( "\r%6d leaf nodes merged\n", numMergedLeafNodes );
}

/*
============
idAASBuild::LedgeSubdivision

  NOTE: this assumes the bounding box is higher than the maximum step height
		only ledges with vertical sides are considered
============
*/
void idAASBuild::LedgeSubdivision( idBrushBSP &bsp ) {
	numLedgeSubdivisions = 0;
	ledgeList.Clear();
	common->Printf( "[Ledge Subdivision]\n" );
	bsp.GetRootNode()->RemoveFlagRecurse( NODE_VISITED );
	FindLedges_r( bsp.GetRootNode(), bsp.GetRootNode() );
	bsp.GetRootNode()->RemoveFlagRecurse( NODE_VISITED );
	common->Printf( "\r%6d ledges\n", ledgeList.Num() );
	LedgeSubdiv( bsp.GetRootNode() );
	common->Printf( "\r%6d subdivisions\n", numLedgeSubdivisions );
}

/*
================
idAASBuild::StoreFile
================
*/
bool idAASBuild::StoreFile( const idBrushBSP& bsp )
{
	aasEdge_t edge;
	aasFace_t face;
	aasArea_t area;
	aasNode_t node;
	
	common->Printf( "[Store AAS]\n" );
	
	SetupHash();
	ClearHash( bsp.GetTreeBounds() );
	
	file = new idAASFileLocal();
	
	file->Clear();
	
	SetSizeEstimate( bsp, file );
	
	// the first edge is a dummy
	memset( &edge, 0, sizeof( edge ) );
	file->edges.Append( edge );
	
	// the first face is a dummy
	memset( &face, 0, sizeof( face ) );
	file->faces.Append( face );
	
	// the first area is a dummy
	memset( &area, 0, sizeof( area ) );
	file->areas.Append( area );
	
	// the first node is a dummy
	memset( &node, 0, sizeof( node ) );
	file->nodes.Append( node );
	
	// store the tree
	StoreTree_r( bsp.GetRootNode() );
	
	// calculate area bounds and a reachable point in the area
	file->FinishAreas();
	
	ShutdownHash();
	
	common->Printf( "\r%6d areas\n", file->areas.Num() );
	
	return true;
}

/*
============
idAASBuild::MergeWithAdjacentLeafNodes
============
*/
bool idAASBuild::MergeWithAdjacentLeafNodes( idBrushBSP &bsp, idBrushBSPNode *node ) {
	int s, numMerges = 0, otherNodeFlags;
	idBrushBSPPortal *p;

	do {
		for ( p = node->GetPortals(); p; p = p->Next(s) ) {
			s = (p->GetNode(1) == node);

			// both leaf nodes must have the same contents
			if ( node->GetContents() != p->GetNode(!s)->GetContents() ) {
				continue;
			}

			// cannot merge leaf nodes if one is near a ledge and the other is not
			if ( (node->GetFlags() & AREA_LEDGE) != (p->GetNode(!s)->GetFlags() & AREA_LEDGE) ) {
				continue;
			}

			// cannot merge leaf nodes if one has a floor portal and the other a gap portal
			if ( node->GetFlags() & AREA_FLOOR ) {
				if ( p->GetNode(!s)->GetFlags() & AREA_GAP ) {
					if ( !AllGapsLeadToOtherNode( p->GetNode(!s), node ) ) {
						continue;
					}
				}
			}
			else if ( node->GetFlags() & AREA_GAP ) {
				if ( p->GetNode(!s)->GetFlags() & AREA_FLOOR ) {
					if ( !AllGapsLeadToOtherNode( node, p->GetNode(!s) ) ) {
						continue;
					}
				}
			}

			otherNodeFlags = p->GetNode(!s)->GetFlags();

			// try to merge the leaf nodes
			if ( bsp.TryMergeLeafNodes( p, s ) ) {
				node->SetFlag( otherNodeFlags );
				if ( node->GetFlags() & AREA_FLOOR ) {
					node->RemoveFlag( AREA_GAP );
				}
				numMerges++;
				DisplayRealTimeString( "\r%6d", ++numMergedLeafNodes );
				break;
			}
		}
	} while( p );

	if ( numMerges ) {
		return true;
	}
	return false;
}

/*
================
idAASBuild::SetSizeEstimate
================
*/
void idAASBuild::SetSizeEstimate( const idBrushBSP &bsp, idAASFileLocal *file ) {
	sizeEstimate_t size;

	size.numEdgeIndexes = 1;
	size.numFaceIndexes = 1;
	size.numAreas = 1;
	size.numNodes = 1;

	GetSizeEstimate_r( NULL, bsp.GetRootNode(), size );

	file->planeList.Resize( size.numNodes / 2, 1024 );
	file->vertices.Resize( size.numEdgeIndexes / 3, 1024 );
	file->edges.Resize( size.numEdgeIndexes / 2, 1024 );
	file->edgeIndex.Resize( size.numEdgeIndexes, 4096 );
	file->faces.Resize( size.numFaceIndexes, 1024 );
	file->faceIndex.Resize( size.numFaceIndexes, 4096 );
	file->areas.Resize( size.numAreas, 1024 );
	file->nodes.Resize( size.numNodes, 1024 );
}